Java SE 学习记录——进阶版13-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42690266/article/details/114372530

本文详细介绍了Java中的Stream流的使用，包括如何通过传统方式和Stream方式进行集合数据过滤，流式思想，获取流的多种方式，以及常用的filter、map、count等操作。此外，还深入探讨了方法引用的概念，通过对象名、类名、super和this引用成员方法，以及构造器引用的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门【Stream流、方法引用】

第一章 Stream流

1.1 引言

传统集合的多步遍历代码
循环遍历的弊端
Stream的更优写法

24-02 使用传统方式遍历集合，对集合中的数据进行过滤

package day_13StreamAndMethodReference.demo01Stream;

import java.util.ArrayList;
import java.util.List;

/*
使用传统方法，遍历集合，对集合中的数据进行过滤
 */
public class Demo01List {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张三");

        // 对list集合中的元素进行过滤，只要以“张”开头的元素存储到一个新的集合中
        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                listA.add(s);
            }
        }

        // 对listA集合中的元素进行过滤，只要姓名长度为3的人存储到一个新的集合中
        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if (s.length() == 3) {
                listB.add(s);
            }
        }

        // 遍历listB集合
        for (String s : listB) {
            System.out.println(s);
        }
    }
}

24-03 使用Stream流的方式遍历集合，对集合中的数据进行过滤

package day_13StreamAndMethodReference.demo01Stream;

import java.util.ArrayList;
import java.util.List;

/*
使用Stream流的方式遍历集合，对集合中的数据进行过滤
Stream流是JDK1.8之后出现的
 */
public class Demo02Stream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张三");

        // 对list集合中的元素进行过滤，只要以“张”开头的元素存储到一个新的集合中
        // 对listA集合中的元素进行过滤，只要姓名长度为3的人存储到一个新的集合中
        // 遍历listB集合
        list.stream()
                .filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
    }
}

1.2 流式思想概述

24-04 流式思想概述

在这里插入图片描述

1.3 获取流

根据Collection获取流
根据Map获取流
根据数组获取流

24-05 两种获取Stream流的方式

package day_13StreamAndMethodReference.demo02Stream;

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

/*
java.util.stream.Stream<T> 是java1.8新加入的最常用的流接口（这并不是一个函数式接口）
获取一个流有一下几种常用的方式：
    所有的Collection集合都可以通过stream默认方法获取流
        default Stream<E> stream()
    Stream接口的静态方法of可以获取数组对应的流
        static <T> Stream<T> of (T...values)
        参数是一个可变参数，可以传递一个数组
 */
public class Demo01GetStream {
    public static void main(String[] args) {
        // 把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map = new HashMap<>();
        // 获取键，存储到一个Set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        // 获取键值对存储到一个Set集合中
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Stream<Map.Entry<String, String>> stream4 = entrySet.stream();

        // 获取值，存储到一个Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream5 = values.stream();

        // 把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        Integer[] arr1 = {1,2,3,4};
        Stream<Integer> stream7 = Stream.of(arr1);
        String[] arr2 = {"a","bb","ccc"};
        Stream<String> stream8 = Stream.of(arr2);


    }
}

1.4 常用方法

延迟方法与终结方法之分！
过滤：filter
　　复习Predicate接口
　　基本使用
统计个数：count
取用前几个：limit
跳过前几个：skip
映射：map
　　复习Function接口
　　基本使用
组合：concat
逐一处理：forEach

24-06 Stream流中的常用方式-forEach

package day_13StreamAndMethodReference.demo02Stream;

import java.util.stream.Stream;

/*
Stream流中的常用方法 forEach
void forEach(Consumer<? super T> action)
该方法接口一个Consumer接口函数，会将每一个流元素交给该函数进行处理
Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式消费数据

简而言之，forEach方法用来遍历流中的数据，是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
 */
public class Demo02Stream_forEach {
    public static void main(String[] args) {
        // 获取一个Stream流
        Stream<String> stream = Stream.of("张三","李四","王五","赵六","田七");
        // 调用forEach方法遍历数据
        stream.forEach(name-> System.out.println(name));
    }
}

24-07 Stream流中的常用方式-filter

package day_13StreamAndMethodReference.demo02Stream;

import java.util.stream.Stream;

