Java集合框架-CSDN博客

本文链接：https://blog.csdn.net/qq_45677189/article/details/130816769

数组的特点与弊端

一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。
另一方面，使用数组存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
数组在内存存储方面的特点：
- 数组初始化以后，长度就确定了。
- 数组中的添加的元素是依次紧密排列的，有序的，可以重复的。
- 数组声明的类型，就决定了进行元素初始化时的类型。不是此类型的变量，就不能添加。
- 可以存储基本数据类型值，也可以存储引用数据类型的变量。
数组在存储数据方面的弊端：
- 数组初始化以后，长度就不可变，不便于扩展。
- 数组中提供的属性和方法少，不便于进行添加、删除、插入、获取元素个数等操作，且效率不高。
- 数组存储数据的特点单一，只能存储有序的、可以重复的数据。
Java 集合框架中的类可以用于存储多个对象，还可用于保存具有映射关系的关联数组。

Java集合框架体系

Java 集合可分为 Collection 和 Map 两大体系：

Collection接口：用于存储一个一个的数据，也称单列数据集合。
List子接口：用来存储有序的、可以重复的数据（主要用来替换数组，"动态"数组）
- 实现类：ArrayList(主要实现类)、LinkedList、Vector
Set子接口：用来存储无序的、不可重复的数据（类似于高中讲的"集合"）
- 实现类：HashSet(主要实现类)、LinkedHashSet、TreeSet
Map接口：用于存储具有映射关系“key-value对”的集合，即一对一对的数据，也称双列数据集合。(类似于高中的函数、映射。(x1,y1),(x2,y2) —> y = f(x) )
- HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口及方法

JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set和List）去实现。
Collection 接口是 List和Set接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 集合。方法如下：

添加
（1）add(E obj)：添加元素对象到当前集合中
（2）addAll(Collection other)：添加other集合中的所有元素对象到当前集合中，即this = this ∪ other
注意：add和addAll的区别，add传入collection对象时，整体视为一个元素，addAll传入collection对象时，添加集合中的所有元素对象到当前集合中。
向Collection中添加元素的要求：要求元素所属的类一定要重写equals()方法，因为Collection中的相关方法（比如： contains(Object obj)、remove(Object obj)）在使用时，要调用元素所在类的equals()。

判断
（3）int size()：获取当前集合中实际存储的元素个数
（4）boolean isEmpty()：判断当前集合是否为空集合
（5）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素，基本数据类型比较的是内容，自定义类型默认比较的是地址。
（6）boolean containsAll(Collection coll)：判断coll集合中的元素是否在当前集合中都存在。即coll集合是否是当前集合的“子集”
（7）boolean equals(Object obj)：判断当前集合与obj是否相等

删除
（8）void clear()：清空集合元素
（9） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。
（10）boolean removeAll(Collection coll)：从当前集合中删除所有与coll集合中相同的元素。即this = this - this ∩ coll
（11）boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与coll集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this = this ∩ coll；
注意几种删除方法的区别

其它
（12）Object[] toArray()：返回包含当前集合中所有元素的数组
（13）hashCode()：获取集合对象的哈希值
（14）iterator()：返回迭代器对象，用于集合遍历

Iterator(迭代器)接口

程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同。
- Collection接口与Map接口主要用于存储元素
- Iterator，被称为迭代器接口，本身并不提供存储对象的能力，主要用于遍历Collection中的元素。
Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
- public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
Iterator接口的常用方法如下：
- public E next():返回迭代的下一个元素。
- public boolean hasNext():如果仍有元素可以迭代，则返回 true。
注意：在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。

使用Iterator迭代器删除元素：java.util.Iterator迭代器中有一个方法：void remove() ;
注意：

Iterator可以删除集合的元素，但是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
如果还未调用next()或在上一次调用 next() 方法之后已经调用了 remove() 方法，再调用remove()都会报IllegalStateException。
Collection已经有remove(xx)方法了，为什么Iterator迭代器还要提供删除方法呢？因为迭代器的remove()可以按指定的条件进行删除。

