Java 集合类（Map和Collection）

1 引言

集合是java中提供的大小可变的容器。

集合分为单列结合Collection和双列集合Map。

集合和数组的区别：

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储任意类型数据。集合存储的都是引用数据类型，如果想存储基本类型数据需要存储对应的包装类型。

2 Collection

2.1 继承体系

Collection：单列集合类的根接口，Collection接口又派生出三个子接口，分别是java.util.List、java.util.Set和java.util.Queue。

注：紫色框体代表接口，其中加粗的是代表四类集合的接口。蓝色框体代表实现类，其中有阴影的是常用实现类。

List的特点是元素有序、元素可重复、有索引（可通过索引遍历集合）。

1. ArrayList：集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
2. LinekdList：集合数据存储的结构是双向链表结构。方便元素添加、删除的集合（增删首尾元素尤其快）。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。
3. Vector：大多数操作与ArrayList相同，区别之处在于Vector是线程安全的，但性能略差。

Set的特点是元素不可重复、无索引（不可通过索引遍历集合）、底层均为值为空的Map。

1. HashSet：添加的元素是无序，不重复，无索引的。增删改查的性能都很好。根据对象的哈希值来确定元素在集合中的存储位置，具有良好的存储和查找性能。依赖hashCode与equals方法保证元素唯一性。在JDK1.8之前，哈希表底层采用数组+链表实现。这存在一个问题，就是当hash值相等的元素较多时，通过key值依次查找链表元素的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值 8 时，将链表转换为红黑树，这样大大减少了查找时间。tips:数组初始容量为16，当如果使用率超过0.75（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128…等）
2. LinkedHashSet：添加的元素是有序，不重复，无索引的。LinkedHashSet是HashSet的子类，依然是使用哈希表存储元素，区别是LinkedHashSet使用了一个双向链表来维护元素的次序，这使得元素看起来是以插入顺序保存的。LinkedHashSet插入性能略低于HashSet且多了一个存储顺序的链会占内存空间，但在迭代访问 Set 里的全部元素时有很好的性能。
3. TreeSet：添加的元素是按照大小默认升序排序、不重复、无索引的。底层依赖于TreeMap，是一种基于红黑树的实现。需要使用自然排序（元素实现Comparable接口）或者定制排序（创建 TreeSet 时提供Comparator比较器）来实现对元素进行排序。如果同时使用了自然排序和定制排序，生效的是定制排序。

Queue：先进先出（FIFO）的队列；

2.2 Collection 常用API

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法。如下所示：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中（可以通过String[]::new指定返回数组的类型为String）

2.3 Collection 的三种遍历方式

Collection集合的遍历方式是全部集合都可以直接使用的。

Collection集合的遍历方式有三种:

• 迭代器Iterator
• foreach(增强for循环)
• JDK 1.8开始之后的新技术Lambda表达式

2.3.1 Iterator迭代器

JDK专门提供了一个接口java.util.Iterator用于遍历集合中的所有元素。

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

Iterator接口的常用方法如下：

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

代码示例：

  	public static void main(String[] args) {
        Collection<String> coll = new ArrayList<String>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        //使用迭代器遍历。每个集合对象都有自己的迭代器。
        //泛型指的是迭代出元素的数据类型
        Iterator<String> it = coll.iterator();
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
  	}

tips:

1. 在进行集合元素获取时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会抛出java.util.NoSuchElementException没有集合元素异常。
2. 在进行集合元素获取时，如果添加或移除集合中的元素 , 将无法继续迭代 , 将会抛出ConcurrentModificationException并发修改异常.

2.3.2 增强for循环

foreach是一种遍历形式，可以遍历集合或者数组。

优点：foreach遍历集合实际上是迭代器遍历的简化写法。
缺点：foreach遍历无法知道遍历到了哪个元素了，因为没有索引。

代码示例：

    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        
        for (String ele : lists) {
            System.out.println(ele);
        }

        int[] ages = new int[]{17 , 18 , 38 , 21};
        for (int age : ages) {
            System.out.println(age);
        }
    }

2.3.3 Lambda表达式

    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        System.out.println(lists);
        
        lists.forEach(s -> {
            System.out.println(s);
        });
        // 简化版本（1）
        lists.forEach(s ->  System.out.println(s));
        // 简化版本（2）
        lists.forEach(System.out::println);
    }

2.4 Collections类

java.utils.Collections是集合工具类，用来对集合进行操作。

常用方法如下：

• public static <T> boolean addAll(Collection<? super T> c, T... elements):往集合中添加一些元素。
• public static void shuffle(List<?> list):打乱集合顺序。（注意：只能打乱有序的List集合）
• public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
• public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

