Java 容器

前言：在java开发中我们会大量的使用集合，在这里我将总结常见的集合类，每个集合类的优点和缺点，以便我们能更好的使用集合。

关于简单容器分类的结构图

此处输入图片的描述

以上是容器的分类情况，其中比较常用的就是图中红色圈出的部分.点线框表示接口，实线框表示具体的类。

1.基本概念

• Collection:一个独立元素的序列，这些元素都服从一条或多条规则，是大多数集合类型的接口。List必须按插入顺序保存元素，而Set不能有重复元素。Queue按照排队的规则来确定对象产生的顺序（通常与他们被插入的顺序一样）

• Map:一组成对的"键值对"对象，允许你使用键来查找值。映射表允许我们使用另一个对象来查找某个对象，它也被称作"关联数组".

2.List

• ArrayList:
  （1） 长于随机访问元素，但是在List的中间的插入和移除元素较慢。如果是大量的随机访问，建议使用ArrayList。
  （2）ArrayList就是数组列表，主要用来装载数据，当我们装载的是基本类型的数据int,long,boolean,short,byte...的时候我们只能存储他们对应的包装类，它的主要底层实现是数组Object[] elementData。
  （3）ArrayList不是线程安全的，但是在发生并发行为时，它会尽可能的抛出ConcurrentModificationException，此为fail-fast机制。
  （4）ArrayList提供了三种方式的构造器，可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。ArrayList的构造函数如下：

    /**
     * 构造一个指定初始容量的空列表
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     *构造一个默认初始容量为10的空列表
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     *构造一个包含指定collection的元素的列表
     */
    
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
注：我们可以看出ArrayList其实就是采用的是数组（默认是长度为10的数组）。所有ArrayList在读取的时候是具有和数组相似的效率，所以导致对List的插入与移除元素时较慢。

• LinkedList
  (1)LinkedList在List中间插入删除时比ArrayList更高效，随机访问要差一些。
  (2)LinkedList还添加了可以使其用作栈，队列或双端队列的方法。各种Queue以及栈的行为，由LinkedList提供支持。以下是LinkedList实现栈的功能：

import java.util.LinkedList;
public class Stack<T> {
    private LinkedList<T> storage = new LinkedList<>();
    //加入元素
    public void push(T v) {
        storage.addFirst(v);
    }
    //返回栈顶元素
    public T peek() {
        return storage.getFirst();
    }
    //移除并返回栈顶元素
    public T pop() {
        return storage.removeFirst();
    }
    public boolean empty() {
        return storage.isEmpty();
    }
    public String toString() {
        return storage.toString();
    }
}
注意：
（1）add方法：将指定的元素附加到该列表的末尾
文档方法定义：add(E e)---> Appends the specified element to the end of this list.
使用add方法后，再使用removefirst返回的是插入的第一元素。即列表的第一个元素


（2）addFirst方法：在列表的开头插入指定的元素。
文档方法定义：addFirst(E e)--->Inserts the specified element at the beginning of this list
使用addfirst方法后，再使用removefirst返回的是插入的最后一元素。同样也是列表的第一个元素。

3.Set

set不保存重复的元素，Set中最常被使用的是测试归属性，你可以很容易访问到某个对象是否在某个Set中，正因如此，查找就成为了Set中最重要的操作，因此你通常会选择一个HashSet的实现，它专门对快速查找进行了优化。

• HashSet
  出于速度因素的考虑，HashSet使用了散列，同时所存储的元素是没有顺序的。下面是样码：

public class SetofInteger {
    public static void main(String[] args) {
        Random rand = new Random(47);
        Set<Integer> intset = new HashSet<Integer>();
        for(int i=0;i<10000;i++) {
            intset.add(rand.nextInt(30));
        }
        System.out.println("HashSet输出结果: "+intset);
    }
}
/*output: 
HashSet输出结果: [0, 1, 2, 3, 4, 5, 7, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 26, 24, 28, 25, 27, 29]
*/

• TreeSet
  TreeSet将元素存储在红-黑树数据结构中，所存储的元素是有顺序的。内部是使用比较器将基本数据类型进行比较后排序的，但是对于用TreeSet存储多个对象时，对象本身应该有自定义比较器来实现排序，不然会报错。下面是一个小程序，跟HashSet那个类似。

public class SetofInteger {
    public static void main(String[] args) {
        Random rand = new Random(47);
        Set<Integer> treeset = new TreeSet<>();
        for(int i=0;i<10000;i++) {
            treeset.add(rand.nextInt(30));
        }
        System.out.println("TreeSet输出结果: "+treeset);
    }
}
/*output:
TreeSet输出结果: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
*/

4.Map

Map以键值对的形式保存元素，是一种将对象（非数字）与对象相关联的设计。HashMap设计用来快速访问，而TreeMap保持键始终处于排序状态，所以HashMap更快。LinkedHashMap保持元素插入的顺序，但是也是通过散列提供了快速访问的能力。

• HashMap
  通过散列用来快速访问

public class MapTest {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Tom", 123);
        map.put("Tony", 134);
        map.put("Mike", 125);
        System.out.println(map);
        for(String str:map.keySet()) {
            System.out.println(str+" has:"+map.get(str));
        }
    }
}
/*output:
{Tony=134, Mike=125, Tom=123}
Tony has:134
Mike has:125
Tom has:123
*/

5.迭代器

• 迭代器(Iterator)
  迭代器是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构。
  (1)使用iterator方法要求容器返回一个Iterator.
  (2)使用hasnext()检查序列中是否还有其他元素。
  (3)使用next()获取序列中的下一个元素。
  (4)使用remove()将迭代器新近返回的元素删除。

• ListIterator
  ListIterator是一个更加强大的Iterator的子类型，它只能用于各种List类的访问。ListIterator可以双向移动。它还可以产生相对于迭代器在列表中指向当前位置的前一个或后一个索引，并可以用set()方法替换掉它访问过的最后一个元素。

public class LinkIteratorTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<5;i++) {
            list.add(i);
        }
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()) {
            System.out.println(it.next()+","+it.nextIndex()+","+it.previousIndex());
        }
    }
}

6.Collection和Collections

• Collection:Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
• Collections:Collections是一个包装类，也就是一个工具类，它包含有各种有关集合操作的静态多态方法。此类不能实例化，它服务于Collection集合。例如：Collections.addAll()方法接收一个Collection对象，以及一个数组或是一个用逗号分隔的列表，将元素添加到Collection中。