Java笔记_16(不可变集合、Stream流、方法引用)

一、创建不可变集合

不可变集合：不可以被修改的集合

1.1、创建不可变集合的应用场景

• 如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。
• 当集合对象被不可信的库调用时，不可变形式是安全的。

简单理解:不想让别人修改集合中的内容

1.2、创建不可变集合的书写格式

在List、Set、Map接口中，都存在静态的of方法，可以获取一个不可变的集合。

方法名称	说明
static <E> List<E> of(E…elements)	创建一个具有指定元素的List集合对象
static <E> Set<E> of(E…elements)	创建一个具有指定元素的Set集合对象
static <K , V> Map<K, V> of(E…elements)	创建一个具有指定元素的Map集合对象

注意:这个集合不能添加，不能删除，不能修改。

Set：

• 当我们要获取一个不可变的Set集合时，里面的参数一定要保证唯一性

Map：

1. 键是不能重复的
2. Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对
3. 如果我们要传递多个键值对对象，数量大于10个，在Map接口中还有一个方法

package ImmutableDome;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;

public class Dome1 {
    public static void main(String[] args) {

        List<String> list = List.of("小王","小里","小五","小陈","小黄","小路","小与");
        System.out.print(list.get(0)+" ");
        System.out.print(list.get(1)+" ");
        System.out.print(list.get(2)+" ");
        System.out.print(list.get(3)+" ");
        System.out.print(list.get(4)+" ");
        System.out.print(list.get(5)+" ");
        System.out.print(list.get(6)+" ");
        System.out.println();
        System.out.println("_-----------------------------------------_");


        for (String s : list) {
            System.out.print (s+" ");
        }


        System.out.println();
        System.out.println("_-----------------------------------------_");


        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.print (next+" ");
        }
        System.out.println();
        System.out.println("_-----------------------------------------_");

        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print (s+" ");
            }
        });
        System.out.println();
        System.out.println("_-----------------------------------------_");

        Map<String, String> map = Map.of("小王", "南京", "小李", "广州", "小杨", "扬州", "小赵", "北京", "小张", "苏州",
                "小飞", "上海", "小卢", "周口", "小黄", "资阳", "小贾", "太原");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.print(entry+" ");
        }
    }
}

• 使Map集合生成不可变的集合通过Map.copyOf()方法操作(JDK10之后可以用)
• 如果JDK版本低于10需要通过一下代码实现

HashMap<String,String> hm = new HashMap<>();
        hm.put("小王", "南京");
        hm.put("小李", "广州");
        hm.put("小杨", "扬州");
        hm.put("小飞", "上海");
        hm.put("小卢", "周口");

        Set<Map.Entry<String, String>> entries1 = hm.entrySet();
        //把entries1变成一个数组
        Map.Entry[] arr1 = new Map.Entry[0];
        //toArray方法在底层会比较集合的长度跟数组的长度两者的大小
        //如果集合的长度〉数组的长度﹔数据在数组中放不下，此时会根据实际数据的个数，重新创建数组
        // 如果集合的长度〈=数组的长度:数据在数组中放的下，此时不会创建新的数组，而是直接用
        Map.Entry[] arr2 = entries1.toArray(arr1);
        //不可变的map集合
       Map map1 = Map.ofEntries(arr2);//此时就是一个不可变的集合
        
        //链式方法
        Map map2 =  Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));

二、Stream流

2.1、体验Stream流

package StreamDome;

import java.util.ArrayList;

public class Dome1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("张三");
        list.add("张良");
        list.add("张小");
        list.add("李小");
        list.add("往小");
        list.add("黄小");

        list.stream().filter(name -> name.startsWith("张")).filter(name ->name.length() == 3).forEach(name-> System.out.println(name));


        ArrayList<String> list1 = new ArrayList<>();
        for (String name : list) {
            if(name.startsWith("张")){
                list1.add(name);
            }
        }
        System.out.println(list1);

        ArrayList<String> list2 = new ArrayList<>();
        for (String name : list1) {
            if (name.length()==3){
                list2.add(name);
            }
        }
        System.out.println(list2);
    }
}

2.2、Stream流的思想和获取Stream流

Stream流的作用：
结合了Lambda表达式，简化集合、数组的操作

