java集合操作

java集合操作

1、java集合概述

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

1. Collection接口：单列数据，定义了存取一组对象的方法的集合

   List：元素有序、可重复的集合

   Set：元素无序、不可重复的集合

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

1.1、Collection接口继承树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eD0BRy3r-1593572915697)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508142343433.png)]

1.2、Map接口继承树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9voieAI1-1593572915700)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508142523629.png)]

2、 Collection 接口方法

Collection 接口

• Collection 接口是List、Set 和Queue 接口的父接口，该接口里定义的方法既可用于操作Set 集合，也可用于操作List 和Queue 集合。
• JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
• 在Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成Object 类型处理；从JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

1、添加

add(Objectobj)

addAll(Collectioncoll)

2、获取有效元素的个数

int size()

3、清空集合

void clear()

4、是否是空集合

boolean isEmpty()

5、是否包含某个元素

boolean contains(Objectobj)：是通过元素的equals方法来判断是否是同一个对象

boolean containsAll(Collectionc)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。

6、删除

boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素

boolean removeAll(Collection coll)：取当前集合的差集

7、取两个集合的交集

boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c

8、集合是否相等

boolean equals(Object obj)

9、转成对象数组

Object[] toArray()

10、获取集合对象的哈希值

hashCode()

11、遍历

iterator()：返回迭代器对象，用于集合遍历

3、Iterator迭代器接口

3.1、使用Iterator接口遍历集合元素

• Iterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection 集合中的元素。
• GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
• Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
• Iterator 仅用于遍历集合，Iterator本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
• 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

3.2、Iterator接口的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7QewEBYn-1593572915702)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508144214109.png)]

在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。

3.3、迭代器的执行原理

Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
    //next():①指针下移②将下移以后集合位置上的元素返回
    System.out.println(iterator.next());
}

3.4、Iterator接口remove()方法

Iterator iter= coll.iterator();
//回到起点
while(iter.hasNext()){
    Object obj= iter.next();
    if(obj.equals("Tom")){
        iter.remove();
    }
}

注意：

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

3.5、使用foreach循环遍历集合元素

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

public class ForTest {
    public static void main(String[] args) {
        String[] str= newString[5];
        for(String myStr: str) {
            myStr= "atguigu";
            System.out.println(myStr);
        }
        for(inti= 0; i< str.length; i++) {
            System.out.println(str[i]);
        }
    }
}

4、Collection子接口之一：List接口

4.1、List接口概述

• 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
• 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位置的元素
• int indexOf(Object obj):返回obj在集合中首次出现的位置
• int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
• Object remove(intindex):移除指定index位置的元素，并返回此元素
• Object set(intindex, Object ele):设置指定index位置的元素为ele
• List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

4.2、List实现类之一：ArrayList

ArrayList是List 接口的典型实现类、主要实现类

• 本质上，ArrayList是对象引用的一个”变长”数组ArrayList的JDK1.8之前与之后的实现区别？
• JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组
• JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
• Arrays.asList(…) 方法返回的List 集合，既不是ArrayList实例，也不是Vector 实例。Arrays.asList(…) 返回值是一个固定长度的List 集合

4.3、List实现类之二：LinkedList

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

• 新增方法：
• void addFirst(Object obj)
• void addLast(Object obj)
• Object getFirst()
• Object getLast()
• Object removeFirst()
• Object removeLast()

LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。

Node除了保存数据，还定义了两个变量：

• prev变量记录前一个元素的位置
• next变量记录下一个元素的位置

4.4、List 实现类之三：Vector

1. Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
2. 在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。
3. 新增方法：

• void addElement(Object obj)
• void insertElementAt(Object obj,int index)
• void setElementAt(Object obj,int index)
• void removeElement(Object obj)
• void removeAllElements()

4.5、面试题

1、ArrayList和LinkedList的异同

二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

2、ArrayList和Vector的区别

Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。

5、Collection子接口之二：Set接口

5.1、Set 接口概述

• Set接口是Collection的子接口，set接口没有提供额外的方法
• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set 集合中，则添加操作失败。
• Set 判断两个对象是否相同不是使用== 运算符，而是根据equals() 方法

