第九章：Java集合

9.1：Java集合框架概述

数组、集合都是对多个数据进行存储(内存层面，不涉及持久化)操作的结构，简称Java容器。

1. 数组存储多个数据方面的特点

   • 一旦初始化以后，其长度就确定了。
   • 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。

2. 数组在存储多个数据方面的缺点

   • 一旦初始化以后，其长度就不可修改。
   • 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不搞。
   • 获取数据中实际元素的个数的需求，数组没有现成的属性或方法可用。
   • 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

3. Java集合可分为Collection和Map两种体系

   • Collection接口：单列数据，定义了存储一组对象的方法的集合。

     1. List：元素有序，可重复的集合。
     2. Set：元素无序，不可重复的集合。
        

   • Map接口：双列数据，保存具有映射关系key - value对的集合。
     

9.2：Collection接口方法

1. add(Object obj)：将元素obj添加到集合中。

2. addAll(Collection coll)：将coll集合中的元素添加到当前的集合中。

3. int size()：获取添加的元素的个数。

4. void clear()：清空集合元素。

5. isEmpty()：判断当前集合是否为空。

   Collection coll = new ArrayList();coll.add("AA");
   coll.add("BB");
   coll.add(123);//自动装箱
   coll.add(new Date());System.out.println(coll.size());//4Collection coll1 = new ArrayList();
   coll1.add(456);
   coll1.add("CC");
   coll.addAll(coll1);System.out.println(coll.size());//6coll.clear();System.out.println(coll.isEmpty());// true
   

6. boolean contains(Object obj)：判断当前集合是否包含obj。

7. boolean containsAll(Collection c)：判断形参c中的所有元素是否都存在于当前集合中。

   Collection coll = new ArrayList();coll.add(123);
   coll.add(456);
   coll.add(new String("Tom"));
   coll.add(false);boolean contains = coll.contains(123);
   System.out.println(contains); // true
   System.out.println(coll.contains(new String("Tom"))); // trueCollection coll1 = Arrays.asList(123,4567);
   System.out.println(coll.containsAll(coll1)); // false
   

   注意：如果判断的对象是自定义类，则需要重写equals()方法。

8. boolean remove(Object obj)：从当前集合中移除obj元素。

9. boolean removeAll(Collection coll)：从当前集合中移除coll中所有的元素。

   Collection coll = new ArrayList();
   coll.add(123);
   coll.add(456);
   coll.add(new String("Tom"));
   coll.add(false);coll.remove(1234);
   System.out.println(coll); // [123, 456, Tom, false]Collection coll1 = Arrays.asList(123,456);
   coll.removeAll(coll1);
   System.out.println(coll); // [Tom, false]
   

10. boolean retainAll(Collection c)：获取当前集合和C集合的交集，并返回给当前集合。

    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new String("Tom"));
    coll.add(false);Collection coll1 = Arrays.asList(123,456,789);
    coll.retainAll(coll1);
    System.out.println(coll); // [123, 456]
    

11. boolean equals(Object obj)：想要返回true，需要当前集合和形参集合的元素的相同。

    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);Collection coll1 = new ArrayList();
    coll1.add(456);
    coll1.add(123);
    coll1.add(new Person("Jerry",20));
    coll1.add(new String("Tom"));
    coll1.add(false);System.out.println(coll.equals(coll1)); // false
    

12. Object[] toAttay()：转成对象数组。

13. hashCode()：返回对象的哈希值。

14. iterator()：返回Iterator接口的实例，用于遍历集合。

    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new String("Tom"));
    coll.add(false);System.out.println(coll.hashCode()); // -1579892151Object[] arr = coll.toArray();
    for(int i = 0;i < arr.length;i++){System.out.print(arr[i] + "\t"); // 123	456	Tom	false
    }
    

9.3：Iterator迭代器接口

​ Iterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection集合中的元素。

​ GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而有不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