Stream流的使用步骤:

1. 先得到一条Stream流（流水线)，并把数据放上去
2. 利用Stream流中的API进行各种操作
   • 过滤、转换（中间方法）->方法结束之后还能调用其他方法
   • 统计、打印（终结方法）->最后一步，方法调用完之后不能再调用其他方法

• 先得到一条Stream流（流水线)，并把数据放上去

获取方法	方法名	说明
单列集合	default Stream<E> stream()	Collection中的默认方法
双列集合	无	无法直接使用stream流
数组	public static <T> Stream<T> stream(T[ ]array)	Arrays工具类中的静态方法
一堆零散数据	public static<T> Stream<T> of(T… values)	Stream接口中的静态方法

在对一对零散数据进行stream流时需要注意：

• stream接口中静态方法of的细节
• 方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组
• 但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当做一个元素，放到Stream当中。

package StreamDome;

import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;

public class Dome2 {
    public static void main(String[] args) {
        //单列集合使用stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e","f","g","h","i","j","k");
        //使用stream流直接打印集合
        list.stream().forEach(s -> System.out.println(s));

        //双列集合需要通过转化成单列集合再进行stream流
        Map<String,Integer> hm = new HashMap<>();
        hm.put("asd",123);
        hm.put("qwe",222);
        hm.put("zxc",333);
        hm.put("fgh",444);
        hm.put("rty",555);
        //获取stream流
        //需要转化成单列集合
        //第一种
        hm.keySet().stream().forEach(s -> System.out.println(s));
        //第二种
        hm.entrySet().stream().forEach((stringIntegerEntry)->System.out.println(stringIntegerEntry));

        //数组使用stream流
        int[] arr1 = {1,2,3,4,5,6};
        String[] arr2 = {"a","c","s","d","f"};

        Arrays.stream(arr1).forEach(s-> System.out.println(s));
        Arrays.stream(arr2).forEach(s-> System.out.println(s));

        //零散数据调用stream流（前提是同种数据类型）
        Stream.of(1,2,3,4,5,6).forEach(s-> System.out.println(s));
        Stream.of("a","c","s","d","f").forEach(s-> System.out.println(s));
    }
}

2.3、Stream流的中间方法

名称	说明
Stream<T> filter(Predicate<? super T> predicate)	过滤
Stream<T> limit(long maxSize)	获取前几个元素
Stream<T> skip(long n)	跳过前几个元素
Stream<T> distinct()	元素去重，依赖(hashCode和equals方法)
static<T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream<R> map(Function<T ,R> mapper)	转换流中的数据类型

注意一：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意二：修改Stream流中的数据，不会影响原来集合或者数组中的数据
注意三：使用concat方法时要注意两个集合的类型，如果两者的类型不同则会转换成他们共同的父类

package StreamDome;

import java.nio.file.WatchService;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
import java.util.stream.Stream;

public class Dome3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();

        Collections.addAll(list,"张三丰","王五六","王二麻","张三","王二","张良","王五六","张阿","王二麻","王麻");
        Collections.addAll(list2,"123","345","666","444","888","999");
        list.stream().filter(s->s.startsWith("张")).forEach(s -> System.out.println(s));
        //提高代码阅读性
        list.stream().filter(s -> s.startsWith("王"))
                .filter(s->s.length()==3)
                .forEach(s -> System.out.println(s));
        System.out.println("===============================================");
        //获取前三个元素
        list.stream().limit(3).forEach(s -> System.out.println(s));
        //跳过前三个元素
        list.stream().skip(3).forEach(s -> System.out.println(s));

        System.out.println("===============================================");
        //元素去重
        //底层使用的时equal和hashCode方法
        list.stream().distinct().forEach(s -> System.out.println(s));

        //合并a，b两个流
        Stream.concat(list.stream(),list2.stream()).forEach(s -> System.out.println(s));

        //stream类型转换
        ArrayList<String> list3 = new ArrayList<>();
        Collections.addAll(list3,"小王-12","小李-14","小张-15","小赵-16","小黄-17");

        list3.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s){
                String[] arr = s.split("-");
                String ages = arr[1];
                int age = Integer.parseInt(ages);
                return age;
            }
        }).forEach(s-> System.out.println(s));

        list3.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println(s));
    }
}

