九、java容器

一、容器的概念和容器API

容器：java API所提供的一系列的实例，用于在程序中存放对象

JDK所提供的容器API位于java.util包内

容器API的类图结构如下图所示：

左边的容器都是一个个往里装，右边的容器也就是map这一边的是一对一对往里装

Collection接口定义了存取一组对象的方法，他代表了一个集合，他下面分了两个子接口set和list。

装东西的时候set是没有顺序并且不可以重复，list是有顺序可以重复，所谓的重复是指两个对象equals

Map接口定义了存储“键(key) –值(value)” 映射对的方法

二、Collection接口

Collection接口中所定义的方法：

int size();
boolean isEmpty();
void clear();
boolean contains(Object element);//查看是否包含某一个对象
bllean add(Object element);
boolean remove(Object element);
Iterator iterator();
boolean containsAll(collection c);
bllean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);//交集
object[] toArray();

看一个例子：

public class Test{

    public static void main(String[] args) {
        Collection c = new ArrayList();//父类引用指向子类对象
        //可以放入不同类型的对象
        c.add("hello");
        c.add(new Name("f1","l1"));
        c.add(new Integer(100));
        System.out.println(c.size());
        System.out.println(c);
    }    

}
//输出结果：
//3
//[hello, f1 l1, 100]

public class Test{

    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("hello");
        c.add(new Name("f1","l1"));
        c.add(new Integer(100));
        c.remove("hello");
        c.remove(new Integer(100));
        System.out.println(c.remove(new Name("f1","l1")));
        System.out.println(c);
    }
}
//输出结果：
//false
//[f1 l1]
//因为两个Name("f1","l1")指向的不是同一个对象，所以equals方法返回false

容器类对象在调用remove、contains等方法时需要比较对象是否相等，这回涉及到对象类型的equals方法和hashCode方法；对于自定义的类型，需要重写equals和hashCode方法以实现自定义的对象相等规则

注意：相等的对象应该具有相等的hashCode

增加Name类的equals和hashCode方法如下：

public boolean equals(Object obj) {
    if (obj instanceof Name) {
        Name name = (Name) obj;
        return (firstName.equals(name.firstName))&&(lastName.equals(name.lastName));
    }
    return super.equals(obj);
}
public int hashCode() {
    return firstName.hashCode();
}

这样那个例子代码结果就会变为true 和[]了

三、Iterator接口

所有实现了collection接口的容器类都由一个interator方法用以返回一个实现了Interator接口的对象
Interator对象称作迭代器，用以方便的实现对容器内元素的遍历操作
Iterator接口定义了如下方法：

boolean hasNext();//判断游标右边是否有元素

Object next();//返回游标右边的元素并将游标移动到下一个位置

void remove();//删除游标左面的元素，在执行完next之后

看一个例子：

public class Test{

    public static void main(String[] args) {

        Collection c = new HashSet();
        c.add(new Name("f1","l1"));
        c.add(new Name("f2","l2"));
        c.add(new Name("f3","l3"));
        //遍历
        Iterator i = c.iterator();
        while(i.hasNext()) {
            //由于next()的返回值为Object类型，需要转换为相应类型
            Name n = (Name)i.next();
            System.out.print(n.getFirstName()+" ");
        }
    }
}

//输出结果
//f1 f2 f3

Iterator对象的remove方法是在迭代过程中删除元素的唯一的安全方法

public class Test{

    public static void main(String[] args) {

        Collection c = new HashSet();
        c.add(new Name("ffff1","lllll1"));
        c.add(new Name("f2","l2"));
        c.add(new Name("fff3","llll3"));

        for (Iterator i = c.iterator(); i.hasNext();) {
            Name name = (Name)i.next();
            if (name.getFirstName().length()<3) {
                i.remove();
                //如果换成c.remove(name);会产生例外
            }
        }

        System.out.println(c);
    }
}

//输出结果：[fff3 llll3, ffff1 lllll1]

四、增强的for循环

增强的for循环对于遍历array或Collection的时候非常简便

看一个例子先：

public class Test{

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.print(i + " ");//遍历输出
        }

        System.out.println();

        Collection c = new ArrayList();
        c.add(new String("aaa"));
        c.add(new String("bbb"));
        c.add(new String("vvv"));
        for (Object o : c) {
            System.out.print(o + " ");//遍历输出
        }
    }
}