5.2、Set实现类之一：HashSet

• HashSet是Set 接口的典型实现，大多数时候使用Set 集合时都使用这个实现类。
• HashSet按Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
• HashSet具有以下特点：
• 不能保证元素的排列顺序
• HashSet不是线程安全的
• 集合元素可以是null
• HashSet 集合判断两个元素相等的标准：两个对象通过hashCode() 方法比较相等，并且两个对象的equals() 方法返回值也相等。
• 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

向HashSet中添加元素的过程：

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

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

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

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

以自定义的Customer类为例，何时需要重写equals()？

• 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。
• 因此，违反了“相等的对象必须具有相等的散列码”。
• 结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

5.3、Set实现类之二：LinkedHashSet

LinkedHashSet是HashSet的子类

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

5.4、Set实现类之三：TreeSet

TreeSet是SortedSet接口的实现类，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和后面要讲的TreeMap采用红黑树的存储结构

特点：有序，查询速度比List快

5.4.1、排序—自然排序

• 自然排序：TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列
• 如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable 接口。
• 实现Comparable 的类必须实现compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。
• Comparable 的典型实现：

1. BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
2. Character：按字符的unicode值来进行比较
3. Boolean：true 对应的包装类实例大于false 对应的包装类实例
4. String：按字符串中字符的unicode 值进行比较
5. Date、Time：后边的时间、日期比前面的时间、日期大

• 向TreeSet中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。

• 因为只有相同类的两个实例才会比较大小，所以向TreeSet中添加的应该是同一个类的对象。

• 对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj) 方法比较返回值。

• 当需要把一个对象放入TreeSet中，重写该对象对应的equals() 方法时，应保证该方法与compareTo(Object obj) 方法有一致的结果：如果两个对象通过equals() 方法比较返回true，则通过compareTo(Object obj) 方法比较应返回0。否则，让人难以理解

• TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。

• 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。

• 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。

• 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。

• 使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0

5.4.2、使用Set集合去除List集合中的重复值

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(2));
        list.add(new Integer(4));
        list.add(new Integer(4));
        List list2 = duplicateList(list);
        for (Object integer : list2) {
            System.out.println(integer);
        }

    }
    public static List duplicateList(List list){
        HashSet set = new HashSet();
        set.addAll(list);
        return new ArrayList(set);
    }

6.Map接口

6.1、Map接口概述

• Map与Collection并列存在。用于保存具有映射关系的数据:key-value
• Map 中的key 和value 都可以是任何引用类型的数据
• Map 中的key 用Set来存放，不允许重复，即同一个Map 对象所对应的类，须重写hashCode()和equals()方法
• 常用String类作为Map的“键”
• key 和value 之间存在单向一对一关系，即通过指定的key 总能找到唯一的、确定的value
• Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是Map 接口使用频率最高的实现类

6.2、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集合

public static void main(String[] args) {
        Map map = new HashMap();
        //map.put(..,..)省略
        map.put(1,"a");
        map.put(2,"b");
        map.put(3,"c");
        System.out.println("map的所有key:");
        Set keys = map.keySet();
        // HashSet
        for(Object key: keys) {
            System.out.println(key+ "->"+ map.get(key));
        }
        System.out.println("map的所有的value：");
        Collection values= map.values();
        Iterator iter= values.iterator();
        while(iter.hasNext()) {
            System.out.println(iter.next());
        }
        System.out.println("map所有的映射关系：");
        // 映射关系的类型是Map.Entry类型，它是Map接口的内部接口
        Set mappings= map.entrySet();
        for(Object mapping: mappings) {
            Map.Entry entry= (Map.Entry) mapping;
            System.out.println("key是："+ entry.getKey() + "，value是："+ entry.getValue());
        }
    }

6.3、Map实现类之一：HashMap