/*
Stream流中的常用方法-filter用于对Stream流中的数据及逆行过滤
Stream<T> filter(Predicate<? super T> predicate);
filter方法的参数Predicate是一个函数式接口，可以传递Lambda表达式对数据进行过过滤
Predicate中的抽象方法
    boolean test(T t);

Stream流属于管道流，只能被消费（使用）一次
第一个Stream流调用完毕后，数据会流转到下一个Stream上
而此时第一个Stream流已经使用完毕，就会关闭了，它不能再调用方法了
 */
public class Demo03Stream_filter {
    public static void main(String[] args) {
        // 创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "赵敏", "周芷若", "张无忌");
        // 对Stream流中的元素进行过滤，只需要姓张的人
        Stream<String> stream1 = stream.filter(name -> name.startsWith("张"));
        // 遍历
        stream1.forEach(name-> System.out.println(name));
    }
}

24-09 Stream流中的常用方式-map

package day_13StreamAndMethodReference.demo02Stream;

import java.util.stream.Stream;

/*
如果需要将流中的元素映射到另一个流中，可以使用map方法
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型的数据转换为另一种R类型的流
function中的抽象方法
    R apply(T t);
 */
public class Demo04Stream_map {
    public static void main(String[] args) {
        // 获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        // 使用map方法，把字符串类型的整数映射为Integer类型的整数
        Stream<Integer> stream1 = stream.map(s -> Integer.parseInt(s));
        // 遍历
        stream1.forEach(num-> System.out.println(num));
    }
}

24-10 Stream流中的常用方式-count

package day_13StreamAndMethodReference.demo02Stream;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
Stream流中的常用方法-count用于统计Stream流中元素的个数
long count();
count方法是一个终结方法，返回值类型是一个long类型的整数，所以不能再继续调用Stream流中的其他方法了
 */
public class Demo05Stream_count {
    public static void main(String[] args) {
        // 获取一个Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(5);
        list.add(31);
        list.add(4);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

24-11 Stream流中的常用方式-limit

package day_13StreamAndMethodReference.demo02Stream;

import java.util.stream.Stream;

/*
Stream流中的常用方法-limit用于截取流中的元素
limit方法可以对流进行截取，只取用前n个
Stream<T> limit(long maxSize);
    参数是一个long类型，如果集合当前长度大于参数则进行截取，否则不进行操作
limit方法是一个延迟方法，只对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
 */
public class Demo06Stream_limit {
    public static void main(String[] args) {
        // 获取一个流
        String[] arr = {"法外","狂徒","张三","罗翔"};
        Stream<String> stream = Stream.of(arr);
        // 使用limit对Stream流中的元素进行截取
        Stream<String> stream1 = stream.limit(3);
        // 遍历
        stream1.forEach(name-> System.out.println(name));
    }
}

24-12 Stream流中的常用方式-skip

package day_13StreamAndMethodReference.demo02Stream;

import java.util.stream.Stream;

/*
Stream流中的常用方法-skip用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流
Stream<T> skip(long n);
    如果流的房前长度大于n，则跳过第n个，否则会得到一个长度为0的空流
 */
public class Demo07Stream_skip {
    public static void main(String[] args) {
        // 获取一个流
        String[] arr = {"法外","狂徒","张三","罗翔"};
        Stream<String> stream = Stream.of(arr);
        // 使用skip跳过Stream流中的前几个元素
        Stream<String> stream1 = stream.skip(2);
        // 遍历
        stream1.forEach(name-> System.out.println(name));

    }
}

24-13 Stream流中的常用方式-concat

package day_13StreamAndMethodReference.demo02Stream;

import java.util.stream.Stream;

/*
Stream流中的常用方法-concat 用于把流组合到一起
如果有两个流，希望合并成为一个流，可以使用Stream接口的静态方法concat
static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T> b);

 */
public class Demo08Stream_concat {
    public static void main(String[] args) {
        // 创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "赵敏", "周芷若", "张无忌");
        // 获取一个流
        String[] arr = {"法外","狂徒","张三","罗翔"};
        Stream<String> stream1 = Stream.of(arr);
        // 把两个流组合为一个流
        Stream<String> concat = Stream.concat(stream1, stream);
        concat.forEach(name-> System.out.println(name));

    }
}

1.5 练习：集合元素处理（传统方式）

题目
解答

24-14 练习：集合元素处理（传统方式）

package day_13StreamAndMethodReference.demo03Stream;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
练习：集合元素处理（传统方式）
    现在有两个ArrayList集合存储队去当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下爱若干操作步骤
    1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
    2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
    3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
    4.第一个队伍筛选之后不要前2个人，存储到一个新集合中
    5.将两个队伍合并为一个队伍，存储到一个新集合中
    6.根据姓名创建Person对象，存储到一个新集合中
    7.打印整个队伍的Person对象信息

 */
public class Demo01StreamTest {
    public static void main(String[] args) {
        // 第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        // 第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");

        // 1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
        ArrayList<String> one1 = new ArrayList<>();
        for (String s : one) {
            if (s.length() == 3) {
                one1.add(s);
            }
        }

        // 2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
        ArrayList<String> one2 = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            one2.add(one1.get(i));
        }

        // 3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
        ArrayList<String> two1 = new ArrayList<>();
        for (String s : two) {
            if (s.startsWith("张")) {
                two1.add(s);
            }
        }

        // 4.第一个队伍筛选之后不要前2个人，存储到一个新集合中
        ArrayList<String> two2 = new ArrayList<>();
        for (int i = 2; i < two1.size(); i++) {
            two2.add(two1.get(i));
        }

        // 5.将两个队伍合并为一个队伍，存储到一个新集合中
        ArrayList<String> list = new ArrayList<>();
        list.addAll(one2);
        list.addAll(two2);

        // 6.根据姓名创建Person对象，存储到一个新集合中
        ArrayList<Person> list1 = new ArrayList<>();
        for (String s : list) {
            list1.add(new Person(s));
        }

        // 7.打印整个队伍的Person对象信息
        for (Person person : list1) {
            System.out.println(person);
        }
    }
}

1.6 练习：集合元素处理（Stream方式）

题目
解答

24-15 练习：集合元素处理（Stream方式）

package day_13StreamAndMethodReference.demo03Stream;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
练习：集合元素处理（传统方式）
    现在有两个ArrayList集合存储队去当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下爱若干操作步骤
    1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
    2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
    3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
    4.第一个队伍筛选之后不要前2个人，存储到一个新集合中
    5.将两个队伍合并为一个队伍，存储到一个新集合中
    6.根据姓名创建Person对象，存储到一个新集合中
    7.打印整个队伍的Person对象信息