缺陷：

对于数组来说不能方便的访问下标值
对于集合来说，与使用Iterator来说，不能方便的删除集合中的内容（在for循环内部也调用Itertor）

所以，除了简单遍历并读出其中的内容外，不建议使用增强for

五、Set接口

Set接口是Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有有顺序的，而且不可以重复

Set容器可以与数学中的集合的概念相对应

J2SDK 的API中所提供的Set容器类有HashSwt，TreeSet等

看一个例子：

public class Test{

    public static void main(String[] args) {

        Set s = new HashSet();
        s.add("hello");
        s.add("world");
        s.add(new Name("f1", "l1"));
        s.add(new Integer(100));
        s.add(new Name("f1", "l1"));//相同元素不会被加入
        s.add("hello");//相同元素不会被加入
        System.out.print(s + "    ");
    }
}
//输出结果：[world, 100, hello, f1 l1]

再看一个例子：

public class Test{

    public static void main(String[] args) {

        Set s1 = new HashSet();
        Set s2 = new HashSet();

        s1.add("a");
        s1.add("b");
        s1.add("c");

        s2.add("a");
        s2.add("b");
        s2.add("d");

        Set sn = new HashSet(s1);
        sn.retainAll(s2);//交集
        Set su = new HashSet(s1);
        su.addAll(s2);

        System.out.println("su = "+ su);
        System.out.println("sn = "+ sn);

    }
}
//输出结果：
//su = [a, b, c, d]
//sn = [a, b]

六、List接口和Comparable接口

1.List接口

List接口是Collection的子接口，实现List接口的俄容器类中的元素是有顺序的，而且可以重复

List的容器重点额元素都对应一个整数型的序号级再其在容器中的位置，可以根据序号存取容器中的元素

J2SDK所提供的List容器类有ArrayList，LinkedList等

Object get(int index);
Object set(int index,Object lement);
void add(int index,Object element);
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);

看一个例子：

public class Test{

    public static void main(String[] args) {

        LinkedList l1 = new LinkedList();
        for (int i=0; i<=5; i++) {
            l1.add("a" + i);
        }
        System.out.println(l1);//[a0, a1, a2, a3, a4, a5]
        l1.add(3,"a100");
        System.out.println(l1);//[a0, a1, a2, a100, a3, a4, a5]
        l1.set(6, "a200");
        System.out.println(l1);//[a0, a1, a2, a100, a3, a4, a200]
        System.out.println((String)l1.get(2)+ " ");//a2
        System.out.println(l1.indexOf("a3"));//4
        l1.remove(1);
        System.out.println(l1);//[a0, a2, a100, a3, a4, a200]

    }
}

List常用算法

void sort(List) //对list容器内的元素排序
void shuffle(List) //对list容器内的对象进行随机排列
void reverse(List) //岁list容器内的对象进行逆序排列
void fill(List,Object) //用一个特定的对象重写整个List容器
void copy(List dest,list src) //将srcList容器内容拷贝到destList容器
void binarySearch(List,Object) //对于顺序的list容器，采用着办查找的方法查找特定对象

看一个例子：

public class Test{

    public static void main(String[] args) {

        LinkedList l1 = new LinkedList();

        for(int i=0; i<=9; i++) {
            l1.add("a" + i);
        }

        System.out.println(l1);//[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
        Collections.shuffle(l1);//随机排列
        System.out.println(l1);//[a9, a2, a7, a4, a1, a5, a3, a6, a8, a0]
        Collections.reverse(l1);//逆序
        System.out.println(l1);//[a0, a8, a6, a3, a5, a1, a4, a7, a2, a9]
        Collections.sort(l1);//排序
        System.out.println(l1);//[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
        System.out.println(Collections.binarySearch(l1, "a5"));//折半查找,结果为5        

    }
}

2.Comparable接口

所有可以”排序”的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法：

public int compareTo(Object obj);

该方法：

返回0表示this == obj
返回正数表示this>obj
返回负数表示this <obj

实现了Comparable接口的类通过实现compataTo方法从而确定该类对象的排序方式

八、Map接口

实现Map接口的类用来存储键-值对

Map接口的实现类有HashMap和TreeMap等

Map类中存储的键-值对通过键来标识，所以键值不能重复

