JAVA集合(Collection)

一、集合是什么？

Java集合类是一个用来存放对象的容器,它存放于 java.util 包中，其中每一个对象叫元素。

注意：①、集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。

　　　②、集合存放的是多个对象的引用，对象本身还是放在堆内存中。

　　　③、集合可以存放不同类型，不限数量的数据类型。

---

 

二、Java 集合框架图

此图来源于：http://blog.csdn.net/u010887744/article/details/50575735

大图可以点此访问：//img-blog.csdn.net/20160124221843905

 

---

 

 三、集合详解

　　从上图可以看到Map接口和Collection接口是所有集合框架的父接口，Java常用的集合包括List,Set，以及Map。而List，Set和Map都是接口，其中List接口，Set接口是继承了Collection接口，而Map接口是没有继承Collection接口，因为List和Set集合一般放的单个对象，Map放的是键值对，也就是成对的两个对象，键值对就是可以根据一个键值获得对应的一个值，因为Collection不具备这种特点，所以Map并没有继承Collection。

1.先谈谈接口：Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements），我们看一下Collection接口的使用:

        //我们这里将 ArrayList集合作为 Collection 的实现类
        Collection collection = new ArrayList();
        
        //添加元素
        collection.add("AA");
        collection.add("BB");
        collection.add("CC");

       //检测是否存在某个元素
        collection.contains("AA");

        //删除指定元素
        collection.remove("AA");

        //判断是否为空
        collection.isEmpty();

        //删除所有元素
        Collection del = new ArrayList();
        del .add("CC");
        collection.removeAll(del );
                               
        //利用增强for循环遍历集合
        for(Object obj : collection){
            System.out.println(obj);
        }
        //利用迭代器 Iterator
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }    

代码中谈到了Iterator，就先说一下Iterator

(1)Iterator:迭代器,它可以说是Collection分支集合的顶层接口，它的内部封装了三个方法，用来遍历集合：

　　  next()：返回迭代器刚越过的元素的引用，返回值是 Object，需要强制转换成自己需要的类型

　　hasNext()：判断容器内是否还有可供访问的元素

　　remove()：删除迭代器刚越过的元素

 　　　　//构造 List 的迭代器
        Iterator it = list.iterator();
        //通过迭代器遍历元素
        while(it.hasNext()){        //list中是否存在下一个对象
            Object obj = it.next(); //遍历，并赋值给对象
            System.out.println(obj);//输出
        }

 下面来说一下Collection接口下面的list接口和set接口

(2)List集合：有序可重复(顺序是按照放入的顺序排列的，可重复指的是可以放入一样的元素)

List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等,现在分别说一下它们的实现：

　　①ArrayList ：List list1 = new ArrayList();

　　底层：使用数组实现 。

　　特点：查找效率高，随机访问效率高，增删效率低，非线程安全的。

　　代码：实现Arrarylist的基本操作。

 

//生成arrayList实例对象    
 List arrayList= new ArrayList();

//ArrayList的添加：  
  arrayList.add("a"); //在末尾添加元素   
  arrayList.add("b");  
  arrayList.add("c");  
  arrayList.add("d");  
  arrayList.add("e");  
  arrayList.add(2,"f");//在指定位置插入元素  

//ArrayList的删除  
  arrayList.remove(2);//移除下标为2的元素  

//ArrayList的修改  
  arrayList.set(0,"a");//把下标为1的元素修改为元素"a"  

//ArrayList的查询，这里需要遍历ArrayList  
//普通for语句遍历  
for(int i=0;i<arrayList.size();i++){  
  System.out.println(list.get(i));
}   

//迭代器方式：  
 //构造 List 的迭代器
Iterator intertor= list.iterator();
while(intertor.hasNext()){  
   Object obj = it.next();
   System.out.println(obj);
}

 　　②LinkedList：List list2 = new LinkedList()

　　底层：使用双向循环链表实现。 
　　特点：查找效率低，随机访问效率低，增删效率高，非线程安全的 
　　代码：与实现Arrarylist的基本操作基本一致，此处已不再声明。

