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

news2024/12/24 2:13:04

Java笔记_15

  • 一、创建不可变集合
    • 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：

  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;
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/481877.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python词云图的制作与案例分享（包含 wordcloud 和 jieba库）

Python词云图的制作与案例分享（包含 wordcloud 和 jieba库）

一、基本知识 Python 有很多可用于制作词云图的库&#xff0c;其中比较常用的有 wordcloud 和 jieba。 wordcloud 是一个用于生成词云图的 Python 库&#xff0c;其使用了 Python 的 PIL 库和 numpy 库。您可以使用 pip 命令来安装 wordcloud 库&#xff1a; pip install wo…
阅读更多...
第12章 项目沟通管理和干系人管理

第12章 项目沟通管理和干系人管理

文章目录 12.1.2 沟通的方式 404沟通管理计划的编制过程12.2.2 制订沟通管理计划的工具 4114、沟通方法 12.3.2 管理沟通的工具 41312.4.2 控制沟通的技术和方法 4163、会议 12.5.1 项目干系人管理所涉及的过程 420项目干系人管理的具体内容&#xff1a;&#xff08;1&#xff…
阅读更多...
从“青铜”到“王者”，制造企业的数字化闯关记

从“青铜”到“王者”，制造企业的数字化闯关记

打过游戏的朋友可能有一个常识&#xff0c;越是精彩纷呈、奖励丰厚的副本&#xff0c;越是需要召集队友一同组团闯关。很多实体企业在数字化转型中&#xff0c;也不会单打独斗&#xff0c;一把手会先找咨询公司对企业内外情况进行调研、梳理、规划&#xff0c;提出一个顶层规划…
阅读更多...
科学计算库—numpy随笔【五一创作】

科学计算库—numpy随笔【五一创作】

文章目录 8.1、numpy8.1.1、为什么用 numpy&#xff1f;8.1.2、numpy 数据类型推理8.1.3、numpy 指定长度数组快速创建8.1.4、numpy 哪个是行、列&#xff1f;8.1.5、numpy 如何进行数据类型转换&#xff1f;8.1.6、numpy 有几种乘法&#xff1f;8.1.7、numpy 索引和切片操作8.…
阅读更多...
2023年前端面试题汇总-代码输出篇

2023年前端面试题汇总-代码输出篇

1. 异步 & 事件循环 1. 代码输出结果 const promise new Promise((resolve, reject) > {console.log(1);console.log(2); }); promise.then(() > {console.log(3); }); console.log(4); 输出结果如下&#xff1a; 1 2 4 promise.then 是微任务&#xff0c;它…
阅读更多...
【今日重磅—国产大模型首批内测机会来了】什么是讯飞星火，如何获得内测和使用方法

【今日重磅—国产大模型首批内测机会来了】什么是讯飞星火，如何获得内测和使用方法

♥️作者&#xff1a;白日参商 &#x1f935;‍♂️个人主页&#xff1a;白日参商主页 ♥️坚持分析平时学习到的项目以及学习到的软件开发知识&#xff0c;和大家一起努力呀&#xff01;&#xff01;&#xff01; &#x1f388;&#x1f388;加油&#xff01; 加油&#xff01…
阅读更多...
数电实验：Quartus II 软件使用 （八进制计数器和全加器）

数电实验：Quartus II 软件使用 （八进制计数器和全加器）

一、实验目的&#xff1a; 1.熟悉可编程逻辑器件的设计工具Quartus II 软件的使用。 2.熟悉FPGA开发实验系统的软件环境&#xff0c;掌握各个菜单和图标的作用和功能。 二、实验内容 &#xff08;1&#xff09;以74160实现八进制计数器为例&#xff0c;学Quartus II 软件的…
阅读更多...
【手撕代码系列】JS手写实现Promise.all

【手撕代码系列】JS手写实现Promise.all

Promise.all() 方法接收一个 Promise 对象数组作为参数&#xff0c;返回一个新的 Promise 对象。该 Promise 对象在所有的 Promise 对象都成功时才会成功&#xff0c;其中一个 Promise 对象失败时&#xff0c;则该 Promise 对象立即失败。 本篇博客将手写实现 Promise.all() 方…
阅读更多...
Peforce(Helix) 使用快速介绍

Peforce(Helix) 使用快速介绍

虽然Git应该是当下使用最多的版本控管工具&#xff0c; 但曾经作为版本控管巨头的Perforce还是在持续的发展和更新中&#xff0c; 在某些企业中&#xff0c;还是作为软件的版本控管工具之一。 Helix 截止2023, Perforce 的最新版本的名称是Helix ,这个词翻译的意思是螺旋&…
阅读更多...
【手撕代码系列】JS手写实现Promise.race

【手撕代码系列】JS手写实现Promise.race

