引言
如果一个程序只包含固定数量的且其生命周期都是已知对象,那么这是一个非常简单的程序——《think in java》
了解容器前,先提出一个问题,ArrayList和LinkedList谁的处理速度更快呢?
一 持有对象的方式
在Java中,我们可以使用数组来保存一组对象。但是,数组是固定大小的,在一般情况下,我们写程序时并不知道将需要多少个对象,因此数组固定大小对于编程有些受限。
java类库中提供了一套相当完整的容器类来解决这个问题,其中基本类型有List,Queue,Set,Map,这些对象类型被称为集合类。但是,Java类库中使用了Collection来指代集合类中的子集{List,Queue,Set} ,所以集合类也被称为容器。容器提供了完善的方法来保存对象。
二 类型安全的容器
java采用泛型保证我们不会向容器中插入不正确的类型,但是java的泛型只存在于程序源码中,在经过编译器编译就会将类型擦除。举一个例子:
java//经过编译前 List<String> list = new ArrayList<>(); list.add("ok"); System.out.println(list.get(0)); //经过编译后 List list = new ArrayList(); list.add("ok"); System.out.println((String)list.get(0)); http://www.nvzi91.cn/fujianyan/29933.html
复制代码
这样做的好处是:在编写程序的时候,不会将其他非导出类型的对象添加到容器中。
三 List
数组存储多个对象的原因是它提前声明了能存储多少对象。那容器又是如何实现存储不定多对象的呢?
java//ArrayList部分源码 private static final int DEFAULT_CAPACITY = 10; private static final Object[] EMPTY_ELEMENTDATA = {}; private transient Object[] elementData; private int size; http://www.nvzi91.cn/zigongnamoyan/29934.html public ArrayList(int initialCapacity) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } public ArrayList() { super(); this.elementData = EMPTY_ELEMENTDATA; } public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } http://www.nvzi91.cn/chunvmoxiufu/29935.html private void ensureCapacityInternal(int minCapacity) { if (elementData == EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); } http://www.nvzi91.cn/penqiangyan/29936.html private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); }
复制代码
我们可以看到,在ArrayList类中有一个elementData数组。当使用无参构造函数时数组长度默认为空,当向ArrayList加入对象时,会调用一个方法来判断数组是否能放下这个对象。当数组为空时设置数组长度为10并申请相应大小空间,当数组已满时,最少重新申请原数组大小1.5倍的空间 (除非达到int类型最大值-8)。而在LinkedList中却没有采用这种方式,而是采用链表方式。
java//LinkedList add方法 void linkLast(E e) { final Node<E> l = last; final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; } http://www.nvzi91.cn/yindaoyan/29937.html
复制代码
在LinkedList中,他的add方法调用了linkLast方法,直接在链表后边加入一个新的节点。
四 Set
Set类型不保存重复的元素。判断对象元素是否相等采用的是equals方法,所以在存入自定义的对象时,如果重写equals方法依赖于可变属性,将会导致一些问题。
五 Map
Map类型是能够将对象映射到其他对象的一种容器,有区别于List的get方法。HashSet类中包含了一个HashMap对象,HashSet的实现依靠HashMap。
HashMap的实现采用了数组链表的方式,即数组的每一个位置都存放的是链表头。查找会先通过key的hash找到对应数组下标,再在该数组下标所对应的链表中找到是否有对应对象,查找方式为equals方法。 HashMap如果存储的键值对大于设定值,会自动进行扩容并且对已经存入的键值对进行重排序,一次扩容的大小是当前数组长度的两倍。
java//HashMap扩容 public V put(K key, V value) { //other... addEntry(hash, key, value, i); return null; }http://www.kmrlyy.com/lcnz/33448.html void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } //other... }
复制代码
六 Queue
队列是一种典型的先进先出的容器,LinkedList实现了Queue接口。PriorityQueue实现了优先级队列。ArrayDeque是一个用数组实现双端队列的类,我们来看一下ArrayDeque类中的一些方法。
java//ArrayDeque构造方法 public ArrayDeque() { elements = (E[]) new Object[16]; } public ArrayDeque(int numElements) { allocateElements(numElements); }http://www.kmrlyy.com/penqiangyan/33450.html private void allocateElements(int numElements) { int initialCapacity = MIN_INITIAL_CAPACITY; if (numElements >= initialCapacity) { initialCapacity = numElements; initialCapacity |= (initialCapacity >>> 1); initialCapacity |= (initialCapacity >>> 2); initialCapacity |= (initialCapacity >>> 4); initialCapacity |= (initialCapacity >>> 8); initialCapacity |= (initialCapacity >>> 16); initialCapacity++; if (initialCapacity < 0) // Too many elements, must back off initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements } elements = (E[]) new Object[initialCapacity]; } http://www.kmrlyy.com/zgjl/33451.html
复制代码
上边的代码是ArrayDeque的构造方法,可以看到,当没有定义大小时,ArrayDeque默认数组大小为16,而定义大小后,会调用allocateElements方法,这个方法的作用是:当给定长度小于最小长度8时,使用最小长度。若大于等于最小长度,则找到比给定长度大的最小的2的幂数。为什么要是2的幂数呢?原因有以下两点:
操作系统分配内存的方法使用伙伴系统的话,每一块的大小都是2的幂数,如果分配的内存大小为2的幂数,可以减少内存分配的时间。
伙伴系统在百度百科中的解释:http://baike.baidu.com/view/4935190.htm
在ArrayDeque的addFirst方法中不固定将头放在数组的第一位,而是循环移位。使用2的幂数能够有效判断头部所在的地址。
同样在第二点中,如果队列满了,数组扩充是将容量capacity值左移一位即可扩充一倍。
javapublic void addFirst(E e) { if (e == null) throw new NullPointerException(); elements[head = (head - 1) & (elements.length - 1)] = e; if (head == tail) doubleCapacity(); } private void doubleCapacity() { assert head == tail; int p = head; int n = elements.length; int r = n - p; // number of elements to the right of p int newCapacity = n << 1; if (newCapacity < 0) throw new IllegalStateException("Sorry, deque too big"); Object[] a = new Object[newCapacity]; System.arraycopy(elements, p, a, 0, r); System.arraycopy(elements, 0, a, r, p); elements = (E[])a; head = 0; tail = n; }http://www.kmrlyy.com/gongjingai/33452.html
复制代码
七 List的选择
在文章开头提出了一个问题,数组实现的List快还是链表实现的List快。模拟一下试试:
javapublic static void add() { long start = 0; long end = 0; List<Integer> alist = new ArrayList<>(); List<Integer> llist = new LinkedList<>(); System.out.println("ArrayList添加1000万数据所需毫秒数"); start = System.currentTimeMillis(); for (int i=0; i<10000000; i++) { alist.add(i); } end = System.currentTimeMillis(); System.out.println(end-start); System.out.println("LinkedList添加1000万数据所需毫秒数"); start = System.currentTimeMillis(); for (int i=0; i<10000000; i++) { llist.add(i); } end = System.currentTimeMillis(); System.out.println(end-start+"\n"); http://www.kmrlyy.com/gongjingfeida/33453.html System.out.println("ArrayList从1000万数据删除数据所需毫秒数"); start = System.currentTimeMillis(); alist.remove(0); alist.remove(2000000); alist.remove(4000000); alist.remove(6000000); alist.remove(8000000); alist.remove(9999994); end = System.currentTimeMillis(); System.out.println(end - start); http://m.nvzi91.cn/gongjingyan/29349.html System.out.println("LinkedList从1000万数据删除数据所需毫秒数"); start = System.currentTimeMillis(); llist.remove(0); llist.remove(2000000); llist.remove(4000000); llist.remove(6000000); llist.remove(8000000); llist.remove(9999994); end = System.currentTimeMillis(); System.out.println(end - start+"\n"); http://m.nvzi91.cn/gongjingmilan/29348.html System.out.println("ArrayList从1000万数据查找数据所需毫秒数"); start = System.currentTimeMillis(); alist.contains(0);http://m.nvzi91.cn/gongjingxirou/29350.html alist.contains(2000000); alist.contains(4000000); alist.contains(6000000); alist.contains(8000000); alist.contains(10000000); end = System.currentTimeMillis(); System.out.println(end - start); www.nvzi91.cn www.kmrlyy.com System.out.println("LinkedList从1000万数据查找数据所需毫秒数"); start = System.currentTimeMillis(); llist.contains(0); llist.contains(2000000); llist.contains(4000000); llist.contains(6000000); llist.contains(8000000); llist.contains(10000000); end = System.currentTimeMillis(); System.out.println(end - start+"\n"); }m.nvzi91.cn