对于集合的遍历，增强for的内部原理其实是个Iterator迭代器。

增强for用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。增强for循环的执行过程中，是将集合或者数组中的元素依次赋值给临时变量，注意，循环体中对临时变量的修改，可能不会导致原有集合或数组元素的改变。

		Collection collection = new ArrayList();
        //添加
        //（1）add(E obj)：添加元素对象到当前集合中
        //（2）addAll(Collection other)：添加other集合中的所有元素对象到当前集合中，即this = this ∪ other
        collection.add("AAA");
        collection.add(123);
        collection.add(new Object());
        collection.add(new Person("Tom", 23));
        System.out.println("collection:" + collection);
        System.out.println("collection size:" + collection.size());

        Collection collection1 = new ArrayList();
        collection1.add("BBB");
        collection1.add(345);
        collection.addAll(collection1);
        System.out.println("collection:" + collection);
        System.out.println("collection size:" + collection.size());

        /**
         * 判断
         * （3）int size()：获取当前集合中实际存储的元素个数
         * （4）boolean isEmpty()：判断当前集合是否为空集合
         * （5）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素
         * （6）boolean containsAll(Collection coll)：判断coll集合中的元素是否在当前集合中都存在。即coll集合是否是当前集合的“子集”
         * （7）boolean equals(Object obj)：判断当前集合与obj是否相等
         */
        System.out.println("contains AAA:"+collection.contains("AAA"));
        System.out.println("collection containsAll collection1:"+collection.containsAll(collection1));

        // 删除
        // （8）void clear()：清空集合元素
        // （9） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。
        // （10）boolean removeAll(Collection coll)：从当前集合中删除所有与coll集合中相同的元素。
        // 即this = this - this ∩ coll
        // （11）boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合
        // 仅保留与coll集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this  = this ∩ coll；
        // 注意几种删除方法的区别
        collection1.clear();
        System.out.println("collection1 size:"+collection1.size());
        collection.remove(123);
        System.out.println("collection:" + collection);

        // 其它
        // （12）Object[] toArray()：返回包含当前集合中所有元素的数组
        // （13）hashCode()：获取集合对象的哈希值
        // （14）iterator()：返回迭代器对象，用于集合遍历
        System.out.println("collection hashCode:"+collection.hashCode());
        Iterator iterator = collection.iterator();
        System.out.println(iterator.getClass()); //class java.util.ArrayList$Itr
        //迭代器遍历    iterator.hasNext(); 判断是否还有下一个元素
        // iterator.next();  指针下移，将下移以后集合位置上的元素返回。
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        // 集合--->数组
        Object[] objects = collection.toArray();
        System.out.println(Arrays.toString(objects));
        // 数组--->集合 调用Arrays的asList方法
        String[] arr = new String[]{"AA","BB","CC"};
        List<String> strings = Arrays.asList(arr);
        System.out.println(strings);

        Integer[] integers = new Integer[]{1,2,3};
        List<Integer> integerList = Arrays.asList(integers);
        System.out.println("integerList size:"+integerList.size()); //3

        int[] arr1= new int[]{1,2,3};
        List<int[]> list = Arrays.asList(arr1);
        System.out.println("list size:"+list.size()); //1

List接口

鉴于Java中数组用来存储数据的局限性，我们通常使用java.util.List替代数组
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
- 举例：List集合存储数据，就像银行门口客服，给每一个来办理业务的客户分配序号：第一个来的是“张三”，客服给他分配的是0；第二个来的是“李四”，客服给他分配的1；以此类推，最后一个序号应该是“总人数-1”。
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

List接口方法
List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。

插入元素
- void add(int index, Object ele):在index位置插入ele元素
- boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
获取元素
- Object get(int index):获取指定index位置的元素
- List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
获取元素索引
- int indexOf(Object obj):返回obj在集合中首次出现的位置
- int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
删除和替换元素
- Object remove(int index):移除指定index位置的元素，并返回此元素
- Object set(int index, Object ele):设置指定index位置的元素为ele