• HashMap是Map 接口使用频率最高的实现类。
• 允许使用null键和null值，与HashSet一样，不保证映射的顺序。
• 所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()
• 所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()
• 一个key-value构成一个entry
• 所有的entry构成的集合是Set:无序的、不可重复的
• HashMap 判断两个key 相等的标准是：两个key 通过equals() 方法返回true，hashCode值也相等。
• HashMap判断两个value相等的标准是：两个value 通过equals() 方法返回true。

6.3.1、HashMap的存储结构

JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)

JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

总结：JDK1.8相较于之前的变化：

1.HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组

2.当首次调用map.put()时，再创建长度为16的数组

3.数组为Node类型，在jdk7中称为Entry类型

4.形成链表结构时，新添加的key-value对在链表的尾部（七上八下）

5.当数组指定索引位置的链表长度>8时，且map中的数组的长度> 64时，此索引位置上的所有key-value对使用红黑树进行存储。

6.4、Map实现类之二：LinkedHashMap

LinkedHashMap是HashMap的子类

• 在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序
• 与LinkedHashSet类似，LinkedHashMap可以维护Map 的迭代顺序：迭代顺序与Key-Value 对的插入顺序一致

6.5、Map实现类之三：TreeMap

• TreeMap存储Key-Value 对时，需要根据key-value 对进行排序。TreeMap可以保证所有的Key-Value 对处于有序状态。
• TreeSet底层使用红黑树结构存储数据
• TreeMap的Key 的排序：
• 自然排序：TreeMap的所有的Key 必须实现Comparable 接口，而且所有的Key 应该是同一个类的对象，否则将会抛出ClasssCastException
• 定制排序：创建TreeMap时，传入一个Comparator 对象，该对象负责对TreeMap中的所有key 进行排序。此时不需要Map 的Key 实现Comparable 接口
• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

6.6、Map实现类之四：Hashtable

• Hashtable是个古老的Map 实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
• Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
• 与HashMap不同，Hashtable不允许使用null 作为key 和value
• 与HashMap一样，Hashtable也不能保证其中Key-Value 对的顺序
• Hashtable判断两个key相等、两个value相等的标准，与HashMap一致

6.7、Map实现类之五：Properties

• Properties 类是Hashtable的子类，该对象用于处理属性文件
• 由于属性文件里的key、value 都是字符串类型，所以Properties 里的key 和value 都是字符串类型
• 存取数据时，建议使用setProperty(String key,Stringvalue)方法和getProperty(String key)方法

public static void main(String[] args) throws IOException {
        Properties pros = new Properties();
        pros.load(new FileInputStream("E:\\烽火数据服务组项目\\SpringBoot项目\\springcloud_springboot_demo\\springboot_jpa\\src\\main\\resources\\jdbc.properties"));
        String user = pros.getProperty("user");
        System.out.println(user);
    }

7、 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 处元素进行交换

7.1、Collections常用方法

查找、替换

• Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
• Object max(Collection，Comparator)：根据Comparator 指定的顺序，返回给定集合中的最大元素
• Object min(Collection)
• Object min(Collection，Comparator)
• int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
• void copy(List dest,List src)：将src中的内容复制到dest中
• boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值

7.2、Collections常用方法：同步控制

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

8、Map接口踩坑

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YZ5ui4vd-1593572915705)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508170703444.png)]

8.1、不是所有的 Map 都能包含 null

常用 Map 子类集合对于 null 存储情况：

上面的实现类约束，都太不一样，有点不好记忆。其实只要我们在加入元素之前，主动去做空指针判断，不要在 Map 中存入 null，就可以从容避免上面问题。

8.2、自定义对象为key

尽量避免使用自定义对象作为 Map 集合 key，如果一定要使用，记得重写 hashCode 与 equals 方法。另外还要保证这是一个不可变对象，即对象创建之后，无法再修改里面字段值。

8.3、错用 ConcurrentHashMap 导致线程不安全

错误使用场景案例

public static void main(String[] args) throws IOException, InterruptedException {
        ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
        concurrentHashMap.put("a",1);
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 1000; i++) {
            executorService.execute(()->{
                //第一步：值加1
                int value = concurrentHashMap.get("a") + 1;
                //第二步：重新设值
                concurrentHashMap.put("a",value);
            });
        }
        TimeUnit.SECONDS.sleep(5l);
        System.out.println("---------"+concurrentHashMap.get("a"));
        executorService.shutdown();
    }