 */
public class Demo02StreamTest {
    public static void main(String[] args) {
        // 第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        // 第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");

        // 1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
        // 2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
        Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(3);
        // 3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
        // 4.第一个队伍筛选之后不要前2个人，存储到一个新集合中
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("张")).skip(2);
        // 5.将两个队伍合并为一个队伍，存储到一个新集合中
        // 6.根据姓名创建Person对象，存储到一个新集合中
        // 7.打印整个队伍的Person对象信息
        Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(person-> System.out.println(person));
    }
}

第二章方法引用

2.1 冗余的Lambda场景

2.2 问题分析

2.3 用方法引用改进代码

2.4 方法引用符

语义分析
推导和省略

24-16 方法引用的基本介绍

在这里插入图片描述

2.5 通过对象名引用成员方法

24-17 方法引用-通过对象名引用成员方法

package day_13StreamAndMethodReference.demo05ObjectMethodReference;

/*
通过对象名引用成员方法
使用前提是对象名已经存在，成员方法也是已经存在的
就可以使用对象名来引用成员方法
 */
public class Demo01ObjectMethodReference {
    public static void printString(Printable p) {
        p.print("hello");
    }

    public static void main(String[] args) {
        printString(str->{
            // 创建对象
            MethodRerObject obj = new MethodRerObject();
            // 通过对象名引用成员方法
            obj.printUpperCaseString(str);
        });

        // 使用方法引用优化Lambda
        printString(new MethodRerObject()::printUpperCaseString);
    }
}

package day_13StreamAndMethodReference.demo05ObjectMethodReference;

public class MethodRerObject {
    // 定义一个成员方法，传递字符串，把字符串按照大写输出
    public void printUpperCaseString(String str) {
        System.out.println(str.toUpperCase());
    }
}

package day_13StreamAndMethodReference.demo05ObjectMethodReference;