1. 内部方法

   • hasNext()：判断是否还有下一个元素。

   • next()：指针下移，将下移以后集合位置上的元素返回。

     Collection coll = new ArrayList();
     coll.add(123);
     coll.add(456);
     coll.add(new String("Tom"));
     coll.add(false);Iterator iterator = coll.iterator();while(iterator.hasNext()){System.out.print(iterator.next() + "\t"); // 123	456	Tom	false	
     }
     

     说明：

     1. Iterator仅用于遍历集合，Iterator本身并不提供承装对象的能力。如果需要创建Itertor对象，则必须有一个被迭代的集合。
     2. 集合对象每次调用iterator()方法到得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
     3. 在调用next()方法之前必须要调用hasNext()进行检测。若不调用，且下一条记录记录无效，直接调用next()会抛出NoSuchElementException异常。

   • remove()：可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()。

     Collection coll = new ArrayList();
     coll.add(123);
     coll.add(456);
     coll.add(new String("Tom"));
     coll.add(false);Iterator iterator = coll.iterator();
     while(iterator.hasNext()) {Object obj = iterator.next();if("Tom".equals(obj)) {iterator.remove();}
     }iterator = coll.iterator();
     while(iterator.hasNext()) {System.out.print(iterator.next() + "\t"); // 123	456	false
     }
     

     说明：

     1. Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
     2. 如果还为调用next()或在上一次调用next方法之后已经调用remove方法，再调用remove都会报IllegalStateException。

2. 使用foreach循环遍历集合元素

   • Java 5.0提供了foreach循环迭代访问Collection和数组。
   • 遍历操作不需要获取Collection或数组的长度，无需使用索引访问元素。
   • 遍历集合的底层调用Iterator完成操作。
   • foreach还可以用来遍历数组。

   Collection coll = new ArrayList();
   coll.add(123);
   coll.add(456);
   coll.add(new Person("Jerry", 20));
   coll.add(new String("Tom"));
   coll.add(false);
   //for(集合元素的类型 局部变量 : 集合对象)
   for(Object obj: coll) {System.out.println(obj);
   }
   

9.4：List接口

​ List集合类中元素有序，且可重复，集合中的每个元素都有其对应的顺序索引。JDK API中List接口的实现类常用的有：ArrayList、LinkedList、Vector。

1. ArrayList源码分析

   作为List接口的主要实现类，线程不安全的，效率高，底层使用Object[]存储。

   • JDK 7情况下

     // 空参构造器，底层创建了长度是10的Object[]数组
     public ArrayList() {this(10);
     }// 添加操作
     public boolean add(E e) {ensureCapacityInternal(size + 1);elementData[size++] = e;return true;
     }
     // 判断索引是否超出Object[]的长度
     private void ensureCapacityInternal(int minCapacity) {modCount++;if (minCapacity - elementData.length > 0)grow(minCapacity);
     }
     // 超出长度进行扩容，且扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中
     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);elementData = Arrays.copyOf(elementData, newCapacity);
     }
     

     说明：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

   • JDK 8情况下

     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
     // 空参构造器，对Object[] 进行初始化
     public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     }// 添加操作
     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);
     }
     // 判断索引是否超出Object[]的长度
     private void ensureExplicitCapacity(int minCapacity) {modCount++;if (minCapacity - elementData.length > 0)grow(minCapacity);
     }
     // 超出长度进行扩容，且扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中
     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);elementData = Arrays.copyOf(elementData, newCapacity);
     }
     

   总结：jdk7中的ArrayList的对象创建类似于单例的饿汉式，而jdk8中的ArrayList的对象创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

2. LinkedList的源码分析

   对于频繁的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储。

   transient Node first;
   transient Node last;// Node定义，体现了LinkedList的双向链表的说法
   private static class Node {E item;Node next;Node prev;Node(Node prev, E element, Node next) {this.item = element;this.next = next;this.prev = prev;}
   }
   