注意：在JavaSE中List名称的类型有两个，一个是java.util.List集合接口，一个是java.awt.List图形界面的组件，别导错包了。

List接口主要实现类：ArrayList

ArrayList 是 List 接口的主要实现类
本质上，ArrayList是对象引用的一个”变长”数组，底层使用Object[]数组存储
Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

LinkedList

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。这是由底层采用链表（双向链表）结构存储数据决定的。
特有方法：
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()

List的实现类之三：Vector

Vector 是一个古老的集合，JDK1.0就有，底层使用Object[]数组存储。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的，效率低。
在各种List中，最好把ArrayList作为默认选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。
特有方法：
- void addElement(Object obj)
- void insertElementAt(Object obj,int index)
- void setElementAt(Object obj,int index)
- void removeElement(Object obj)
- void removeAllElements()

		List list = new ArrayList();
        //add(Object obj)
        list.add("AA");
        list.add("BB");
        list.add(123);
        list.add(new Person("Jerry",3));

        System.out.println(list.toString());
        //add(int index, Object ele)
        list.add(2,"CC");
        System.out.println(list);

        //addAll(int index,Collection eles)
        List<Integer> integerList = Arrays.asList(1, 2, 3);
        list.addAll(integerList);
        System.out.println(list);

        //删除索引为2的元素
        list.remove(2);
        System.out.println(list);

        //删除数据为2的元素
        list.remove(Integer.valueOf(2));
        System.out.println(list);

        //迭代器遍历list
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //增强for遍历list
        for (Object obj : list) {
            System.out.println(obj);
        }

Set接口

Set接口是Collection的子接口，Set接口相较于Collection接口没有提供额外的方法
Set 集合不允许包含相同的元素，主要用于过滤重复数据，如果试图把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
Set集合支持的遍历方式和Collection集合一样：foreach和Iterator。
Set的常用实现类有：HashSet、TreeSet、LinkedHashSet。Set主要实现类：HashSet

HashSet概述

HashSet 是 Set 接口的主要实现类，底层使用HashMap，即使用数组+单向链表+红黑树结构进行存储（JDK8中），大多数时候使用 Set 集合时都使用这个实现类，LinkedHashSet是HashSet的子类，在现有的数组+单向链表+红黑树的基础上，又添加了一组双向链表，用于记录添加元素的先后顺序，即我们可以按照添加元素的顺序实现遍历，便于频繁的查询操作。
**
**
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存储、查找、删除性能。
HashSet 具有以下特点：
- 不能保证元素的排列顺序
- HashSet 不是线程安全的
- 集合元素可以是 null
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法得到的哈希值相等，并且两个对象的 equals() 方法返回值为true。
对于存放在Set容器中的对象，对应的类一定要重写hashCode()和equals(Object obj)方法，以实现对象相等规则。即“相等的对象必须具有相等的散列码”。
HashSet集合中元素的无序性，不等同于随机性。添加元素的顺序和遍历元素的顺序不一致不是无序性，这里的无序性与元素的添加位置有关。具体来说：我们在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的hash值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性。

HashSet中添加元素的过程：

第1步：当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法得到该对象的 hashCode值，然后根据 hashCode值，通过某个散列函数决定该对象在 HashSet 底层数组中的存储位置。
第2步：如果要在数组中存储的位置上没有元素，则直接添加成功。
第3步：如果要在数组中存储的位置上有元素，则继续比较：
- 如果两个元素的hashCode值不相等，则添加成功；
- 如果两个元素的hashCode()值相等，则会继续调用equals()方法：
  - 如果equals()方法结果为false，则添加成功。
  - 如果equals()方法结果为true，则添加失败。
第2步添加成功，元素会保存在底层数组中。

第3步两种添加成功的操作，由于该底层数组的位置已经有元素了，则会通过链表的方式继续链接，存储。