上面示例代码，我们原本期望输出 1001，但是运行几次，得到结果都是小于 1001。

深入分析这个问题原因，实际上是因为第一步与第二步是一个组合逻辑，不是一个原子操作。

ConcurrentHashMap 只能保证这两步单的操作是个原子操作，线程安全。但是并不能保证两个组合逻辑线程安全，很有可能 A 线程刚通过 get 方法取到值，还未来得及加 1，线程发生了切换，B 线程也进来取到同样的值。

这个问题同样也发生在其他线程安全的容器，比如 Vector等。

上面的问题解决办法也很简单，加锁就可以解决，不过这样就会使性能大打折扣，所以不太推荐。

我们可以使用 AtomicInteger 解决以上的问题。

public static void main(String[] args) throws IOException, InterruptedException {
        ConcurrentHashMap<String, AtomicInteger> concurrentHashMap = new ConcurrentHashMap<>();
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 1000; i++) {
            executorService.execute(()->{
                //如果key不存在，新建AtomicInteger对象，否则内部AtomicInteger递增
                concurrentHashMap.computeIfAbsent("a",s ->new AtomicInteger(1)).incrementAndGet();
            });
        }
        TimeUnit.SECONDS.sleep(5l);
        System.out.println("---------"+concurrentHashMap.get("a"));
        executorService.shutdown();
    }

Map 接口除了支持增删改查功能以外，还有三个特有的方法，能返回所有 key，返回所有的 value，返回所有 kv 键值对。

// 返回 key 的 set 视图
Set<K> keySet()；
// 返回所有 value   Collection 视图
Collection<V> values();
// 返回 key-value 的 set 视图
Set<Map.Entry<K, V>> entrySet();

这三个方法创建返回新集合，底层其实都依赖的原有 Map 中数据，所以一旦 Map 中元素变动，就会同步影响返回的集合。

另外这三个方法返回新集合，是不支持的新增以及修改操作的，但是却支持 clear、remove 等操作。

public static void main(String[] args) throws IOException, InterruptedException {
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("a",1);
        hashMap.put("b",2);
        hashMap.put("c",3);
        Collection<Integer> values = hashMap.values();
        hashMap.put("d",4);
        Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> entry = iterator.next();
            System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
        }
        Iterator<Integer> iterator1 = values.iterator();
        while (iterator1.hasNext()){
            Integer next = iterator1.next();
            System.out.println("value:"+next);
        }
    }

9、List接口踩坑

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QfRNXUMT-1593572915707)(C:\Users\23746\AppData\Roaming\Typora\typora-user-images\image-20200508203306744.png)]

9.1、Array数组转成List集合注意点

数组转List集合，Arrays.asList，不支持增删元素，共享原始数组，修改原始数据，影响新集合，修改新集合，又会影响数组元素

public static void main(String[] args) throws IOException, InterruptedException {
        String[] array={"a","b","c"};
        List<String> list = Arrays.asList(array);
//        list.add("d");//数组转成List不支持新增，java.lang.UnsupportedOperationException
        array[0]="aaa";
        list.set(1,"bbb");
        System.out.println(Arrays.toString(array));
        for (String s : list) {
            System.out.println(s);
        }
    }

//运行结果
[aaa, bbb, c]
aaa
bbb
c

知道了实际原因，修复的办法也很简单，套娃一层 ArrayList 呗！

List<String> list = new ArrayList<>(Arrays.asList(arrays));

不过这么写感觉十分繁琐，推荐使用 Guava Lists 提供的方法。

List<String> list = Lists.newArrayList(arrays);

通过上面两种方式，我们将新的 List 集合与原始数组解耦，不再互相影响，同时由于此时还是真正的 ArrayList，不用担心 add/remove报错了。

除了 Arrays#asList产生新集合与原始数组互相影响之外，JDK 另一个方法List#subList 生成新集合也会与原始 List 互相影响。

