三、 Java Collection
1. Collection 接口
// Collection 接口在其源码中的定义： * 1. Collection 是集合层次结构中的根接口 * 2. 一个 Collection 代表 一组对象（objects），这些对象称为其元素（elements） * 3. 一些 Collection 允许有重复的元素，而另一些 Collection 不允许有重复的元素 * 4. 一些 Collection 的元素是有序的，而另一些 Collection 是无序的 * 5. JDK 没有提供任何直接（direct）实现 Collection 的类 * 6. JDK 只提供了继承 Collection 的“子接口”（List 和 Set）的实现类 * -Set 中的元素没有顺序且不可以重复 * -List 中的元素有顺序且可以重复 * -Map 接口定义了存储 “键（key）- 值（value）映射对” 的方法，键（key）不能重复，重写 hashCode() 和 equals() 方法！ * * * 接口 Collection * / * * 接口 Set List Map * | / | * * 类 HashSet ArrayList LinkedList HashMap // 谈到 Collection 接口，我们不得不区别一下 Collections 类 // Collections 是一个类，不能实例化，是一个工具类，它包含各种有关集合操作的静态（static）多态方法，比如 sort、search、shuffle 以及线程安全等操作 public class Collections { // 私有化构造器，所以不能被实例化 private Collections() { } ... }
2. ArrayList
1. ArrayList 是 List 接口的实现类，并继承于 AbstractList（AbstractList 继承于 AbstractCollection，并且实现了大部分 List 接口） 2. ArrayList 的底层实现是动态数组（属于数据结构中的可扩容的线性表），线程不安全，效率高 // 创建 List list = new ArrayList(); // 常用方法 list.size();// 返回元素的数量 list.isEmpty(); list.add(element); list.add(index, element);// 在指定位置添加元素 list.remove(index);// 删除指定索引的元素，并返回该元素内容 list.remove(element);// 删除指定元素，删除成功返回 true list.get(index);// 获取指定位置的元素 list.toArray();// 返回一个包含列表中的所有元素的数组 list.contains(element);// 判断是否包含指定元素 list.indexOf(element);// 返回指定元素所在的第一个位置，没找到返回 -1 list.lastIndexOf(element);// 返回指定元素所在的最后一个位置 list.clear();// 删除所有元素 // 为了更深入了解 ArrayList，我们来分析一下 ArrayList 的部分源码
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { private static final int DEFAULT_CAPACITY = 10;// 默认容量为 10 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;// 最大容量 private static final Object[] EMPTY_ELEMENTDATA = {}; private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; transient Object[] elementData;// 可见底层是 Object 对象数组 private int size;// 包含元素的数量 // 无参构造器，对象数组默认为空 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } // 有参构造器，用于初始化数组容量 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); } } // 返回所包含元素的数量 public int size() { return size; } // 判断对象数组是否为空 public boolean isEmpty() { return size == 0; } // 返回一个包含列表中的所有元素的数组 public Object[] toArray() { return Arrays.copyOf(elementData, size); } // 删除元素 public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; return oldValue; } // 添加元素 public boolean add(E e) { ensureCapacityInternal(size + 1);// 判断是否需要扩容 elementData[size++] = e; return true; } // 判断是否需要扩容 private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { modCount++; if (minCapacity - elementData.length > 0) grow(minCapacity); } // 扩容方法 private void grow(int minCapacity) { 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); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } ... }
3. LinkedList
1. LinkedList 是 List 接口的实现类，并继承于 AbstractSequentialList（AbstractSequentialList 继承于 AbstractList，提供了对数据元素的链式访问而不是随机访问） 2. LinkedList 的底层实现是链表（属于数据结构中的双向链表），线程不安全，效率高 // 创建 List link = new LinkedList(); // 常用方法 link.size(); link.getFirst();// 返回第一个节点的元素 link.getLast();// 返回最后一个节点的元素 link.get(index);// 返回指定位置的元素 link.contain(element);// 判断链表中是否有指定元素 link.addFirst(element);// 从链表头部插入元素，无返回值 link.add(element); // 从链表尾部插入元素，插入成功返回 true link.add(index, element);// 在指定位置插入元素，无返回值 link.remove(element); // 删除指定元素，删除成功返回 true link.remove(index);// 删除指定位置的元素，删除成功返回被删除元素 link.addAll(Collection);// 添加指定集合 link.clear();// 清空链表，释放节点空间 // 为了更深入了解 LinkedList，我们来分析一下 LinkedList 的部分源码
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { // 用私有静态内部类定义链表的节点对象 private static class Node<E> { E item; // 存放元素内容 Node<E> next;// 指向下一个节点 Node<E> prev;// 指向前一个节点 //有参构造器 Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } } transient int size = 0;// 元素的数量 transient Node<E> first;// 指向链表的第一个节点 transient Node<E> last;// 指向链表的最后一个节点 public LinkedList() { } // 有参构造器，用于构造包含指定集合的链表 public LinkedList(Collection<? extends E> c) { this(); addAll(c);// 添加指定集合 } // 返回元素的数量 public int size() { return size; } // 在链表的头部插入元素 public void addFirst(E e) { linkFirst(e); } private void linkFirst(E e) { final Node<E> f = first; final Node<E> newNode = new Node<>(null, e, f); first = newNode; if (f == null) last = newNode; else f.prev = newNode; size++; modCount++; } // 在链表的尾部插入元素 public boolean add(E e) { linkLast(e); return true; } 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++; } // 删除元素 public boolean remove(Object o) { if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) { unlink(x); return true; } } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; } E unlink(Node<E> x) { // assert x != null; final E element = x.item; final Node<E> next = x.next; final Node<E> prev = x.prev; if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } x.item = null; size--; modCount++; return element; } // 清空链表 public void clear() { for (Node<E> x = first; x != null; ) { Node<E> next = x.next; x.item = null; x.next = null; x.prev = null; x = next; } first = last = null; size = 0; modCount++; } }
4. HashMap
1. HashMap 是 Map 接口的实现类，并继承于 AbstractMap（AbstractMap 是 Map 接口的抽象实现类，并且实现了大部分 Map 接口） 2. HashMap 的底层实现：哈希表+链表（属于数据结构中的邻接表） // 创建 Map map = new HashMap(); // 常用方法 map.put(k,v);// 添加键值对，如果 key 已存在，则覆盖 value，并返回被覆盖的 value；不存在，则返回 null map.putAll(map02);// 添加指定的 map 集合 map.remove(k);// 删除指定 key 的节点，并返回 value map.get(k);// 获取指定 key 的 value map.containsKey(k);// 判断是否含有指定 key 的节点 map.containsValue(v);// 判断是否含有指定 value 的节点 map.size();// 返回键值对的数量 map.values();//获取所有 value，返回值类型 Collection<valueType> map.keySet(); //获取所有 key，返回值类型 Set<keyType> map.entrySet();// 获取所有 key 和 value，返回值类型 Set<Entry<keyType, valueType>> map.clear();// 清空 map 里的所有键值对 // 为了更深入了解 HashMap，我们来分析一下 HashMap 的部分源码
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;// 默认最小容量 MUST be a power of two. aka 16 static final int MAXIMUM_CAPACITY = 1 << 30;// 默认最大容量 static final float DEFAULT_LOAD_FACTOR = 0.75f;// 默认负载因子 // 用静态内部类定义链表的节点对象 static class Node<K,V> implements Map.Entry<K,V> { final int hash;// 存放 hashCode final K key;// 存放 key V value; // 存放 value Node<K,V> next;// 指向下个节点 // 有参构造器 Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } /* 使用自己定义的 hashCode()方法 这里给出 java.util.Objects 中定义的 hashCode()方法 public static int hashCode(Object o) { return o != null ? o.hashCode() : 0; } */ public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } /* 使用自己定义的 equals()方法 这里给出 java.util.Objects 中定义的 equals()方法 public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); } */ public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } } transient Node<K,V>[] table;// 声明哈希表 transient int size;// 元素的数量 final float loadFactor;// 负载因子 // 无参构造器 public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; } public int size() { return size; } public boolean isEmpty() { return size == 0; } // 定义了自己的 hash()方法 static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } /* 添加键值对 我们先在这给出 java.lang.Object 的 equals()方法 public boolean equals(Object obj) { return (this == obj); } 所以，我们在做 key 的比较时，要根据自己的需求重写 equals()方法 */ public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; // 如果哈希表为空，初始化哈希表 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 如果 hash(key) 对应哈希表位置为 null，直接存放该节点 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; // 如果 hash(key) 对应哈希表位置存放的节点 key 等于 我们要添加的键值对的 key，则直接覆盖 value if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; // 如果是树节点的操作 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 如果 hash(key) 对应哈希表位置存放的节点 key 不等于 我们要添加的键值对的 key，则往下寻找，如果有相等的，覆盖 value，没有则在最后一个节点后添加新节点存放 else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } // 有参构造器，使用与指定的 Map 相同的映射，构造一个新的 HashMap，新的 HashMap 内包含了指定 map 的所有元素 public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); } final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { if (table == null) { // pre-size float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); if (t > threshold) threshold = tableSizeFor(t); } else if (s > threshold) resize(); for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); } } } // 获取指定 key 的 value public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; } // 是否存在指定 key public boolean containsKey(Object key) { return getNode(hash(key), key) != null; } // 删除指定 key 的键值对，并返回 value public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; } // 清空 public void clear() { Node<K,V>[] tab; modCount++; if ((tab = table) != null && size > 0) { size = 0; for (int i = 0; i < tab.length; ++i) tab[i] = null; } } }
5. HashSet
1. HashSet 是 Set 接口的实现类，并继承于 AbstractSet（AbstractSet 继承于 AbstractCollection，并且实现了大部分 Set 接口） 2. HashSet 的底层实现：利用 “HashMap 键唯一” 的特性 // 创建 Set set = new HashSet(); // 常用方法 set.size();// 返回元素的数量 set.isEmpty(); set.add(e);// 添加元素，添加成功返回 true，否则返回 false set.remove(e);// 删除指定元素，删除成功返回 true set.contains(e);// 判断指定元素是否已存在 set.clear();// 清空 set 里的所有元素 // 为了更深入了解 HashSet，我们来分析一下 HashSet 的部分源码
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable { private transient HashMap<E,Object> map;// 哇，直接就用了 HashMap private static final Object PRESENT = new Object();// 创建一个 Object 对象常量，其实就是用来填充 HashMap 的 value public HashSet() { map = new HashMap<>(); } public int size() { return map.size(); } public boolean isEmpty() { return map.isEmpty(); } public boolean contains(Object o) { return map.containsKey(o); } public boolean add(E e) { // 当添加元素 e 已经存在时，即对应的 map 里的 key 存在，则 map 的 put()方法会返回被覆盖的 value，这个 value 就是 PRESENT，不等于 null，故返回 false return map.put(e, PRESENT)==null; } public boolean remove(Object o) { return map.remove(o)==PRESENT; } public void clear() { map.clear(); } }
6. Iterator 迭代器
1.所有实现了 Collection 接口的容器类都有一个 iterator() 方法，用来返回一个实现了 Iterator 接口的对象 2.迭代器使遍历操作更加方便 3.java.util.Iterator 接口定义了如下方法： * boolean hasNext();// 判断是否有下一个节点 * Object next();// 返回游标（cursor）当前位置的元素，并且游标（cursor）指向下一个位置 * void remove();// 删除游标左边（lastRet）的元素，在执行完 next()方法 之后该操作只能执行一次，因为每次执行 remove()方法后 lastRet 都会置为 -1；只有当再次使用 next()方法后，才会给 lastRet 重新赋值 // 下面给出 ArrayList 的遍历操作，LinkedList、HashMap、HashSet 的遍历操作都类似，需要注意的是 Map 和 Set 是用 哈希表+链表 实现的，所以不能使用第一种遍历方式（索引遍历） public class Traversal { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); //遍历方式一 for(int i=0;i<list.size();i++) System.out.println(list.get(i)); //遍历方式二 for(String li : list) System.out.println(li); //遍历方式三 for(Iterator<String> iterator = list.iterator();iterator.hasNext();) System.out.println(iterator.next()); //遍历方式四 Iterator<String> iterator = list.iterator(); while(iterator.hasNext()) System.out.println(iterator.next()); } }