这里涉及的知识点：泛型通配符、可变参数、自然排序、定制排序。

3 Map

3.1 继承体系

java.util.Map接口是Java提供的专门用来存放映射关系的对象的集合类。

注：紫色框体代表接口，其中加粗的是代表四类集合的接口。蓝色框体代表实现类，其中有阴影的是常用实现类。

• HashMap<K,V>：键是无序、不重复、无索引的，值不做要求。HashMap是最经典的、用的最多的键值对集合。存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，自定义对象作为键时要重写hashCode()方法、equals()方法。在JDK1.8之前，哈希表底层采用数组+链表实现。这存在一个问题，就是当hash值相等的元素较多时，通过key值依次查找链表元素的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值 8 时，将链表转换为红黑树，这样大大减少了查找时间。tips:数组初始容量为 16，当如果使用率超过 0.75（16*0.75=12）就会扩大容量为原来的 2 倍。（16扩容为32，依次为64,128…等）
• LinkedHashMap<K,V>：键是有序、不重复、无索引的，值不做要求。LinkedHashMap是HashMap的子类，依然是使用哈希表存储元素，区别是LinkedHashMap使用了一个双向链表来维护元素的次序，这使得元素看起来是以插入顺序保存的。
• TreeMap<K,V>：添加的元素是按照大小默认升序排序、不重复、无索引的。底层基于红黑树的实现。需要使用自然排序（元素实现Comparable接口）或者定制排序（创建 TreeSet 时提供Comparator比较器）来实现对元素进行排序。如果同时使用了自然排序和定制排序，生效的是定制排序。
• Hashtable<K,V>：大多数操作与HashMap相同，区别之处在于Hashtable是线程安全的，但性能略差。
• Properties: Hashtable 的子类，该对象用于处理属性文件。由于属性文件里的 key 和 value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型。存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法。

3.2 Map 常用API

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
• public boolean containKey(Object key):判断该集合中是否有此键。

tips:

• 使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；
• 若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

3.3 Map 的三种遍历方式

Map集合的遍历方式有三种:

• “键找值”的方式遍历（先获取Map集合全部的键，再根据遍历键找值。）
• “键值对”的方式遍历。
• JDK 1.8开始之后的新技术：Lambda表达式。

3.3.1 键找值

通过元素中的键，获取键所对应的值

操作步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示:get(K key)

    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("可口可乐",3);
        maps.put("雪碧",3);
        maps.put("脉动",5);
        maps.put("果粒橙",4);
        maps.put("魔爪",6);
        System.out.println(maps);

        // a.获取当前Map集合的全部键的集合 。
        Set<String> keys = maps.keySet();
        // b.通过遍历键然后通过键取对应的值
        for (String key : keys) {
            // 通过键取对应的值
            Integer value = maps.get(key);
            System.out.println(key + "=" + value);
        }
    }

3.3.2 键值对方式

通过集合中每个键值对Entry对象，获取键值对Entry对象中的键与值。

Entry键值对对象:

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

tips:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

操作步骤：

1. 获取Map集合中，所有的键值对对象（Map.Entry内部类），以Set集合形式返回。方法提示:entrySet()。
2. 遍历包含键值对Entry对象的Set集合，得到每一个键值对Entry对象。
3. 通过键值对Entry对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()

    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("可口可乐",3);
        maps.put("雪碧",3);
        maps.put("脉动",5);
        maps.put("果粒橙",4);
        maps.put("魔爪",6);
        System.out.println(maps);
        // 获取Map集合中，所有的键值对对象
        Set<Map.Entry<String,Integer>> entries = maps.entrySet();
        //  遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
        for (Map.Entry<String, Integer> entry : entries) {
            // 通过键值对(Entry)对象，获取Entry对象中的键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }

3.3.3 Lambda表达式

    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("可口可乐",3);
        maps.put("雪碧",3);
        maps.put("脉动",5);
        maps.put("果粒橙",4);
        maps.put("魔爪",6);
        
        maps.forEach((k , v) -> {
            System.out.println(k+"="+v);
        });
        // 简化版本        
        maps.forEach((k , v) -> System.out.println(k+"="+v));
    }

4 集合类常考面试题

Collection的remove方法和List的remove方法的区分

    public static void main(String[] args) throws ParseException {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //删除的是索引为2的元素
        list.remove(2);
        //删除的是值为2的元素
        list.remove(Integer.valueOf(2));
        System.out.println(list);
    }

请问ArrayList/LinkedList/Vector的异同？谈谈你的理解？ArrayList底层是什么？扩容机制？Vector和ArrayList的最大区别?

• ArrayList和LinkedList的异同
  二者都线程不安全，相对线程安全的Vector，执行效率高。
  此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。