3. Vector源码分析

   作为List接口的古老实现类，线程安全的，效率低，底层使用Object[]数组存储。

   // 空参构造器，底层创建了长度是10的Object[]数组
   public Vector() {this(10);
   }
   // 添加操作
   public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;return true;
   }
   // 判断索引是否超出Object[]的长度
   private void ensureCapacityHelper(int minCapacity) {if (minCapacity - elementData.length > 0)grow(minCapacity);
   }
   // 超出长度进行扩容，且扩容为原来容量的2倍，同时需要将原有数组中的数据复制到新的数组中
   private void grow(int minCapacity) {int oldCapacity = elementData.length;int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);if (newCapacity - minCapacity < 0)newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);elementData = Arrays.copyOf(elementData, newCapacity);
   }
   

4. List接口方法

   • void add(int index, Object ele)：在index位置插入ele元素。
   • boolean addAll(int index, Collection eles)：从index位置开始将eles中的素有元素添加进来。
   • Object get(int index)：获取指定index位置的元素。

   ArrayList list = new ArrayList();
   list.add(123);
   list.add(456);
   list.add("AA");
   list.add(new Person("Tom", 12));
   list.add(456);
   System.out.println(list); // [123, 456, AA, Person{name='Tom', age=12}, 456]list.add(1, "BB");
   System.out.println(list); // [123, BB, 456, AA, Person{name='Tom', age=12}, 456]List list1 = Arrays.asList(1, 2, 3);
   list.addAll(list1);
   System.out.println(list.size()); // 9System.out.println(list.get(0)); // 123
   

   • int indexOf(Object obj)：返回obj在集合中首次出现的位置，集合中没有则返回-1。
   • int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置，集合中没有则返回-1。
   • Object remove(int index)：移除指定的index位置的元素，并返回此元素。
   • Object set(int index, Object ele)：设置指定index位置的元素为ele。
   • List subList(int formIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合。

   ArrayList list = new ArrayList();
   list.add(123);
   list.add(456);
   list.add("AA");
   list.add(new Person("Tom", 12));
   list.add(456);int index = list.indexOf(4567);
   System.out.println(index); // -1System.out.println(list.lastIndexOf(456));  // 4Object obj = list.remove(0);
   System.out.println(obj); // 123
   System.out.println(list); // [456, AA, Person{name='Tom', age=12}, 456]list.set(1, "CC");
   System.out.println(list); // [456, CC, Person{name='Tom', age=12}, 456]List subList = list.subList(2, 4);
   System.out.println(subList); // [Person{name='Tom', age=12}, 456]
   System.out.println(list); // [456, CC, Person{name='Tom', age=12}, 456]
   

9.5：Set接口

​ Set接口存储无序的、不可重复的数据。set接口没有提供额外的方法。JDK API中Set接口的实现类常用的有：HashSet、LinkedHashSet、TreeSet。

​ 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

​ 不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。

1. HashSet

   作为Set接口的主要实现类：线程不安全的，可以存储null值。

   • 添加元素的过程

     1. 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算机元素a的哈希值，此哈希值接着通过某种算法计算出HashSet底层数组中的存放位置(即为：索引位置)。
     2. 判断数组此位置上是否已经有元素。
     3. 如果此位置上没有其他元素，则元素a添加成功。
     4. 如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的hash值。
     5. 如果hash值不相同，则元素a添加成功，
     6. 如果hash值相同，进而需要调用元素a所在类的equals()方法。
     7. equals()返回true，元素a添加失败。
     8. equals()返回false，则元素a添加成功。

     注意：对于索引位置已有元素然后还添加成功的而已，元素a与已经存在指定索引位置上数据以链表的方式存储。

     • jdk 7：元素a放到数组中，指向原来的元素。
     • jdk 8：原来的元素在数组中，指向元素a。
       

2. LinkedHashSet

   ​ 作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历。在添加数据还维护了两个引用，记录此数据前一个数据和后一个数据，对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
   

3. TreeSet

   • TreeSet底层使用红黑树结构存储数据。

   • 向TreeSet中添加的数据，要求是相同的对象。

   • TreeSet可以确保集合元素处于排序状态。就必须得实现Comparable或者Comparator。

   • 在比较两个对象是否相同的标准为：compareTo()或者compare()返回0，不再是equals()。

9.6：Map接口

​ map与Collection并列存在。用于保存具有映射关系的数据。Map存储的是双列数据，存储key-value对的数据。Map中的**key用Set来存放，不允许重复**，即同一个Map对象所对应的类，须重写hashCode()和equals()方法。Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。

1. HashMap

   作为Map的主要实现类：线程不安全，效率高，能存储null的key和value。

   • Map结构的理解

     1. Map中的key：无序的、不可重复的，使用Set存储所有的key。
     2. Map中的value：无序的、可重复的，使用Collection存储所有的value。
     3. Map中的entry：key-value构成了一个Entry对象。无序的，不可重复的，使用Set存储所有的entry。

   • HashMap的底层实现原理

     1. jdk 7

        HashMap map = new HashMap(); // 实例化以后，底层创建了长度是16的一维数组Entry[] table
        map.put(key1, value1);
        

        • 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存在位置。
        • 如果此位置上的数据为空，此时的key1-value添加成功。
        • 如果此位置上的数据不为空，比较key1和已经存在的一个或多个数据的哈希值。
        • 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。
        • 如果key1的哈希值和已经存在的某一个数据key2-value2的哈希值相同，继续比较，调用key1所在类类的equals(key2)方法。
        • 如果equals()返回false，此时key-value添加成功。
        • 如果equals()返回true，使用value1替换value2。

        // HashMap的默认容量
        static final int DEFAULT_INITIAL_CAPACITY = 16;
        // HashMap的默认加载因子
        static final float DEFAULT_LOAD_FACTOR = 0.75f;
        // 扩容的临界值(容量 * 加载因子)
        final float loadFactor;// 空参构造器
        public HashMap() {this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
        }
        // 初始化数组
        public HashMap(int initialCapacity, float loadFactor) {// 不执行此处3个ifif (initialCapacity < 0) // 最大容量是不是小于0throw new IllegalArgumentException("Illegal initial capacity: "+initialCapacity);if (initialCapacity > MAXIMUM_CAPACITY) // 最大容量是不是超出范围initialCapacity = MAXIMUM_CAPACITY;if (loadFactor <= 0 || Float.isNaN(loadFactor)) // 扩容临界值是不是小于0，或者没有初始化throw new IllegalArgumentException("Illegal load factor: " + loadFactor);int capacity = 1;// capacity循环完为16while (capacity < initialCapacity)capacity <<= 1;// this.loadFactor = 0.75this.loadFactor = loadFactor;// threshold = 12threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);// 初始化Entry数组的长度为16table = new Entry[capacity];useAltHashing = sun.misc.VM.isBooted() &&(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);init();
        }// 添加数据方法
        public V put(K key, V value) {// 判断key是否为nullif (key == null)return putForNullKey(value);// 获取key的哈希值int hash = hash(key);// 获取在table数组中存放的位置int i = indexFor(hash, table.length);// 看table数组位置上是否有数据for (Entry e = table[i]; e != null; e = e.next) {Object k;// 判断哈希值是否相等，如果相等判断equals是否为trueif (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;addEntry(hash, key, value, i);return null;
        }
        // 判断table是否需要扩容，如果需要扩容，则长度扩容2倍
        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);}createEntry(hash, key, value, bucketIndex);
        }
        // 把数据添加到HashMap中
        void createEntry(int hash, K key, V value, int bucketIndex) {Entry e = table[bucketIndex];table[bucketIndex] = new Entry<>(hash, key, value, e);size++;
        }
        

     2. jdk 8

        • new HashMap()：底层没有创建一个长度为16的数组。
        • jdk 8底层的数组是：Node[]，而非Entry[]。
        • 首次调用put()方法时，底层创建长度为16的数组。
        • jdk 8中底层结构：数组+链表(七上八下)+红黑树。
        • 当数组中的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 < 64时，此时此索引位置上的数据改为使用红黑树存储。

        static final float DEFAULT_LOAD_FACTOR = 0.75f;
        tatic final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
        // Bucket中链表长度大于该默认值，转为红黑树
        static final int TREEIFY_THRESHOLD = 8;
        // 桶中的Node被数化时最小的hash表容量
        static final int MIN_TREEIFY_CAPACITY = 64;// 空参构造器
        public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR;
        }// 添加数据方法
        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[] tab; Node p; int n, i;// 判断是否为第一次添加数据if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;// 判断添加数据在数组的位置是否为空if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {Node e; K k;// 判断数组不为空的位置第一个元素与添加元素哈希值是否相等，如果相等判断equals是否为trueif (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;else if (p instanceof TreeNode) // 判断数据是否为红黑树的方式存储e = ((TreeNode)p).putTreeVal(this, tab, hash, 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)// 把链表变为红黑树存储treeifyBin(tab, hash);break;}// 判断数组不为空的位置里的元素与添加元素哈希值是否相等// 如果相等判断equals是否为trueif (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}// 看是否有元素的哈希值一样与equals方法也为trueif (e != null) {V oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold)resize();afterNodeInsertion(evict);return null;
        }
        // 第一次添加数据或者扩容
        final Node[] resize() {Node[] oldTab = table;int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;int newCap, newThr = 0;// 此if执行elseif (oldCap > 0) { .....} else if (oldThr > 0){ .....} else {// newCap = 16, newThr = 12newCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}// 此if不执行if (newThr == 0) { .... }// threshold = 12threshold = newThr;// 初始化table数组，长度为16@SuppressWarnings({"rawtypes","unchecked"})Node[] newTab = (Node[])new Node[newCap];table = newTab;// 此if不执行if (oldTab != null) { ..... }return newTab;
        }final void treeifyBin(Node[] tab, int hash) {int n, index; Node e;// 链表长度大于8并且小于64if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();else if ((e = tab[index = (n - 1) & hash]) != null) {TreeNode hd = null, tl = null;do {TreeNode p = replacementTreeNode(e, null);if (tl == null)hd = p;else {p.prev = tl;tl.next = p;}tl = p;} while ((e = e.next) != null);if ((tab[index] = hd) != null)hd.treeify(tab);}
        }
        