Object put(Object key,Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();

看一个例子：

public class Test{

    public static void main(String[] args) {

        Map m1 = new HashMap();
        Map m2 = new TreeMap();

        m1.put("one", new Integer(1));
        m1.put("two", new Integer(2));
        m1.put("three", new Integer(3));

        m2.put("A", new Integer(1));
        m2.put("B", new Integer(2));

        System.out.println(m1.size());//3
        System.out.println(m1.containsKey("one"));//true
        System.out.println(m2.containsValue(new Integer(1)));//true

        if (m1.containsKey("two")) {
            int i = ((Integer)m1.get("two")).intValue();
            System.out.println(i);//2
        }

        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);//{A=1, B=2, two=2, three=3, one=1}
    }
}

九、自动打包/解包

在合适的时机自动打包、解包（JDK1.5之后的版本支持）

自动将基础类型转换为对象（打包）
自动将对象转换为基础类型（解包）

如此，上面的例子可以这么写：

public class Test{

    public static void main(String[] args) {

        Map m1 = new HashMap();
        Map m2 = new TreeMap();

        m1.put("one", 1);
        m1.put("two", 2);
        m1.put("three", 3);

        m2.put("A", 1);
        m2.put("B", 2);

        System.out.println(m1.size());//3
        System.out.println(m1.containsKey("one"));//true
        System.out.println(m2.containsValue(1));//true

        if (m1.containsKey("two")) {
            int i = ((Integer)m1.get("two"));
            System.out.println(i);//2
        }

        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);//{A=1, B=2, two=2, three=3, one=1}
    }
}

看一个练习例子：

/*
 * 注释掉的代码是使用了自动打包和解包进行的代码简化
 */
public class Test{

    private static final Integer ONE = new Integer(1);
    //private static final int ONE = 1;

    public static void main(String[] args) {

        Map m = new HashMap();

        for(int i=0; i<args.length; i++) {
            Integer freq = (Integer)m.get(args[i]);
            //int freq = (Integer)m.get(args[i]);
            m.put(args[i], (freq == null ? ONE : new Integer(freq.intValue() +1)));
            //m.put(args[i], freq==0 ? ONE : freq + 1);
        }

        System.out.println(m.size() + " distinct words detected: ");
        System.out.println(m);

    }
}

这是一个统计传外部参次数的例子

十、泛型（JDK1.5以后新增）

起因：

JDK1.4以前类型不明确：

装入集合的类型都被当作Object对待，从而时区自己的实际类型
从集合中取出时往往需要转型，效率低，容易产生错误

解决办法：

在定义集合的时候同事定义集合中对象的类型
可以在定义Collection的时候指定
也可以在循环时用Iterator指定

好处：

增强程序的可读性和稳定性

看一个例子：