重写 hashCode() 方法的基本原则

在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等。
对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

注意：如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

重写equals()方法的基本原则

重写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
推荐：开发中直接调用Eclipse/IDEA里的快捷键自动重写equals()和hashCode()方法即可。
- 为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？
  首先，选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
  其次，31只占用5bits,相乘造成数据溢出的概率较小。
  再次，31可以由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
  最后，31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有1来整除！(减少冲突)

Set实现类之二：LinkedHashSet

LinkedHashSet 是 HashSet 的子类，不允许集合元素重复。
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以添加顺序保存的。
LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。

Set实现类之三：TreeSet

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以按照添加的元素的指定的属性的大小顺序进行遍历，添加到TreeSet中的元素必须是同一个类型的对象，否则报ClassCastException。
判断数据是否相同的标准：不再是考虑hashCode()和equals()方法，也就意味着添加到TreeSet中的元素所在的类不需要重写这两个方法，比较元素大小或比较元素是否相等的标准就是考虑自然排序或定制排序中，compareTo()或compare()的返回值。如果返回值为0，认为两个对象是相等的。由于TreeSet中不能存放相同的元素，则后一个相等的元素就不能添加到TreeSet中。
TreeSet底层使用红黑树结构存储数据
新增的方法如下： (了解)
- Comparator comparator()
- Object first()
- Object last()
- Object lower(Object e)
- Object higher(Object e)
- SortedSet subSet(fromElement, toElement)
- SortedSet headSet(toElement)
- SortedSet tailSet(fromElement)
TreeSet特点：不允许重复、实现排序（自然排序或定制排序）
TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。
- 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。
  - 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
  - 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
- 定制排序：如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
  - 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
  - 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。
对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 或compare(Object o1,Object o2)方法比较返回值。返回值为0，则认为两个对象相等。

		Set set1 = new HashSet();
        set1.add("AAA");
        set1.add("AAA");
        set1.add("BBB");
        set1.add(new Person("Tom", 23));
        set1.add(123);
        set1.add(456);

        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }

        System.out.println(set1.contains(new Person("Tom", 23)));
        System.out.println();

        Set set2 = new LinkedHashSet();
        set2.add("AAA");
        set2.add("BBB");
        set2.add(new Person("Tom", 23));
        set2.add(123);
        set2.add(456);

        Iterator iterator2 = set2.iterator();
        while (iterator2.hasNext()) {
            System.out.println(iterator2.next());
        }

        System.out.println(set2.contains(new Person("Tom", 23)));
        System.out.println();

        TreeSet treeSet = new TreeSet();
        treeSet.add("CC");
        treeSet.add("BB");
        treeSet.add("QQ");
        treeSet.add("KK");
        treeSet.add("UU");
        //treeSet.add(123);  //ClassCastException: java.lang.String cannot be cast to java.lang.Integer
        Iterator iterator3 = treeSet.iterator();
        while (iterator3.hasNext()) {
            System.out.println(iterator3.next());
        }
        System.out.println();

        TreeSet userTreeSet = new TreeSet();
        User user1 = new User("Tom", 22);
        User user2 = new User("Jerry", 12);
        User user3 = new User("Pony", 52);
        User user4 = new User("David", 22);
        User user5 = new User("Helen", 32);

        userTreeSet.add(user1);
        userTreeSet.add(user2);
        userTreeSet.add(user3);
        userTreeSet.add(user4);
        userTreeSet.add(user5);
        Iterator userIterator = userTreeSet.iterator();
        while (userIterator.hasNext()) {
            System.out.println(userIterator.next());
        }
        System.out.println();

        Comparator comparator = new Comparator() {
            //按照先按姓名A-Z排序，再按年龄从大到小排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User) {
                    User user1 = (User) o1;
                    User user2 = (User) o2;
                    int value = user1.getName().compareTo(user2.getName());
                    if (value != 0) {
                        return value;
                    } else {
                        return -(user1.getAge() - user2.getAge());
                    }
                }
                throw new RuntimeException("数据类型不一致!");
            }
        };

        TreeSet userComparatorTreeSet = new TreeSet(comparator);
        User user6 = new User("Tom", 22);
        User user7 = new User("Jerry", 12);
        User user8 = new User("Pony", 52);
        User user9 = new User("David", 22);
        User user10 = new User("Helen", 32);
        User user11 = new User("Hello", 62);

        userComparatorTreeSet.add(user6);
        userComparatorTreeSet.add(user7);
        userComparatorTreeSet.add(user8);
        userComparatorTreeSet.add(user9);
        userComparatorTreeSet.add(user10);
        userComparatorTreeSet.add(user11);

        Iterator userComparatorIterator = userComparatorTreeSet.iterator();
        while (userComparatorIterator.hasNext()) {
            System.out.println(userComparatorIterator.next());
        }

        //去除list中的重复元素，通过set实现
        //方式1
        List list = new ArrayList();
        list.add(123);
        list.add(123);
        list.add(456);
        list.add(234);
        list.add(555);
        list.add(666);
        list.add(456);
        HashSet set = new HashSet();
        for (Object o : list) {
            set.add(o);
        }
        List newList = new ArrayList();
        for (Object o : set) {
            newList.add(o);
        }
        System.out.println(newList);

        //方式2
        HashSet hashSet = new HashSet(list);
        List newArrayList = new ArrayList(hashSet);
        System.out.println(newArrayList);

        //编写一个程序，获取10个1-20的随机数，要求随机数不能重复，并输出随机数的结果
        Set hashSet1 = new HashSet();
        while (hashSet1.size() < 10) {
            int random = (int) (Math.random() * (20 - 1 + 1) + 1);
            hashSet1.add(random);
        }
        Iterator iterator = hashSet1.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