2.4、Stream流的终结方法

名称	说明
void forEach(Consumer action)	遍历
long count()	统计
toArray()	收集流中的数据，放到数组中
collect(Collector collector)	收集流中的数据，放到集合中

• IntFunction的泛型：具体类型的数组
• apply的形参：流中数据的个数，要跟数组的长度保持一致
• apply的返回值，集体类型的数组
• 方法体：就是创建数组

• toArray方法的参数的作用:负责创建一个指定类型的数组
• toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
• toArray方法的返回值:是一个装着流里面所有数据的数组

package StreamDome;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;

public class Dome4 {
    public static void main(String[] args) {
        ArrayList<String> list =new ArrayList<>();
        Collections.addAll(list,"张三丰","王五六","王二麻","张三","王二","张良","王五六","张阿","王二麻","王麻");

        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        System.out.println(list.stream().count());

        Object[] objects = list.stream().toArray();
        System.out.println(Arrays.toString(objects));

        //IntFunction的泛型：具体类型的数组
        //apply的形参：流中数据的个数，要跟数组的长度保持一致
        //apply的返回值，集体类型的数组
        //方法体：就是创建数组

        //toArray方法的参数的作用:负责创建一个指定类型的数组
        //toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
        //toArray方法的返回值:是一个装着流里面所有数据的数组

        String[] strings = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        
        list.stream().toArray(value -> new String[value]);

    }
}

2.5、收集方法collect

package StreamDome;

import java.sql.SQLOutput;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Dome5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"小路-女-18","小王-女-18","小李-男-18",
                "小张-男-18","小宇-女-18","小黄-男-18","小飞-男-18");
        //收集成list集合
        List<String> list1 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        System.out.println(list1);
        //收集成set集合
        //需要设定键和值的规则，并且键不能重复
        Set<String> set = list.stream().filter(s -> "女".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        System.out.println(set);

        Map<String, Integer> collect = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                /*
        toMap :参数一表示键的生成规则
               参数二表示值的生成规则
        参数一:
               Function泛型一:表示流中每一个数据的类型
                        泛型二:表示Map集合中键的数据类型

               方法apply形参:依次表示流里面的每一个数据
                        方法体:生成键的代码
                        返回值:已经生成的键

        参数二:
               Function泛型一:表示流中每一个数据的类型
                        泛型二:表示Map集合中值的数据类型
                方法apply形参:依次表示流里面的每一个数据
                        方法体:生成值的代码
                        返回值:已经生成的值
**/
                .collect(Collectors.toMap(new Function<String, String>() {//第一个匿名内部类，编写键的规则
                                              @Override
                                              public String apply(String s) {
                                                  return s.split("-")[0];
                                              }
                                          }, new Function<String, Integer>() {//第二个匿名内部类，编写值的规则
                                              @Override
                                              public Integer apply(String s) {
                                                  return Integer.parseInt(s.split("-")[2]);
                                              }
                                          }));
        System.out.println(collect);
        //写成lambda
        Map<String, Integer> collect1 = list.stream().filter(s -> "女".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],
                        s -> Integer.parseInt(s.split("-")[2])));
        System.out.println(collect1);
    }
}

2.6、练习-数字过滤

package StreamDome;

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

public class Test1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);

        ArrayList<Integer> list1 = new ArrayList<>();
        list.stream().filter(s->s%2==0).forEach(s-> list1.add(s));
        System.out.println(list1);

    }
}

2.7、练习-字符串过滤并收集

package StreamDome;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();

        Collections.addAll(list1,"zhangsan,23","lisi,24","wangwu,25");

        Map<String, Integer> collect = list1.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
                .collect(Collectors.toMap((String s)->s.split(",")[0], s-> Integer.parseInt(s.split(",")[1])));
        System.out.println(collect);
    }
}

2.8、练习-数据操作