我们来看一个例子：

public static void main(String[] args) throws IOException, InterruptedException {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        List<Integer> subList = integers.subList(0, 2);
        integers.set(0,100);
        subList.set(1,200);
        System.out.println("list:"+integers);
        System.out.println("subList:"+subList);
    }
//运行结果
list:[100, 200, 3]
subList:[100, 200]

这里修复的办法也很简单，跟上面一样，也来个套娃呗，加一层 ArrayList 。

为了防止 List 集合被误操作，我们可以使用 Collections#unmodifiableList 生成一个不可变（immutable）集合，进行防御性编程。

这个不可变集合只能被读取，不能做任何修改，包括增加，删除，修改，从而保护不可变集合的安全。

public static void main(String[] args) throws IOException, InterruptedException {
        ArrayList<String> arrayList = Lists.newArrayList(Arrays.asList("a", "b", "c"));
        List<String> list = Collections.unmodifiableList(arrayList);
//        list.add("d");//抛异常java.lang.UnsupportedOperationException
        arrayList.add("d");//修改原集合，从原集合生成的不可变集合也跟着改动
        System.out.println(list);
    }

可以看到这跟上面 SubList 其实是同一个问题，新集合底层实际使用了原始 List。

由于不可变集合所有修改操作都会报错，所以不可变集合不会产生任何改动，所以并不影响的原始集合。但是防过来，却不行，原始 List 随时都有可能被改动，从而影响不可变集合。

可以使用如下两种方式防止上卖弄的情况。

使用 JDK9 List#of 方法。

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
List<String> unmodifiableList = List.of(list.toArray(new String[]{}));

使用 Guava immutable list

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
List<String> unmodifiableList = ImmutableList.copyOf(list);

相比而言 Guava 方式比较清爽，使用也比较简单，推荐使用 Guava 这种方式生成不可变集合。

9.2、foreach 增加/删除元素大坑

先来看一段代码：

String[] arrays = {"1", "2", "3"};
List<String> list = new ArrayList<>(Arrays.asList(arrays));
for (String str : list) {
    if (str.equals("1")) {
        list.remove(str);
    }
}

上面的代码我们使用 foreach 方式遍历 List 集合，如果符合条件，将会从集合中删除改元素。

这个程序编译正常，但是运行时，程序将会发生异常，日志如下：

java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:939)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:893)

可以看到程序最终错误是由 ArrayList$Itr.next 处的代码抛出，但是代码中我们并没有调用该方法，为什么会这样?

实际是因为 foreach 这种方式实际上 Java 给我们提供的一种语法糖，编译之后将会变为另一种方式。

我们将上面的代码产生 class 文件反编来看下最后代码长的啥样。

可以看到 foreach 这种方式实际就是 Iterator 迭代器实现方式，这就是为什么foreach 被遍历的类需要实现 Iterator接口的原因。

修复的办法有两种：

使用 Iterator#remove 删除元素

public static void main(String[] args) throws IOException, InterruptedException {
        String[] arrays = {"1", "2", "3"};
        List<String> list = new ArrayList<>(Arrays.asList(arrays));
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            if(next.equals("1")){
                iterator.remove();
            }
        }
        System.out.println(list);
    }

JDK1.8 List#removeIf

public static void main(String[] args) throws IOException, InterruptedException {
        String[] arrays = {"1", "2", "3"};
        List<String> list = new ArrayList<>(Arrays.asList(arrays));
        list.removeIf(s -> s.equals("1"));
        System.out.println(list);
    }

9.3、总结

第一，我们不要先入为主，想当然就认为 Arrays.asList 和 List.subList 就是一个普通，独立的 ArrayList。

如果没办法，使用了 Arrays.asList 和 List.subList ，返回给其他方法的时候，一定要记得再套娃一层真正的 java.util.ArrayList。

第二 JDK 的提供的不可变集合实际非常笨重，并且低效，还不安全，所以推荐使用 Guava 不可变集合代替。

最后，切记，不要随便在 foreach增加/删除元素。