2. LinkedHashMap

   ​ LinkedHashMap是HashMap的子类。

   ​ 保证在遍历map元素时，可以按照添加的顺序实现遍历。在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。

   final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {if ((p = tab[i = (n - 1) & hash]) == null)// LinkedHashMap重写了newNode方法tab[i] = newNode(hash, key, value, null);else { ... }
   }
   // 重写的newNode方法
   Node newNode(int hash, K key, V value, Node e) {LinkedHashMap.Entry p = new LinkedHashMap.Entry(hash, key, value, e);linkNodeLast(p);return p;
   }
   // LinkedHashMap中的Entry
   static class Entry extends HashMap.Node {Entry before, after;Entry(int hash, K key, V value, Node next) {super(hash, key, value, next);}
   }
   

3. Map接口的常用方法

   • Object put(Object key, Object value)：将指定key-value添加到(或修改)当前map对象中。
   • void putAll(Map m)：将m中的所有key-value对存放到当前map中。
   • Object remove(Object key)：移除指定key的key-value对，并返回value。
   • void clear()：清空当前map中的所有数据。

   Map map = new HashMap();
   map.put("AA", 123);
   map.put(45, 123);
   map.put("BB", 56);map.put("AA", 87);
   System.out.println(map); // {AA=87, BB=56, 45=123}Map map1 = new HashMap();
   map1.put("CC", 123);
   map.put("DD", 123);
   map.putAll(map1);
   System.out.println(map); // {AA=87, BB=56, DD=123, CC=123, 45=123}Object value = map.remove("CC");
   System.out.println(value); // 123
   System.out.println(map); // {AA=87, BB=56, DD=123, 45=123}map.clear();
   System.out.println(map.size());  // 0
   System.out.println(map); // {}
   

   • Object get(Object key)：获取指定key对应的value。
   • boolean containsKey(Object key)：是否包含指定的key。
   • boolean containsValue(Object value)：是否包含指定的value。
   • int size()：返回map中key-value对的个数。
   • boolean isEmpty()：判断当前map是否为空、
   • boolean equals(Object obj)：判断当前map和参数对象Object是否相等。

   Map map = new HashMap();
   map.put("AA", 123);
   map.put(45, 123);
   map.put("BB", 56);
   System.out.println(map.get(45)); // 123boolean isExist = map.containsKey("BB");
   System.out.println(isExist); // trueisExist = map.containsValue(123); 
   System.out.println(isExist); // truemap.clear();
   System.out.println(map.isEmpty()); // true
   

   • Set keySet()：返回所有key构成的Set集合。
   • Collection values()：返回所有value构成的Collection集合。
   • Set entrySet()：返回所有key-value对构成的Set集合。

   Map map = new HashMap();
   map.put("AA", 123);
   map.put(45, 1234);
   map.put("BB", 56);Set set = map.keySet();
   Iterator iterator = set.iterator();
   while(iterator.hasNext()) {System.out.print(iterator.next() + "\t"); // AA	BB	45	
   }
   System.out.println();Collection values= map.values();
   for(Object obj: values) {System.out.print(obj + "\t"); // 123	56	1234	
   }
   System.out.println();Set entrySet = map.entrySet();
   Iterator iterator1 = entrySet.iterator();
   while(iterator1.hasNext()) {Object obj = iterator1.next();Map.Entry entry = (Map.Entry) obj;System.out.print(entry.getKey() + "-" + entry.getValue() + "\t"); // AA-123	BB-56	45-1234	
   }
   System.out.println();Set keySet = map.keySet();
   Iterator iterator2 = keySet.iterator();
   while(iterator2.hasNext()) {Object key = iterator2.next();Object value = map.get(key);System.out.print(key + "=" + value + "\t"); // AA=123	BB=56	45=1234	
   }
   