package StreamDome;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test3 {
    public static void main(String[] args) {
        ArrayList<String> manlist = new ArrayList<>();
        ArrayList<String> womanlist = new ArrayList<>();

        ArrayList<Actor> actorArrayList = new ArrayList<>();
        Collections.addAll(manlist,"张三,23","李四,24","王五,25","张如龙,23","李太白,24","王大卫,25");
        Collections.addAll(womanlist,"张娜,23","李琳,24","杨云,25","杨小娜,23","李琳霖,24","杨昭云,25");

        manlist.stream()
                .filter(s -> s.split(",")[0].length()==3)
                .limit(2)
                .forEach(s ->  actorArrayList.add(new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1]))));
        womanlist.stream()
                .filter(s->s.split(",")[0].startsWith("杨"))
                .skip(1)
                .forEach(s ->  actorArrayList.add(new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1]))));

        /*Stream<String> stream1 = manlist.stream();
        Stream<String> stream2 = womanlist.stream();

        List<Actor> list = Stream.concat(stream1,stream2)
                .map(s->new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
                .collect(Collectors.toList());

        System.out.println(list);*/
        System.out.println(actorArrayList);
    }
}

三、方法引用

3.1、方法引用概述

把已经有的方法拿过来用，当做函数式接口中抽象方法的方法体

可以使用方法引用的条件：

1. 引用处必须是函数式接口
2. 被引用的方法必须已经存在
3. 被引用方法的形参和返回值需要跟抽象方法保持一致
4. 被引用方法的功能需要满足当前的需求

::方法引用符：方法引用中独特的符号

package Method_reference;

import java.util.Arrays;
import java.util.Comparator;

public class Dome1 {
    public static void main(String[] args) {
        Integer[] arr = {2,6,1,5,2,8,9,3};

        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        //System.out.println(Arrays.toString(arr));

        Arrays.sort(arr,(Integer o1, Integer o2) -> o2-o1);
        //System.out.println(Arrays.toString(arr));

        Arrays.sort(arr,Dome1::subnumber);
        System.out.println(Arrays.toString(arr));
    }
    public static int subnumber(int num1,int num2){
        return num2-num1;
    }
}

3.2、引用静态方法

格式：类名::静态方法

package Method_reference;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Dome2 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();

        Collections.addAll(list1,"1","2","3","4","5","6");
        //将list1中的成员变成int型并且添加到list2中
        //函数式接口写法
        list1.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                list2.add(i);
                return i;
            }
        }).forEach(s-> System.out.println(s));
        System.out.println(list2);

        //静态方法引用式写法
        list1.stream().map(Integer::parseInt).forEach(s-> list2.add(s));
        System.out.println(list2);
    }
}

3.3、引用成员方法

格式：对象::成员方法

1. 其他类：其他类对象:方法名
2. 本类：this::方法名
3. 父类：super::方法名

package Method_reference;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;

public class Dome3 {
    public static void main(String[] args) {

        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三丰","张三","张如龙","杨三丰","张锋","张阳");
        //原先的方法
        //过滤出以张开头的并且长度为3的姓名
        list1.stream().filter(s -> s.startsWith("张")&&s.length()==3).forEach(s-> System.out.println(s));
        //引用成员方法
        list1.stream().filter(new StringOperation()::test).forEach(s -> System.out.println(s));
    }
}
package Method_reference;

public class StringOperation {
    public boolean test(String s) {
        return s.startsWith("张")&&s.length()==3;
    }
}

3.4、引用本类或父类的成员方法

package Method_reference;

public class Dome4_App {
    public static void main(String[] args) {
        new Dome5();
    }
}

package Method_reference;

import javax.swing.*;
import java.awt.event.ActionEvent;

//不需要引用点击事件接口
public class Dome5 extends MyJFram {
	//因为需要使用点击事件，把按钮写到成员位置
    JButton jButton = new JButton("点击一下");

    public Dome5(){
        initJFrame();

        initView();
    }
    public void initJFrame(){
		//设置页面
        this.setBounds(500,300,400,600);
        this.setAlwaysOnTop(true);
        this.setDefaultCloseOperation(3);
        this.setLayout(null);
        this.setVisible(true);
    }
    public void initView(){
    	//设置按钮大小位置
        jButton.setBounds(150,200,100,50);
        this.getContentPane().add(jButton);
        //在此处把参数值进行修改
        //this表示引用本类方法
        jButton.addActionListener(this::dianji1);
        //super表示引用父类方法
        jButton.addActionListener(super::dianji2);
    }

