Java集合框架之Collection实例解析

转载自https://blog.csdn.net/qq_28261343/article/details/52614411

0、集合引入

1)集合的由来?

Java是面向对象编程语言，经常操作很多对象，必要时需存储对象（达到复用或管理等目的），常见容器如数组和StringBuffer（或StringBuilder，前者线程安全，效率较低，为了提高效率而引进)。

通常数组的长度固定，所以不适合做变化的需求（可以手动去重新分配调整，较麻烦），而StringBuffer(或StringBuilder)存储元素为字符串，皆不符合存储任意元素的要求。因此集合就应运而生了。

2)集合和数组的区别?

• 1 长度限制之别

  • 数组长度是固定不变的
  • 集合的大小是可动态变化的

• 2 存储类型之别

  • 一个数组存储的元素可以是基本类型，也可以是引用类型，且只能存储同一种类型的元素
  • 一个集合存储的元素只能是引用类型，但集合可以存储不同类型的元素(但集合一般存储同一种类型，可以用泛型加以控制)

• 3 访问元素方式

  • 数组是根据索引来获取元素的
  • 集合通常会提供一个迭代器来方便访问元素

3）java集合框架初窥

 
注：图片来源于网络。类已经很全了，就不赘画了。

---

1、Collection之继承体系

Collection<E> 接口是所有单列集合的共同父接口，下面列出了常用的Collection子类集合及其继承关系。

Collection
    |-----List  有序(存储顺序和取出顺序一致)，可重复

        |----ArrayList ，线程不安全，底层使用数组实现，查询快，增删慢。效率高。
                每次容量不足时，自增长度的一半，如下源码可知
                  int newCapacity = oldCapacity + (oldCapacity >> 1);
        |----LinkedList ， 线程不安全，底层使用链表实现，查询慢，增删快。效率高

        |----Vector ， 线程安全，底层使用数组实现，查询快，增删慢。效率低
                每次容量不足时，默认自增长度的一倍（如果不指定增量的话），如下源码可知
                   int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    |-----Set   元素唯一
    一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

        |--HashSet 底层是由HashMap实现的，通过对象的hashCode方法与equals方法来保证插入元素的唯一性，无序(存储顺序和取出顺序不一致)。

            |--LinkedHashSet 底层数据结构由哈希表和链表组成。哈希表保证元素的唯一性，链表保证元素有序。(存储和取出是一致)

        |--TreeSet 基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 元素唯一。

---

2、Collection泛型接口

方法摘要

 boolean add(E e) 
              确保此 collection 包含指定的元素（可选操作）。 
     boolean addAll(Collection<? extends E> c) 
              将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 
     void clear() 
              移除此 collection 中的所有元素（可选操作）。 
     boolean contains(Object o) 
              如果此 collection 包含指定的元素，则返回 true。 
     boolean containsAll(Collection<?> c) 
              如果此 collection 包含指定 collection 中的所有元素，则返回 true。 
     boolean equals(Object o) 
              比较此 collection 与指定对象是否相等。 
     int hashCode() 
              返回此 collection 的哈希码值。 
     boolean isEmpty() 
              如果此 collection 不包含元素，则返回 true。 
     Iterator<E> iterator() 
              返回在此 collection 的元素上进行迭代的迭代器。 
     boolean remove(Object o) 
              从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 
     boolean removeAll(Collection<?> c) 
              移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 
     boolean retainAll(Collection<?> c) 
              仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 
     int size() 
              返回此 collection 中的元素数。 
     Object[] toArray() 
              返回包含此 collection 中所有元素的数组。 
    <T> T[] 
     toArray(T[] a) 

使用Collection示例

public class CollectionReview {
    public static void main(String[] args) {
        test1();

    }

    private static void test1() {
        // Collection<E>为接口，使用多态进行创建
        Collection<String> collection = new Vector<>();
        collection.add("gogogo");
        collection.add("pap");
        collection.add("niko");
        collection.add("kitty");

        Collection<String> coll = new ArrayList<>();
        coll.add("niko");
        coll.add("kitty");
        coll.add("pecuyu");

        // collection.clear(); // 清空集合
         //System.out.println(collection.isEmpty()); // 集合是否为空

        // int size = collection.size(); // 获取集合大小
        // System.out.println(size);  

        // boolean contains = collection.contains("niko"); // 是否包含另一个元素
        // System.out.println(contains);
        //boolean containsAll = collection.containsAll(coll); //是否完全包含另一个集合
        //System.out.println(containsAll);

        // collection.remove("kitty");   // 删除第一个匹配项，删除了匹配项则返回true
        // boolean removeAll = collection.removeAll(coll);  // 删除与指定集合有交集的部分，原集合有改变就返回true
        // System.out.println(removeAll);

        //boolean retainAll = collection.retainAll(coll);// 保留与指定集合有交集的部分，原集合有改变就返回true
        //System.out.println(retainAll);

    // iterator 迭代器， 方式1
        Iterator<String> iterator = collection.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println("\n"+"-------------------");

    // 方式2 ，for循环完iterator1就会被销毁，节约内存提高效率
        for (Iterator<String> iterator1 = collection.iterator(); iterator1.hasNext(); ) {
            System.out.print(iterator1.next()+" ");

        }
        System.out.println("\n"+"-------------------");


        Object[] array = collection.toArray();  // 转化为object数组
        for (Object string : array) {
            System.out.print(string+" ");
        }
        System.out.println("\n"+"-------------------");
        String[] arr=new String[collection.size()];
        String[] array2 = collection.toArray(arr);  // 指定要转化的数组类型
        for (String string : array2) {
            System.out.print(string+" ");
        }
    }