　　③Vector：List list3 = new Vector();

　　底层：底层数据结构是数组。 
　　特点：查询快，增删慢;线程安全，效率低(Vector是线程安全，因为是线程安全的，所以效率上比ArrayList要低)

　　代码：与实现Arrarylist的基本操作基本一致。

 List list = new Vector();
        list.add("A");
        list.add("B");
        list.add("C");

        list.remove("A");
        list.set(0,"修改");

        list.add(2,"新增");

        for(Object obj:list)
        {
            System.out.println(obj);
        }

        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }

 

　　④Stack：就是我们常说到的栈

　　底层：Stack实际上也是通过数组去实现的。

　　继承：Stack继承于Vector，意味着Vector拥有的属性和功能，Stack都拥有。

　　方法：empty(),peek(),pop(),push(E object),search(Object o);下面通过实际的例子来描述一下：　

Stack stack = new Stack();
        //添加
        stack.push("A");
        stack.push("B");
        stack.push("C");
        stack.push("D");

        //查找“A”在栈中的位置
        int pos = stack.search("A");
        System.out.println("the postion of A is:"+pos);

        // pop栈顶元素，取出栈顶元素，并将该元素从栈中删除
        stack.pop();

        // peek栈顶元素，取出栈顶元素，不执行删除
        String val = (String)stack.peek();
        System.out.println("peek:"+val);

        
        // 遍历并打印出该栈
        Iterator iterator = stack.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }

对于List中的集合的几种特点怎么来记呢？无非底层就是数组和链表两种，可以这样来记：

　　数组就像身上编了号站成一排的人，要找第10个人很容易，根据人身上的编号很快就能找到。但插入、删除慢，要望某个位置插入或删除一个人时，后面的人身上的编号都要变。当然，加入或删除的人始终末尾的也快。

　　链表就像手牵着手站成一圈的人，要找第10个人不容易，必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手，并重新牵上新加进来的人的手就可以。删除一样的道理。

(3)Set集合：无序不可重复

Set接口的实现类主要有：hashSet、treeSet 、linkedHashSet

　　① hashSet：Set hashSet = new HashSet();

　　底层：使用哈希表实现 

　　特点：不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;判断重不重复，是通过对象本身的hashCode()方法和equals()方法决定的，下图可以详细理解元素是否重复。

 

 　　方法：下面通过例子来了解一下

　　　　 Set hashset = new HashSet();
        //增
        hashset.add("A");
        hashset.add("B");
        hashset.add("C");
        //删除
        hashset.remove("A");
        System.out.println(hashset.contains("A"));
        //查
        for(Object obj:hashset)
        {
            System.out.println(obj);
        }

        Iterator iterator = hashset.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }

　　②treeSet ：Set treeSet = new TreeSet();

　　底层：使用红黑树算法，擅长于范围查询

　　特点：有序；不可重复

　　实现：

        TreeSet set = new TreeSet();
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");
        set.add("eee");
        set.add("ddd");
        set.add("ccc");
        //正序遍历
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
        //逆序遍历
        Iterator iterator1 = set.descendingIterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            System.out.println(obj);
        }

　　③linkedHashSet ：Set linkedHashSet = new LinkedHashSet()　

　　底层：底层采用 链表 和 哈希表

　　特点：有序；不可重复

下面我们说一下三个set接口实现类的异同：

相同点：都不允许元素重复，都不是线程安全的类，解决办法：Set set = Collections.synchronizedSet(set 对象)

不同点：

　　HashSet:不保证元素的添加顺序，底层采用 哈希表算法，查询效率高。判断两个元素是否相等，equals() 方法返回 true,hashCode() 值相等。即要求存入 HashSet 中的元素要覆盖 equals() 方法和 hashCode()方法

　　LinkedHashSet:HashSet 的子类，底层采用了哈希表算法以及链表算法，既保证了元素的添加顺序，也保证了查询效率。但是整体性能要低于 HashSet　　　　

　　TreeSet:不保证元素的添加顺序，但是会对集合中的元素进行排序。底层采用 红-黑 树算法（树结构比较适合范围查询）