public class Test{
    public static void main(String[] args) {

        List<String> c = new ArrayList<String>();
        c.add("aaa");
        c.add("bbb");
        c.add("ccc");
        for(int i=0; i<c.size(); i++) {
            String s = c.get(i);
            System.out.println(s);
        }

        Collection<String> c2 = new HashSet<String>();
        c2.add("aaa");
        c2.add("bbb");
        c2.add("ccc");
        for(Iterator<String> it = c2.iterator(); it.hasNext();) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

在看一个例子：

public class Test{
    public static void main(String[] args) {

        Map<String,Integer> m1 = new HashMap<String,Integer>();
        m1.put("one", 1);
        m1.put("two", 2);
        m1.put("three", 3);

        System.out.println(m1.size());
        System.out.println(m1.containsKey("one"));

        if(m1.containsKey("two")) {
            int i = m1.get("two");
            System.out.println(i);
        }
    }
}

时间： 2024-10-14 08:58:01

九、java容器的相关文章

Java 容器 & 泛型：一、认识容器

Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 容器是Java语言学习中重要的一部分.泥瓦匠我的感觉是刚开始挺难学的,但等你熟悉它,接触多了,也就"顺理成章"地知道了.Java的容器类主要由两个接口派生而出:Collection和Map. 一.Collection vs Collections 首先,Collection 和 Collections 是两个不同的概念.之所以放在一起,是为了更好的比较.Collection是容器层次结构中

Java 容器

在实际问题中我们经常需要处理数据,单纯依靠数组来存储数据对开发来说非常困难,java提供了一套容器来方便我们编程.对java容器有一个整体的了解对我们来说非常重要,这样在需要特定容器时,不会手忙脚乱,本文主要介绍java的一些基本容器,而不要仅知道使用ArrayList.下面的图片是java中的简单容器分类 --图片来自网络 java定义了四种容器类型,List.Set.Queue和Map. 其中List.Set.Queue都实现了Collection接口,下面来看看这4中类型的容器. Co

java容器---集合总结

思考为什么要引入容器这个概念? Java有多种方式保存对象(应该是对象的引用),例如使用数组时保存一组对象中的最有效的方式,如果你想保存一组基本类型的数据,也推荐使用这种方式,但大家知道数组是具有固定尺寸的,你必须事先知道你要需要多少个对象.但是在一般的情况中,你在写程序中并不知道将需要多少个对象,或者是否需要更加复杂的方式来存储对象,因此数组尺寸固定很不爽! 为了解决上述问题,引入了容器的概念.容器提供了完善的方法来保存对象,你可以使用这些工具来解决数量惊人的问题.Java容器类可以自动调整自

Java 容器在实际web项目中应用

前言:在java开发中我们离不开集合数组等,在java中有个专有名词:"容器" ,下面会结合Thinking in Java的知识和实际开发中业务场景讲述一下容器在Web项目中的用法.可结合图片代码了解Java中的容器备注 :这个地方 ,参考于朝向远方的博客Java容器详解,既然前人总结的这么好,我就直接拿来用,在这里更注重在实际开发中的例子,感谢那些总结的前辈们,辛苦了. 简单的数组例子 Thinking in Java 中并没有把数组归为Java的容器,实际上数组的确不是Java

Java 容器在实际项目中的应用

Java面试题-Java容器

一.Java容器分类 Java容器划分为两个概念Collection.Map Collection: 一个独立元素的序列,这些元素都服从一条或多条规则.List必须按照插入的顺序保存元素,不关心是否重复:Set不能有重复元素:Queue一端插入一端输出.所有的Collection都可以用foreach语法遍历实现:List:ArrayList.LinkedList: Set:HashSet.TreeSet.LinkedHashSet Map:HashMap.TreeMap.Linked

java容器集合类

容器就是容纳物品,放置物品的东西,对Java来说,一切皆是对象,他的容器就是能保存java的对象的类.由于数据容器中存放了我们随时可能需要使用到的对象引用,所以一般的数据容器要都要能能提供方便的查询.遍历.修改等基本接口功能. 早期的OOP语言都通过数组的方式来实现对引用集的集中管理和维护.但是数组方式下,数组大小需要提前被确定,并不允许修改大小,导致其作为一种灵活的数据容器的能力的功能大为下降. 为了方便的利用数据容器进行引用的管理,Java中提供了丰富的数据容器以满足程序员多样化的需求. j

九:Java之包

Java包(package) 为了更好地组织类,Java提供了包机制,用于区别类名的命名空间. 一.包的作用 java中"包"的引入的主要原因是java本身跨平台特性的需求.因为java中的所有的资源也是以文件方式组织,这其中主要包含大量的类文件需要组织管理.java中同样采用了目录树形结构.虽然各种常见操作系统平台对文件的管理都是以目录树的形式的组织,但是它们对目录的分隔表达方式不同,为了区别于各种平台,java中采用了"."来分隔目录. 1 把功能相似或相关的类

java 容器Collection List Set Map概述

对JAVA的集合的理解是想对于数组数组是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型) JAVA集合可以存储和操作数目不固定的一组数据. 所有的JAVA集合都位于 java.util包中! JAVA集合只能存放引用类型的的数据,不能存放基本数据类型. JAVA集合主要分为三种类型: Set(集) List(列表) Map(映射) Collection 接口 Collection是最基本的集合接口,声明了适用于JAVA集合(只包括Set和List)的通用方法. Set 和

Java 容器相关知识全面总结

Java实用类库提供了一套相当完整的容器来帮助我们解决很多具体问题.因为我本身是一名Android开发者,包括我在内很多安卓开发,最拿手的就是ListView(RecycleView)+BaseAdapter+ArrayList三剑客, 平时接触使用的容器也只有ArrayList和HashMap.导致对于整个Java容器体系的掌握和使用还停留在很浅的层面.省不足而思改进,那么跟着我来总结一下Java容器的相关知识吧. 结构 java容器类的继承结构具体介绍迭代器 Collection Lis