Java学习笔记（20）

可变参数

输入的参数数量不确定

底层就是把输入的参数放进一个数组里

1. 只能写一个可变参数
2. 如果还有其他形参，可变参数要放在最后写

可变参数在底层就是一个数组

Collections

Addall shuffle

练习

package exercise;

import java.util.ArrayList;
import java.util.Collections;

public class exercise1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "11", "22", "#3", "33", "44", "55");

        for (int i = 0; i < 5; i++) {
            Collections.shuffle(list);
            System.out.println("第" + i + "轮：");
            System.out.println(list);
        }
    }
}

package exercise;

import java.util.*;
import java.util.function.BiConsumer;

public class exercise2 {
    public static void main(String[] args) {
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        ArrayList<String> city1 = new ArrayList<>();
        ArrayList<String> city2 = new ArrayList<>();
        ArrayList<String> city3 = new ArrayList<>();
        Collections.addAll(city1, "南京市", "扬州市", "苏州市", "无锡市", "常州市");
        Collections.addAll(city2, "武汉市", "孝感市", "十堰市", "宜昌市", "鄂州市");
        Collections.addAll(city3, "石家庄市", "唐山市", "邢台市", "保定市", "张家口市");
        hm.put("江苏省", city1);
        hm.put("湖北省", city2);
        hm.put("河北省", city3);

        hm.forEach(new BiConsumer<String, ArrayList<String>>() {
            @Override
            public void accept(String s, ArrayList<String> strings) {
                StringJoiner sj = new StringJoiner(",","","");
                for (String city : strings) {
                    sj.add(city);
                }
                System.out.println(s + " = " + sj);
            }
        });
    }

}

创建不可变集合

不可以被修改的集合

不能改长度，改内容

只能查询

List.of

Set.of里面如果有重复的元素，就会报错

Map.of

参数是有上限的，最多传10个
为什么有上限？

因为map.of参数里传的是一个键，一个值，一个键一个值这样，如果想要写成可变参数，如下面，第一个参数传键的可变参数，第二个传值的可变参数是不行的。因为参数里只允许有一个可变参数，并且传入参数有多个的话，可变参数要放在最后。

所以没法这样写

为了可以传多个键值对，就可以使用map.ofEntries，传递entry对象的可变参数

传多个Entry对象，就可以把多个entry对象放在数组array里

那怎么放？

首先从hashmap中获取所有entry对象的集合set（entryset（）方法）

再新建一个entry的数组用于存放

调用entry对象集合的toArray方法，传入参数就是上面建立的entry数组，返回的就是一个装满entry对象的数组

就可以把这个数组放到map.ofEntries的传入参数里，就得到一个不可以修改的map

嫌麻烦？

一行代码

记不住？

直接用

Copyof  JDK10才出现

如果传入的是不可变的map，直接返回

如果不是，则给你转成一个不可变的map

Stream流

单列集合

Arraylist是collection的实现类，继承了里面的stream方法

双列集合

数组

用的是Arrays里面的steam方法

对零散数据使用stream的静态方法Stream.of

要求：数据得是相同类型的

Stream.of在底层其实使用的是Arrays.stream()

注意，如果用stream.of如果传递的是引用数据类型的数组，则可以用

传递基本数据类型的数组，会把数组当做一个元素，返回的是数组的地址值

用包装类就可以实现了

Stream流的中间方法

Filter limit skip distinct concat map

Stream流只能用一次

不会改变原来的集合内容

Distinct 底层是通过new一个hashset来去重的；如果元素是自定义对象，要重写hashcode和equals

.map方法

Lambda表达

Stream终结方法

注意：tolist()不是终结方法

Toarray（）是终结方法

收集方法

.collect

Tolist：会把数据放到arraylist中

Toset：会把数据放到hashset中

注意：收集到map里的数据，键不能重复，否则报错

应该收集到一个hashmap中

Lambda写法

ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> list1 = list.stream().filter(i -> i % 2 == 1).toList();
        System.out.println(list1);//[1, 3, 5, 7, 9]

ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "zhangsan, 23", "lisi, 24", "wangwu, 25");


        Map<String, Integer> map = list2.stream().filter(s -> Integer.parseInt(s.split(", ")[1]) >= 24)
                .collect(Collectors.toMap(s -> s.split(", ")[0], i -> Integer.parseInt(i.split(", ")[1])));
        System.out.println(map);//{lisi=24, wangwu=25}

 //1.创建两个ArrayList集合
        ArrayList<String> manList = new ArrayList<>();
        ArrayList<String> womenList = new ArrayList<>();
        //2.添加数据
        Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
        Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");

        Stream<String> stream1 = manList.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);
        Stream<String> stream2 = womenList.stream().filter(s -> s.startsWith("杨")).skip(1);

        List<Actor> list3 = Stream.concat(stream1, stream2)
                .map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
                .toList();
        System.out.println(list3);//[Actor{name = 蔡坤坤, age = 24}, Actor{name = 叶齁咸, age = 23}, Actor{name = 杨小幂, age = 33}]

方法引用

方法引用的分类

引用静态方法

Integer::parseInt

引用成员方法

用this和super引用需要注意：如果当前类是静态static的，则没得用，因为static方法里是没有this的

如果要用，只能先创建本类的对象，再去调用本类的方法

引用构造方法

自己在对象类重写一个构造方法和抽象方法一致，但不需要管返回值，因为构造方法生成的对象和抽象方法的返回值相同就行。

其他调用方式

使用java类名引用成员方法

有局限性

引用数组的构造方法

//1.创建两个ArrayList集合
        ArrayList<String> manList = new ArrayList<>();
        //2.添加数据
        Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");

        Actor[] array = manList.stream().map(Actor::new).toArray(Actor[]::new);
        System.out.println(Arrays.toString(array));
        //[Actor{name = 蔡坤坤, age = 24}, Actor{name = 叶齁咸, age = 23},
        // Actor{name = 刘不甜, age = 22}, Actor{name = 吴签, age = 24},
        // Actor{name = 谷嘉, age = 30}, Actor{name = 肖梁梁, age = 27}]

String[] array1 = Arrays.stream(array).map(Actor::getName).toArray(String[]::new);
        System.out.println(Arrays.toString(array1));
        //[蔡坤坤, 叶齁咸, 刘不甜, 吴签, 谷嘉, 肖梁梁]

manList.stream().map(new exercise3()::method2).toList().forEach(System.out::println);
        //蔡坤坤-24
        //叶齁咸-23
        //刘不甜-22
        //吴签-24
        //谷嘉-30
        //肖梁梁-27

public String method2(String s) {
        return s.split(",")[0] + "-" + s.split(",")[1];
    }

String[] array2 = Arrays.stream(array).map(Actor::method2).toArray(String[]::new);
System.out.println(Arrays.toString(array2));
//[蔡坤坤-24, 叶齁咸-23, 刘不甜-22, 吴签-24, 谷嘉-30, 肖梁梁-27]

public static String method2(Actor a) {
        return a.getName() + "-" + a.getAge();
    }