Java笔记_16

一、创建不可变集合
- 1.1、创建不可变集合的应用场景
- 1.2、创建不可变集合的书写格式
二、Stream流
- 2.1、体验Stream流
- 2.2、Stream流的思想和获取Stream流
- 2.3、Stream流的中间方法
- 2.4、Stream流的终结方法
- 2.5、收集方法collect
- 2.6、练习-数字过滤
- 2.7、练习-字符串过滤并收集
- 2.8、练习-数据操作
三、方法引用
- 3.1、方法引用概述
- 3.2、引用静态方法
- 3.3、引用成员方法
- 3.4、引用本类或父类的成员方法
- 3.5、引用构造方法
- 3.6、类名引用成员方法
- 3.7、引用数组的构造方程
- 3.8、方法引用小练习

一、创建不可变集合

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

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：

键是不能重复的
Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对
如果我们要传递多个键值对对象，数量大于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>() {@Overridepublic 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流的使用步骤:

先得到一条Stream流（流水线)，并把数据放上去
利用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>() {@Overridepublic 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>() {@Overridepublic 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[]>() {@Overridepublic 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>() {//第一个匿名内部类，编写键的规则@Overridepublic String apply(String s) {return s.split("-")[0];}}, new Function<String, Integer>() {//第二个匿名内部类，编写值的规则@Overridepublic Integer apply(String s) {return Integer.parseInt(s.split("-")[2]);}}));System.out.println(collect);//写成lambdaMap<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、方法引用概述

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

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

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

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

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>() {@Overridepublic 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>() {@Overridepublic 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、引用成员方法

格式：对象::成员方法

其他类：其他类对象:方法名
本类：this::方法名
父类：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>() {@Overridepublic 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

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

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

抽象方法形参的详解:

第一个参数:表示被引用方法的调用者，决定了可以引用哪些类中的方法在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[]>() {@Overridepublic 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;}
}

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

Java基础 Stream流方法引用异常文件
Stream流引例需求:按照下面要求完成集合的创建和遍历创建一个集合,存储多个字符串元素 1. 把所有以"曹"开头的元素存储到新集合中 2. 把曹开头,长度为3的元素存储到新 ...
不可变集合 Stream流异常
目录创建不可变集合如何创建不可变集合? Stream流 Stream流的概述 Stream流的获取 Stream流的常用API Stream流的综合应用收集Stream流异常处理异常概述.体 ...
Stream流方法引用
一.对象存在,方法也存在,双冒号引用 1.方法引用的概念: 使用实例: 1.1先定义i一个函数式接口: 1.2定义一个入参参数列表有函数式接口的方法: 1.3调用这个入参有函数式接口的方法: lamb ...
Java从入门到精通十七(Stream 流)
Java从入门到精通十七(Stream 流 ) Stream 流引入说明 Stream 流的常用方法说明 1: filter() 2:collect() 3:distinct() 4:sorted() ...
深入理解Java 8 Lambda（语言篇——lambda，方法引用，目标类型和默认方法）
作者:Lucida 微博:@peng_gong 豆瓣:@figure9 原文链接:http://zh.lucida.me/blog/java-8-lambdas-insideout-language- ...
Stream和方法引用
Stream和方法引用 1. Stream流 1.1. Stream流引入 Stream流完全不是I/O流,按照流水线处理方式来考虑代码中的思想.JDK1.8 之后,我们拥有了Lambda表达式,让代 ...
黑马笔记---创建不可变集合与Stream流
目录 1.不可变集合 1.1什么是不可变集合? 1.2如何创建不可变集合? 总结: 2.Stream流 2.1Stream流的概述什么是Stream流? 案例:Stream流的作用 Stream流式 ...
第八章_集合(3)_Map集合Stream流
目录一.Map 1.Map集合的基本使用 2.Map集合的常用方法 3.Map集合遍历二.HashMap 三.TreeMap 四.可变参数五.Stream流 1.Stream流概念 2.获取St ...
【Java笔记】File类与IO流(另添加NIO2使用)
文章目录本章专题与脉络 java.io.File类的使用概述构造器常用方法获取文件和目录基本信息列出目录的下一级 File类的重命名功能判断功能的方法创建.删除功能 NIO2的使用 P ...

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