@FunctionalInterface
public interface Printable {
    // 定义字符串的抽象类
    public abstract void print(String s);
}

2.6 通过类名引用静态成员方法

24-18 方法引用-通过类名引用静态成员方法

package day_13StreamAndMethodReference.demo06StaticMethodReference;

@FunctionalInterface
public interface Calcable {
    // 定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
    public abstract int calAbs(int num);
}

package day_13StreamAndMethodReference.demo06StaticMethodReference;

/*
通过类名引用静态成员方法
类名已经存在，静态成员方法也是已经存在的
就可以使用类名来引用静态成员方法

 */
public class Demo01StaticMethodReference {
    public static int method(int num,Calcable cal) {
        return cal.calAbs(num);
    }

    public static void main(String[] args) {
        int abs = method(-24, num -> Math.abs(num));
        System.out.println(abs);

        // 使用方法引用优化Lambda
        int abs1 = method(-64, Math::abs);
        System.out.println(abs1);
    }

}

2.7 通过super引用成员方法

24-19 方法引用-通过super引用父类的成员方法

package day_13StreamAndMethodReference.demo07SuperMethodReference;

/*
定义父类
 */
public class Human {
    // 定义一个sayHello方法
    public void sayHello(){
        System.out.println("你好，我是Human" );
    }
}

package day_13StreamAndMethodReference.demo07SuperMethodReference;

/*
定义一个子类
 */
public class Man extends Human{
    // 子类重写父类方法
    @Override
    public void sayHello() {
        System.out.println("你好，我是Man");
    }

    // 定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
//        method(()->{
//            // 创建父类对象
//            Human human = new Human();
//            human.sayHello();
//        });

        // 因为存在子父类关系，存在关键字super
//        method(()->{
//            super.sayHello();
//        });

        // 优化
        method(super::sayHello);
    }

    public static void main(String[] args) {
        new Man().show();
    }
}

package day_13StreamAndMethodReference.demo07SuperMethodReference;

/*
定义见面的函数式接口
 */
@FunctionalInterface
public interface Greetable {
    void greet();
}

2.8 通过this引用成员方法

24-20 方法引用-通过this引用本类的成员方法

package day_13StreamAndMethodReference.demo08ThisMethodReference;

/*
定义一个函数式接口
 */
@FunctionalInterface
public interface Richable {
    void buy();
}

package day_13StreamAndMethodReference.demo08ThisMethodReference;

/*
通过this引用本类的成员方法
 */
public class Husband {
    // 定义一个买房子的方法
    public void buyHouse() {
        System.out.println("买第一套房");
    }

    // 定义一个结婚的方法，参数传递Richable接口
    public void marry(Richable r) {
        r.buy();
    }

    public void soHappy(){
//        marry(()->{
//            this.buyHouse();
//        });

        marry(this::buyHouse);
    }

    public static void main(String[] args) {
        new Husband().soHappy();
    }
}

2.9 类的构造器引用

24-21 方法引用-类的构造器引用

package day_13StreamAndMethodReference.demo09ConstructorMethodReference;


public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }
}

package day_13StreamAndMethodReference.demo09ConstructorMethodReference;

/*
定义一个函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
    // 定义一个方法，根据传递的姓名，创建Person对象返回
    Person builderPerson(String name);
}

package day_13StreamAndMethodReference.demo09ConstructorMethodReference;

/*
类的构造器（构造方法）引用
 */
public class Demo {
    public static void printName(String name,PersonBuilder pb) {
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
//        printName("罗翔",(name)->{
//            return new Person(name);
//        });

        printName("罗翔",Person::new); // 使用Person类的带参构造，通过传递的姓名创建对象

    }
}

2.10 数组的构造器引用

24-22 方法引用-数组的构造器引用

package day_13StreamAndMethodReference.demo10ArrayMethodReference;

@FunctionalInterface
public interface ArrayBuilder {
    // 定义一个创建int类型的数组的方法，参数传递数组的长度，返回创建好的int类型数组
    int[] builderArray(int length);
}

package day_13StreamAndMethodReference.demo10ArrayMethodReference;

/*
数组的构造器引用
 */
public class Demo {
    public static int[] creatArray(int length, ArrayBuilder ab) {
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        int[] array = creatArray(10, int[]::new);
        System.out.println(array.length);
    }
}