4. TreeMap

   • 保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。

   • TreeSet底层使用红黑树结构存储数据。‘

   • TreeMap的key必须实现Comparable或者Comparator接口。

   • TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

5. Properties

   Properties的父类是Hashtable，是古老的实现类，线程安全的，效率低，不能存储null的key和value。

   Properties常用来处理配置文件。key和value都是String类型。

   Properties pros = new Properties();
   pros.load(new FileInputStream("jdbc.properties"));
   String user = pros.getProperty("user");
   System.out.println(user);
   

9.7：Collections工具类

Collections是一个操作Set、List、Map等集合的工具类。

1. 排序操作

   • reverse(List)：反转List中元素的顺序。
   • shuffle(List)：对List集合元素进行随机排序。
   • sort(List)：根据元素的自然顺序对指定List集合元素按升序排序。
   • sort(List, Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序。
   • swap(List, int, int)：将指定list集合中的i处元素和j处元素进行交换。

2. 查找、替换

   • Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素。

   • Object max(Collection, Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素。

   • Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素。

   • Object min(Collection, Comparator)：根据Comparator指定的顺序，返回给定集合中的最小元素。

   • int frequency(Collection, Object)：返回指定集合中指定元素的出现次数。

   • void copy(List dest, List src)：将src中的内容复制到dest中。

     注意：dest的长度要大于等于src的长度，不然会报错。

   • boolean replaceAll(List list, Object oldVal, Object newVal)：使用新值替换List对象的所有旧值。

   ​ Collections类中提供了多个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

3. Enumeration

   Enumeration接口是Iterator迭代器的"古老版本"。

   Enumeration stringEnum = new StringTokenizer("a-b*c-d-e-g", "-");
   while(stringEnum.hasMoreElements()){Object obj = stringEnum.nextElement();System.out.print(obj + "\t"); // a	b*c	d	e	g	
   }