Java9集合类新增功能

前言

Java8及Java9在集合Collection类中新增了一些很好用的新方法，能方便程序员更便捷的处理集合数据，本文对其中的一些方法进行总结

一. List

1.创建

        // 传统方法
        List<String> list1 = new ArrayList<>();
        list1.add("item1");
        list1.add("item2");

        //方法2-子类
        List<String> list2 = new ArrayList<String>() {
            {
                add("item1");
                add("item2");
            }
        };
        
        //方法3：Arrays.asList()罗列元素，不可增删，但可更改
        List<String> list3 = Arrays.asList("item1", "item2");
        
        //方法4：Java9以上新增，不可增删改
        List.of("item1", "item2");

2.更新

        //replaceAll()对元素进行批量替换，本例为在原每个元素String后面增加三个星号
        list1.replaceAll(item -> item + "***");            //更新原List，对象类型不变，所以入参应为Operator：T->T
        System.out.println(list1);

3.判断条件式移除

        //removeIf() 满足条件则移除
        list1.removeIf(item -> item.contains("2"));         //过滤掉含有“2”的元素，list发生改变
        System.out.println(list1);

4. 遍历

        //foreach()循环元素每个对象，放入Customer方法中消费
        list1.forEach(System.out::println);

二. Set

        //Set工厂, Java9提供
        Set<String> set = Set.of("item1", "item2");

三. Map

1.创建

        //Map工厂，Java9提供，以key、value的格式依次设置参数
        Map<String, String> map1 = Map.of("key1", "value1", "key2", "value2");

        //以Map.entry()格式来创建key、value
        Map<String, Integer> map2 = Map.ofEntries(
                Map.entry("key1", 1),
                Map.entry("key2", 2),
                Map.entry("key3", 3));

2. 替换更新replace(）/replaceAll()

        //replace()条件替换
        String key1 = "key1";
        boolean replace = map.replace(key1, 1, 3);
        System.out.println("key5执行computeIfPresent后，结果值:" + map.get(key1));     //执行结果：5，上面的replace没有生效
        

        //replaceAll()全量替换
        map.replaceAll((key, value)-> value + 2);
        System.out.println("key5执行computeIfPresent后，结果值:" + map);           //执行结果：value都增加了2

3.判断条件移除remove()

        /*  remove(key, value)： 当map中对应的key->value值时，才会被remove；会结合value一起进行判断 */
        String key2 = "key2";
        boolean remove = map.remove(key2, 2);       //此时key2已经被改为4，因此remove不生效
        System.out.println("移除结果：" + remove);   //执行结果：false

        remove = map.remove(key2, 4);
        System.out.println("移除结果：" + remove);   //此次执行结果：true

4. 遍历forEach()

        //forEach() 以Entry方式来遍历
        map.forEach((key, value) -> {
            System.out.println("key=" + key + ", value=" + value);
        });

5. 排序

        /*用流的方式进行排序*/
        //sorted() 按某种条件排序
        Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();
        //按照value排序，类似的还有Map.Entry.comparingByKey
        Stream<Map.Entry<String, Integer>> stream1 = stream.sorted(Map.Entry.comparingByValue());
        System.out.println("Map.Entry.comparingByValue 进行排序:");
        stream1.forEachOrdered(System.out::println);

6. 带默认值获取getOrDefault()

       /*  从map中取值，若取不到则返回默认值 */
        String key4 = "key4";
        Integer value4 = map.getOrDefault(key4, 14);     //取key，如果取不到则返回第二个参数，默认值
        System.out.println("getOrDefault执行后，得到的结果:" + value4);      //执行结果：14

7. computer计算

    /**
     * 先定义一个生成value的方法
     */
    public int createValue(String key) {
        String substring = key.substring(3);
        System.out.println("== createValue方法创建value值，key=" + key);
        return Integer.valueOf(substring);
    }


	public void computerTest() {

        /*  computeIfAbsent()： 指定的键没有对应的值，则使用该键计算新的值， 并添加到Map中 */
        Integer value4 = map.computeIfAbsent(key4, this::createValue);    //执行此步骤可以看到value为createValue()执行了，有内部日志打印出来
        System.out.println("computeIfAbsent执行后，结果值:" + value4);     //可以看到value4的结果为：4
        System.out.println("map现在可以取值：" + map.get(key4));           //直接查询map也能得到结果：4

        // 如果指定的键在map中已有，那么直接取值，不会再调用方法参数创建新值。
        Integer value4Again = map.computeIfAbsent(key4, this::createValue);    //执行此步骤，没有createValue()方法内部日志打印出来
        System.out.println("再次执行computeIfAbsent，结果值:" + value4Again);  //执行结果：4


        /*  computeIfPresent()： 指定的键有对应的值，则使用该键计算新的值， 并添加到Map中 */
        //定义的BiFunction，可以把原数据的key-value都传入，计算新value
        BiFunction<String, Integer, Integer> add10Function = (key, value) -> value + 5;
        Integer computeIfPresent2 = map.computeIfPresent(key4, add10Function);      //因为key4已有值，所以会被重算
        System.out.println("Key4执行computeIfPresent后，结果值:" + computeIfPresent2);     //执行结果：9

        //若不存在，则不执行，返回null；因为key5在map中没有对应value，所以没有计算
        String key5 = "key5";
        Integer value5 = map.computeIfPresent(key5, add10Function);            
        System.out.println("key5执行computeIfPresent后，结果值:" + value5);     //执行结果：null
   }

8. 合并

        /*merge() 合并两个map，会根据key以及给出的方法做整合*/
       Map<String, Integer> map = new HashMap<>(Map.ofEntries(
                Map.entry("key1", 5),
                Map.entry("key2", 2),
                Map.entry("key3", 3)));
        Map<String, Integer> map2 = new HashMap<>(Map.ofEntries(
                Map.entry("key1", 1),
                Map.entry("key2", 2),
                Map.entry("key5", 3)));
        //将map2合并入map中
        map2.forEach((k, v) -> map.merge(k, v, (v1, v2) -> v1 + v2));
        System.out.println(map);           //{key1=6, key2=4, key5=3, key3=3} ,以key为基准，做了合并