• ArrayList和Vector的区别
  Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。

Set集合添加的元素是不重复的，它是如何去重复的？

HashSet去重的原理：

向HashSet中添加元素的过程：

• 当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）
• 如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
• 如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功

如果希望HashSet集合认为两个对象只要内容一样就重复了，对应的类一定要重写equals()和hashCode()方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

TreeSet去重的原理：
通过compareTo()方法或者compare()方法的返回值判断，如果返回0，说明两个对象是重复的。

HashSet 添加删除元素的细节

    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person(1001,"AA");
        Person p2 = new Person(1002,"BB");
        set.add(p1);
        set.add(p2);
        // 修改了数组中person对象的属性值，但是其在底层数组中位置没变（依旧是由{id=1002, name='AA'}计算出的hashCode决定的）
        p1.name = "CC"; 
        // 删除的是由{id=1002, name='CC'}计算出的hashCode决定的位置上的对象，而此时该位置为空，因此没有元素被删除
        set.remove(p1); 
        System.out.println(set);
        // 由{id=1002, name='CC'}计算出的hashCode决定的位置为空，成功添加
        set.add(new Person(1001,"CC"));
        System.out.println(set);
        // 由{id=1002, name='AA'}计算出的hashCode决定的位置上存在一个{id=1002, name='CC'}，此时会调用和equals方法，返回false，成功添加
        set.add(new Person(1001,"AA"));
        System.out.println(set);
    }

输出：

[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]

利用 HashSet 去重

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(4);
        list.add(4);
        HashSet<Integer> set = new HashSet<>(list);
        List<Integer> list2 = new ArrayList<>(set);
        list2.forEach(System.out::println);
    }

谈谈你对HashMap的存储结构？对put/get方法的认识？

HashMap的内部存储结构其实是数组+链表+树的结合。

在put第一对映射关系时，系统会创建一个长度为initialCapacity的Node数组，这个长度在哈希表中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。每个bucket中存储一个元素，即一个Node对象，但每一个Node对象可以带一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个TreeNode树。

HashMap的扩容机制?底层链表转变为树的条件？

当HashMap中的元素个数超过吞吐临界值 时，就会进行数组扩容。也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

吞吐临界值 = 容量(Capacity) * 负载因子(loadFactor)

当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有达到64，那么HashMap会先扩容，如果已经达到了64，那么这个链会变成树，结点类型由Node变成TreeNode类型。

当然，如果当映射关系被移除后，下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。

负载因子值的大小，对HashMap有什么影响？

负载因子的大小决定了HashMap的数据密度。

• 负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,
  造成查询或插入时的比较次数增多，性能会下降。
• 负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
• 按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数

HashMap的key能否修改？

可以改，但不建议修改。

映射关系存储到HashMap中会存储key的hash值，这样就不用在每次查找时重新计算每一个Entry或Node（TreeNode）的hash值了，因此如果已经put到Map中的映射关系，再修改key的属性，而这个属性又参与hashcode值的计算，那么会导致匹配不上，这样可能导致HashMap中出现相同的key。

Java中的容器，线程安全和线程不安全的分别有哪些？

java.util包下的集合类大部分都是线程不安全的，例如我们常用的HashSet、TreeSet、ArrayList、LinkedList、ArrayDeque、HashMap、TreeMap，这些都是线程不安全的集合类，但是它们的优点是性能好。如果需要使用线程安全的集合类，则可以使用Collections工具类提供的synchronizedXxx()方法，将这些集合类包装成线程安全的集合类。

**java.util包下也有线程安全的集合类，例如Vector、Hashtable。**这些集合类都是比较古老的API，虽然实现了线程安全，但是性能很差。所以即便是需要使用线程安全的集合类，也建议将线程不安全的集合类包装成线程安全集合类的方式，而不是直接使用这些古老的API。

从Java5开始，Java在java.util.concurrent包下提供了大量支持高效并发访问的集合类，它们既能包装良好的访问性能，有能包装线程安全。这些集合类可以分为两部分，它们的特征如下：

• 以Concurrent开头的集合类代表了支持并发访问的集合，它们可以支持多个线程并发写入访问，这些写入线程的所有操作都是线程安全的，但读取操作不必锁定。以Concurrent开头的集合类采用了更复杂的算法来保证永远不会锁住整个集合，因此在并发写入时有较好的性能。

• 以CopyOnWrite开头的集合类采用复制底层数组的方式来实现写操作。当线程对此类集合执行读取操作时，线程将会直接读取集合本身，无须加锁与阻塞。当线程对此类集合执行写入操作时，集合会在底层复制一份新的数组，接下来对新的数组执行写入操作。由于对集合的写入操作都是对数组的副本执行操作，因此它是线程安全的。