    //重新写方法给去除
    public void dianji1(ActionEvent e) {
            System.out.println("被点击了一下--1");
    }
}
package Method_reference;

import javax.swing.*;
import java.awt.event.ActionEvent;

public class MyJFram extends JFrame {
    public void dianji2(ActionEvent e) {
        System.out.println("被点击了一下--2");
    }
}

3.5、引用构造方法

格式：类名: :new
范例： Student: : new

package Method_reference;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Dome6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三,12","李四,12","王五,12");
        //原先的方法使集合里面的数据转换为对象类型的
        list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String[] split = s.split(",");
                String name = split[0];
                int age = Integer.parseInt(split[1]);
                return new Student(name,age);
            }
        }).forEach(s-> System.out.println(s));

        //使用引用构造方法map集合
        list.stream().map(Student::new).forEach(s-> System.out.println(s));

    }
}
package Method_reference;

public class Student {
    private String name;
    private int age;

    public Student() {
    }
	//重写一个带一个参数的构造函数
    public Student(String str){
        String[] split = str.split(",");
        this.name = split[0];
        this.age = Integer.parseInt(split[1]);
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

3.6、类名引用成员方法

格式：类名::成员方法
范例：string : : substring

类名引用成员方法引用的规则：

1. 需要有函数式接口
2. 被引用的方法必须已经存在
3. 被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致。
4. 被引用方法的功能需要满足当前的需求

抽象方法形参的详解:

• 第一个参数:表示被引用方法的调用者，决定了可以引用哪些类中的方法在Stream流当中，第一个参数一般都表示流里面的每一个数据。假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用string这个类中的方法
• 第二个参数到最后一个参数:跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法
• 局限性:
  不能引用所有类中的成员方法。
  是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。

package Method_reference;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Dome7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"aaa","sss","www","ddd","zzz");

        list.stream().map(new Function<String, String>() {
            @Override
            //在该重写方法里面是带参的，不过在抽象方法中没有形参
            //因为在这个重写的方法中只有一个参数
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s -> System.out.println(s));
        //map(String::toUpperCase)
        //拿着流里面的每一个数据，去调用String类中的toUpperCase方法,方法的返回值就是转换之后的结果。
        list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));

    }
}

3.7、引用数组的构造方程

格式：数据类型[]::new
范例：Integer[]::new

• 细节:
  数组的类型，需要跟流中数据的类型保持一致。

package Method_reference;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;

public class Dome8 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6);

        Integer[] integers = list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });
        System.out.println(Arrays.toString(integers));
        //使用引用数组的构造方程
        //数组的类型，需要跟流中数据的类型保持一致。
        Integer[] integers2 =   list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(integers2));
    }
}

3.8、方法引用小练习

练习1：

package Method_reference;

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

public class Test1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三,23","李四,23","王五,23","陈六,23");

        Student[] s =  list.stream().map(Student::new).toArray(Student[]::new);
        System.out.println(Arrays.toString(s));
    }
}

package Method_reference;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String str){
        String[] split = str.split(",");
        this.name = split[0];
        this.age = Integer.parseInt(split[1]);
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

练习2：

package Method_reference;

import java.util.ArrayList;
import java.util.Arrays;


public class Test2 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student s1 = new Student("张三",24);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",24);
        Student s4 = new Student("陈六",24);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        String[] array = list.stream().map(Test2::apply).toArray(String[]::new);
        System.out.println(Arrays.toString(array));
        
        String[] array2 = list.stream().map(Student::getName).toArray(String[]::new);
        System.out.println(Arrays.toString(array2));
    }
    public static String apply(Student student) {
        String s =  student.getName();
        return s;
    }
}

练习3：

package Method_reference;

import java.util.ArrayList;
import java.util.Arrays;

public class Test3 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student s1 = new Student("张三",24);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",24);
        Student s4 = new Student("陈六",24);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        String[] arr =  list.stream().map(Test3::connect).toArray(String[]::new);
        System.out.println(Arrays.toString(arr));
    }
    public static String connect(Student student){
        String name = student.getName();
        int age = student.getAge();

        return name+"-"+age;
    }
}