Map接口

现实生活与开发中，我们常会看到这样的一类集合：用户ID与账户信息、学生姓名与考试成绩、IP地址与主机名等，这种一一对应的关系，就称作映射。Java提供了专门的集合框架用来存储这种映射关系的对象，即java.util.Map接口。

Map接口概述

Map与Collection并列存在。用于保存具有映射关系的数据：key-value
- Collection集合称为单列集合，元素是孤立存在的（理解为单身）。
- Map集合称为双列集合，元素是成对存在的(理解为夫妻)。
Map 中的 key 和 value 都可以是任何引用类型的数据。但常用String类作为Map的“键”。
Map接口的常用实现类：HashMap、LinkedHashMap、TreeMap和``Properties。其中，HashMap是 Map 接口使用频率最高`的实现类。

Map中key-value特点
这里主要以HashMap为例说明。HashMap中存储的key、value的特点如下：

Map 中的 key用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法。
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value，不同key对应的value可以重复。value所在的类要重写equals()方法。
key和value构成一个entry。所有的entry彼此之间是无序的、不可重复的。

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中的所有数据
元素查询的操作：
- 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和参数对象obj是否相等
元视图操作的方法：
- Set keySet()：返回所有key构成的Set集合
- Collection values()：返回所有value构成的Collection集合
- Set entrySet()：返回所有key-value对构成的Set集合

Map的主要实现类：HashMap

HashMap是 Map 接口使用频率最高的实现类。
HashMap是线程不安全的。允许添加 null 键和 null 值。
存储数据采用的哈希表结构，底层使用一维数组+单向链表+红黑树进行key-value数据的存储。与HashSet一样，元素的存取顺序不能保证一致。
HashMap 判断两个key相等的标准是：两个 key 的hashCode值相等，通过 equals() 方法返回 true。
HashMap 判断两个value相等的标准是：两个 value 通过 equals() 方法返回 true。

LinkedHashMap：是HashMap的子类，在HashMap使用的数据结构的基础上，增加了一对双向链表，用于记录添加元素的先后顺序，进而我们在遍历元素的时候就可以按照添加的顺序显示。开发中，对于频繁的遍历操作，建议使用此类。
**TreeMap：底层使用红黑树存储，可以按照添加的key-value中的key元素的指定的属性的大小顺序进行遍历。**需要考虑使用自然排序或者定制排序。
要求：向TreeMap中添加的key必须是同一个类型的对象。

Hashtable：古老实现类，线程安全的，效率低，不可以添加null的key或value值，底层使用数组+单向链表结构存储(JDK8)。
Properties：是Hashtable的子类，其key和value都是String类型，常用来处理属性文件。

LinkedHashMap linkedHashMap = new LinkedHashMap();
        linkedHashMap.put(123, "AAA");
        linkedHashMap.put("CC", 445);
        linkedHashMap.put(456, new Date());
        System.out.println(linkedHashMap);

        //HashMap常用方法
        Map map = new HashMap();
        //Object put(Object key,Object value)
        map.put("AA", 56);
        map.put(12, "Tomcat");
        map.put("XX", "value");
        map.put(new Person("Mask", 33), 1234);

        System.out.println(map);
        System.out.println("size：" + map.size());
        //Object remove(Object key)
        Object remove = map.remove(12);
        System.out.println("removeValue:" + remove);
        System.out.println(map);
        //修改Object put(Object key,Object value)
        Object oldValue = map.put("AA", 456);
        System.out.println("oldValue:" + oldValue);
        System.out.println(map);

        //遍历
        // Set keySet()：返回所有key构成的Set集合
        Set keySet = map.keySet();
        Iterator keySetIterator = keySet.iterator();
        while (keySetIterator.hasNext()) {
            System.out.println(keySetIterator.next());
        }
        //遍历value集 Collection values()：返回所有value构成的Collection集合
        //方式1 推荐
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }

        //方式2 使用map的get方法通过key获取value
        for (Object key : keySet) {
            Object value = map.get(key);
            System.out.println(value);
        }

        //遍历entry集合的方式1 Set entrySet()：返回所有key-value对构成的Set集合
        Set entrySet = map.entrySet();
        Iterator entrySetIterator = entrySet.iterator();
        while (entrySetIterator.hasNext()) {
            //方法1
            // System.out.println(entrySetIterator.next());
            //方法2
            Map.Entry entry = (Map.Entry) entrySetIterator.next();
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }

        //遍历entry集合的方式2   keySet(),getKey()
        for (Object key : keySet) {
            System.out.println(key + "---" + map.get(key));
        }

        //TreeMap
        TreeMap treeMap = new TreeMap();
        treeMap.put("QQ", 123);
        treeMap.put("CC", 456);
        treeMap.put("AA", 789);
        treeMap.put("BB", 111);
        treeMap.put("QQ", 222);
        Set treeEntrySet = treeMap.entrySet();
        for (Object entry : treeEntrySet) {
            System.out.println(entry);
        }

        //TreeMap 自定义类自然排序
        TreeMap userTreeMap = new TreeMap();
        User user1 = new User("Tom", 22);
        User user2 = new User("Jerry", 12);
        User user3 = new User("Pony", 52);
        User user4 = new User("David", 22);
        User user5 = new User("Helen", 32);
        userTreeMap.put(user1, 01);
        userTreeMap.put(user2, 02);
        userTreeMap.put(user3, 03);
        userTreeMap.put(user4, 04);
        userTreeMap.put(user5, 05);
        Set userEntrySet = userTreeMap.entrySet();
        for (Object entry : userEntrySet) {
            System.out.println(entry);
        }
        System.out.println();

        //TreeMap 自定义类定制排序
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User) {
                    User user1 = (User) o1;
                    User user2 = (User) o2;
                    int value = user1.getAge() - user2.getAge();
                    if (value != 0) {
                        return value;
                    } else {
                        return user1.getName().compareTo(user2.getName());
                    }
                }
                throw new RuntimeException("数据类型不一致!");
            }
        };
        TreeMap userTreeMap1 = new TreeMap(comparator);
        User user6 = new User("Tom", 22);
        User user7 = new User("Jerry", 12);
        User user8 = new User("Pony", 52);
        User user9 = new User("David", 22);
        User user10 = new User("Helen", 32);
        User user11 = new User("Hello", 62);
        userTreeMap1.put(user6, 6);
        userTreeMap1.put(user7, 7);
        userTreeMap1.put(user8, 8);
        userTreeMap1.put(user9, 9);
        userTreeMap1.put(user10, 10);
        userTreeMap1.put(user11, 11);
        Set userEntrySet1 = userTreeMap1.entrySet();
        for (Object entry : userEntrySet1) {
            System.out.println(entry);
        }

Collections工具类

参考操作数组的工具类：Arrays，Collections 是一个操作 Set、List 和 Map 等集合的工具类。

常用方法
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法（均为static方法）：

排序操作：

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

查找

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
Object min(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最小元素
int binarySearch(List list,T key)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。
int binarySearch(List list,T key,Comparator c)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定。
int frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数

复制、替换

void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
提供了多个unmodifiableXxx()方法，该方法返回指定 Xxx的不可修改的视图。

添加

boolean addAll(Collection c,T… elements)将所有指定元素添加到指定 collection 中。

同步

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

 //排序操作
        // - reverse(List)：反转 List 中元素的顺序
        // - shuffle(List)：对 List 集合元素进行随机排序
        // - sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        // - sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        // - swap(List，int i， int j)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        List list = Arrays.asList(45, 324, 6346, 22, -34, 3425, -3566, 47, 1, 0, -1);
        Collections.reverse(list);
        System.out.println("reverseList:"+list);
        Collections.shuffle(list);
        System.out.println("shuffleList:"+list);
        Collections.sort(list);
        System.out.println("sortList:"+list);
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Integer && o2 instanceof Integer){
                    Integer i1 = (Integer) o1;
                    Integer i2 = (Integer) o2;
                    return -(i1.intValue() - i2.intValue());
                }
                throw new RuntimeException("数据类型不一致!");
            }
        });
        System.out.println("sortComparatorList:"+list);
        Collections.swap(list,0,1);
        System.out.println("swap[0,1]:"+list);

        //查找
        // - Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        // - Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        // - Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
        // - Object min(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最小元素
        // - int binarySearch(List list,T key)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。
        // - int binarySearch(List list,T key,Comparator c)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定。
        // - int frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数
        Object max = Collections.max(list);
        System.out.println("max:"+max);
        Object max1 = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Integer && o2 instanceof Integer) {
                    Integer i1 = (Integer) o1;
                    Integer i2 = (Integer) o2;
                    return -(i1.intValue() - i2.intValue());
                }
                throw new RuntimeException("数据类型不一致!");
            }
        });
        System.out.println("max1:"+max1);
        int count = Collections.frequency(list, 0);
        System.out.println("0 count:"+count);

        // 复制、替换
        // - void copy(List dest,List src)：将src中的内容复制到dest中
        // - boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
        // - 提供了多个unmodifiableXxx()方法，该方法返回指定 Xxx的不可修改的视图。

        //错误的写法：IndexOutOfBoundsException: Source does not fit in dest
        // List desc = new ArrayList();
        // Collections.copy(desc,list);
        // System.out.println(desc);
        List desc = Arrays.asList(new Object[list.size()]);
        Collections.copy(desc,list);
        System.out.println("desc:"+list);

        List unmodifiableList = Collections.unmodifiableList(desc);
        // unmodifiableList.add(123);  //UnsupportedOperationException
        System.out.println("index 0:"+unmodifiableList.get(0));

        // 同步
        // - Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，
        // 从而可以解决多线程并发访问集合时的线程安全问题
        //线程安全的list
        List synList = Collections.synchronizedList(list);
        HashMap hashMap = new HashMap();
        //线程安全的Map
        Map synHashMap = Collections.synchronizedMap(hashMap);