公众号&#xff1a;Code程序人生&#xff0c;分享前端所见所闻。 Promise.race() 是一个常见的 JavaScript Promise 方法&#xff0c;它接受一个 Promise 数组作为参数&#xff0c;并返回一个新的 Promise 对象。这个新的 Promise 对象在传入的 Promise 数组中&#xff0c;任意…
阅读更多...
[架构之路-158]-《软考-系统分析师》-13-系统设计 - 高内聚低耦合详解、图解以及技术手段

[架构之路-158]-《软考-系统分析师》-13-系统设计 - 高内聚低耦合详解、图解以及技术手段

目录 第1章 什么是高内聚低耦合 1.1 概念 1.2 目的 1.3 什么时候需要进行高内聚低耦合 1.4 什么系统需要关注高内聚、低耦合 第2章 分类 2.1 内聚的分类 2.2 耦合的分类 第3章 增加高内聚降低耦合度的方法 3.1 增加高内聚 3.2 降低耦合度 第1章 什么是高内聚低耦…
阅读更多...
seurat -- 关于DE gene的讨论

seurat -- 关于DE gene的讨论

实例 # 加载演示数据集 library(Seurat) library(SeuratData) pbmc <- LoadData("pbmc3k", type "pbmc3k.final")# list options for groups to perform differential expression on levels(pbmc)## [1] "Naive CD4 T" "Memory CD4 T…
阅读更多...
Orangepi Zero2 全志H616（DHT11温湿度检测）

Orangepi Zero2 全志H616（DHT11温湿度检测）

最近在学习Linux应用和安卓开发过程中&#xff0c;打算把Linux实现的温湿度显示安卓app上&#xff0c;于是在此之前先基于Orangepi Zero2 全志H616下的wiringPi库对DHT11进行开发&#xff0c;本文主要记录开发过程的一些问题和细节&#xff0c;主要简单通过开启线程来接收温湿度…
阅读更多...
LeetCode1376. 通知所有员工所需的时间

LeetCode1376. 通知所有员工所需的时间

【LetMeFly】1376.通知所有员工所需的时间 力扣题目链接&#xff1a;https://leetcode.cn/problems/time-needed-to-inform-all-employees/ 公司里有 n 名员工&#xff0c;每个员工的 ID 都是独一无二的&#xff0c;编号从 0 到 n - 1。公司的总负责人通过 headID 进行标识。…
阅读更多...
c++题目练习

c++题目练习

阅读更多...
QML动画分组（Grouped Animations）

QML动画分组（Grouped Animations）

通常使用的动画比一个属性的动画更加复杂。例如你想同时运行几个动画并把他们连接起来&#xff0c;或者在一个一个的运行&#xff0c;或者在两个动画之间执行一个脚本。动画分组提供了很好的帮助&#xff0c;作为命名建议可以叫做一组动画。有两种方法来分组&#xff1a;平行与…
阅读更多...
SNAP + StaMPS 处理Sentinel-1哨兵1 时间序列

SNAP + StaMPS 处理Sentinel-1哨兵1 时间序列

SNAP StaMPS 处理Sentinel-1哨兵1 时间序列 Step0: 文件准备及路径设置 0.1 前往GitHub下载snap2stamps: Github snap2stamps 0.2 新建工作路径&#xff0c;用来进行数据处理&#xff0c;并将下载的snap2stamps解压到该文件夹下&#xff0c;并新建两个文件夹&#xff0c;ma…
阅读更多...
二叉搜索树的最小绝对差

二叉搜索树的最小绝对差

1题目 给你一个二叉搜索树的根节点 root &#xff0c;返回 树中任意两不同节点值之间的最小差值 。 差值是一个正数&#xff0c;其数值等于两值之差的绝对值。 示例 1&#xff1a; 输入&#xff1a;root [4,2,6,1,3] 输出&#xff1a;1示例 2&#xff1a; 输入&#xff1a;r…
阅读更多...
证券从业资格证-考前复习

证券从业资格证-考前复习

备考2023年6月证券从业资格证&#xff0c;每章思维导图及相关概念&#xff0c;用于考前复习 1. 金融市场基础知识 1.1 第一章 金融市场体系 #mermaid-svg-XEPZZTVBmo6nGm2Y {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#merm…
阅读更多...
【14.HTML-移动端适配】

【14.HTML-移动端适配】

移动端适配 1 布局视口和视觉视口1.1 设置移动端布局视口宽度 2 移动端适配方案2.1 rem单位动态html的font-size&#xff1b;2.2 vw单位2.3 rem和vw对比2.4 flex的弹性布局 1 布局视口和视觉视口 1.1 设置移动端布局视口宽度 避免布局视口宽度默认980px带了的缩放问题,并且禁止…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023