Java高级重点知识点-25-Stream流、方法引用

已于 2024-07-22 09:07:55 修改
阅读量1k 收藏 29
点赞数 29
文章标签： java 开发语言
于 2024-07-12 00:39:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72926194/article/details/140335458
版权

文章目录

Stream流

通过循环遍历来讲解流的优势；
要求：筛选所有姓张的人；然后筛选名字有三个字的人； 最后进行对结果进行打印输出。

import java.util.ArrayList;
import java.util.List;
public class Demo02NormalFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        List<String> zhangList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("张")) {
            zhangList.add(name);
        }
        }
        List<String> shortList = new ArrayList<>();
        for (String name : zhangList) {
            if (name.length() == 3) {
            shortList.add(name);
        }
        }
        for (String name : shortList) {
            System.out.println(name);
        }
    }
}

在这里插入图片描述
这段代码中我们可以看到，我们首先通过遍历集合list来获取到了所有姓张的人，然后我们通过遍历shortList集合来获取到了名字长度为三个字的人。最终打印出了名字三个字并且姓张的人，很显然这个过程很麻烦，下面我们来看一下Stream流式写法；

import java.util.ArrayList;
import java.util.List;
public class Demo03StreamFilter {
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    list.stream()
    .filter(s -> s.startsWith("张"))
    .filter(s -> s.length() == 3)
    .forEach(System.out::println);
    }
}

在这里插入图片描述
这里我们可以看到我们通过filter（）过滤方法过滤掉了姓张且名字长度为3的人，并且通过方法引用来输出打印。

流式思想概述

流式思想类似于工厂车间的“生产流水线”
Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。
Stream（流）是一个来自数据源的元素队列

  • 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
    数据源 流的来源。 可以是集合，数组 等。
  • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluentstyle）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

获取流

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口

  • 所有的 Collection 集合都可以通过 stream 默认方法获取流；
  • Stream 接口的静态方法 of 可以获取数组对应的流。
  1. 根据Collection获取流
import java.util.*;
import java.util.stream.Stream;
public class Demo04GetStream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();
        Vector<String> vector = new Vector<>();
        Stream<String> stream3 = vector.stream();
    }
}
  1. 根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流 需要分key、value或entry等情况

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
public class Demo05GetStream {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		Stream<String> keyStream = map.keySet().stream();
		Stream<String> valueStream = map.values().stream();
		Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
	}
}
  1. 根据数组获取流
    Stream 接口中提供了静态方法of来实现数组的流化。
import java.util.stream.Stream;
public class Demo06GetStream {
	public static void main(String[] args) {
		String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
		Stream<String> stream = Stream.of(array);
	}
}

常用方法

  • 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
  • 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。

逐一处理：forEach

  • void forEach(Consumer<? super T> action);
import java.util.stream.Stream;
public class StreamForEach {
	public static void main(String[] args) {
		Stream<String> stream = Stream.of("张三", "张三丰", "周姐");
		stream.forEach(name‐> System.out.println(name));
	}
}

过滤：filter

  • Stream<T> filter(Predicate<? super T> predicate);
import java.util.stream.Stream;
public class Demo07StreamFilter {
	public static void main(String[] args) {
		Stream<String> original = Stream.of("张三", "张三丰", "周姐");
		Stream<String> result = original.filter(s ‐> s.startsWith("张"));
	}
}

映射：map

  • <R> Stream<R> map(Function<? super T, ? extends R> mapper); 将流中的元素映射到另一个流中
import java.util.stream.Stream;
public class Demo08StreamMap {
	public static void main(String[] args) {
		Stream<String> original = Stream.of("10", "12", "18");
		Stream<Integer> result = original.map(str‐>Integer.parseInt(str));
	}
}

统计个数：count

  • long count(); 这里的返回值是long类型，不再和旧集合一样是int类型，也就是说可以用来获取更大的集合对象的大小。
import java.util.stream.Stream;
public class Demo09StreamCount {
	public static void main(String[] args) {
		Stream<String> original = Stream.of("张三", "张三丰", "周姐");
		Stream<String> result = original.filter(s ‐> s.startsWith("张"));
		System.out.println(result.count()); // 2
	}
}

取用前几个：limit

  • Stream<T> limit(long maxSize); 对流进行截取，只取用前maxSize个
import java.util.stream.Stream;
public class Demo10StreamLimit {
	public static void main(String[] args) {
		Stream<String> original = Stream.of("张三", "张三丰", "周姐");
		Stream<String> result = original.limit(2);
		System.out.println(result.count()); // 2
	}
}

跳过前几个：skip

  • Stream<T> skip(long n); skip 方法获取一个截取之后的新流
import java.util.stream.Stream;
public class Demo11StreamSkip {
	public static void main(String[] args) {
		Stream<String> original = Stream.of("张三", "张三丰", "周姐");
		Stream<String> result = original.skip(2);
		System.out.println(result.count()); // 1
	}
}

组合：concat

  • static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 两个流合并成为一个流
import java.util.stream.Stream;
public class Demo12StreamConcat {
	public static void main(String[] args) {
		Stream<String> streamA = Stream.of("张三");
		Stream<String> streamB = Stream.of("李四");
		Stream<String> result = Stream.concat(streamA, streamB);
	}
}

方法引用

冗余的Lambda场景：

  1. 首先定义一个函数式接口
@FunctionalInterface
public interface Printable {
	void print(String str);
}
  1. 通过lambda表达式来使用该字符串
public class PrintSimple {
	private static void printString(Printable data) {
		data.print("Hello, World!");
	}
	public static void main(String[] args) {
		printString(s ‐> System.out.println(s));
	}
}

对字符串进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是 System.out对象中的 println(String) 方法。因此我们不必自己动手调用该方法。使用方法引用即可。

public class Demo02PrintRef {
	private static void printString(Printable data) {
		data.print("Hello, World!");
	}
	public static void main(String[] args) {
		printString(System.out::println);
	}
}

方法引用符

双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。

  • Lambda表达式写法： s -> System.out.println(s); 语义：拿到参数之后经Lambda之手，继而传递给 System.out.println 方法去处理。
  • 方法引用写法： System.out::println 语义: 直接让 System.out 中的 println 方法来取代Lambda。

注意: Lambda 中 传递的参数 一定是方法引用中 的那个方法可以接收的类型,否则会抛出异常
函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。因此方法引用同时也是可推导可省略的；

通过对象名引用成员方法

  1. 首先定义一个函数式接口
@FunctionalInterface
public interface Printable {
    void print(String str);
}
  1. 创建一个实现了指定方法的类
public class MethodRefObject {
	public void printUpperCase(String str) {
	System.out.println(str.toUpperCase());
	}
}
  1. 测试
public class Demo04MethodRef {
    private static void printString(Printable lambda) {
        lambda.print("Hello");
    }
    public static void main(String[] args) {
        MethodRefObject obj = new MethodRefObject();
        printString(obj::printUpperCase);
    }
}

在这里插入图片描述
这里我们可以看到，我们通过方法引用了MethodRefObject中的printUpperCase（String str）方法，并没有通过lambda表达式来实现，而是使用一个已经实现了类中的方法，与我们引用System.out对象中的println（）方法类似。

通过类名称引用静态方法

通过java.lang.Math 类中的静态方法 abs举例

  1. 声明一个函数式接口
@FunctionalInterface
public interface Calcable {
	int calc(int num);
}
  1. 使用lambda表达式来实现
public class Demo05Lambda {
	private static void method(int num, Calcable lambda) {
		System.out.println(lambda.calc(num));
	}
	public static void main(String[] args) {
		method(‐10, n ‐> Math.abs(n));
	}
}
  1. 使用方法引用的方式来实现
public class Demo06MethodRef {
	private static void method(int num, Calcable lambda) {
		System.out.println(lambda.calc(num));
	}
	public static void main(String[] args) {
		method(‐10, Math::abs);
	}
}

通过super引用成员方法

如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。

  1. 定义函数式接口
@FunctionalInterface
public interface Greetable {
	void greet();
}
  1. 定义父类
public class Human {
	public void sayHello() {
		System.out.println("Hello!");
	}
}
  1. 定义子类(Lambda)
public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
    }
    //定义方法method,参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        //调用method方法,使用Lambda表达式
        method(()->{
            //创建Human对象,调用sayHello方法
            new Human().sayHello();
        });
        //简化Lambda
        method(()->new Human().sayHello());
        //使用super关键字代替父类对象
        method(()->super.sayHello());
    }
}
  1. 定义子类（方法引用）
public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
    }
    //定义方法method,参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        method(super::sayHello);
    }
}

通过this引用成员方法

这里与父类super类似，直接展示通过方法引用的写法

public class Husband {
	private void buyHouse() {
		System.out.println("买套房子");
	}
	private void marry(Richable lambda) {
		lambda.buy();
	}
	public void beHappy() {
		marry(this::buyHouse);
	}
}

类的构造器引用

  1. 定义一个Person类
public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
  1. 定义用来创建Person 对象的函数式接口
public interface PersonBuilder {
	Person buildPerson(String name);
}
  1. 使用Lambda表达式创建指定名称的Person对象
public class Demo09Lambda {
	public static void printName(String name, PersonBuilder builder) {
		System.out.println(builder.buildPerson(name).getName());
	}
	public static void main(String[] args) {
		printName("赵丽颖", name ‐> new Person(name));
	}
}
  1. 使用方法引用创建指定名称的Person对象
public class Demo10ConstructorRef {
	public static void printName(String name, PersonBuilder builder) {
		System.out.println(builder.buildPerson(name).getName());
	}
	public static void main(String[] args) {
		printName("赵丽颖", Person::new);
	}
}

数组的构造器引用

数组也是 Object 的子类对象，所以同样具有构造器

  1. 定义一个函数式接口
@FunctionalInterface
public interface ArrayBuilder {
	int[] buildArray(int length);
}
  1. 使用lambda表达式应用该接口
public class Demo11ArrayInitRef {
	private static int[] initArray(int length, ArrayBuilder builder) {
		return builder.buildArray(length);
	}
	public static void main(String[] args) {
	int[] array = initArray(10, length ‐> new int[length]);
	}
}
  1. 使用方法引用应用该接口
public class Demo12ArrayInitRef {
	private static int[] initArray(int length, ArrayBuilder builder) {
		return builder.buildArray(length);
	}
	public static void main(String[] args) {
		int[] array = initArray(10, int[]::new);
	}
}

欢迎java热爱者了解文章，作者将会持续更新中，期待各位友友的关注和收藏,另外对编程感兴趣的友友们可以加以下群共同学习。群号：127871664

【Java学习】第25节：Stream流和方法引用
m0_46013789的博客
05-23 1148
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
Java高级重点知识点-27-Java反射机制
m0_72926194的博客
07-12 1437
本章节中主要讲解了Java的反射机制，反射就好比一面镜子，我们可以通过这面镜子获取到类中的全部结构，比如说获取到类中的所有构造器、字段、方法、接口、泛型。这里反射技术运用最多的就是动态代理，通过动态代理我们可以实现程序的一些拓展功能，其中必不可少的就是实现IInvocationHandler接口的代理对象，核心方法就是实现invoke（）这里的逻辑要明白。
Java知识点汇总--基础篇
m0_74194490的博客
07-01 3677
异常就是程序在运行时出现的意外情况，而导致程序无法正常往下执行[终止了]当系统提供的异常类型无法满足客户需求时，程序员可以自己定义异常类型。目的可以达到见名知意创建一个异常类并继承RuntimeException//创建一个构造函数super(msg);使用自定义的异常类。
Java高频面试基础知识点整理
热门推荐
张彦峰的博客
11-04 168万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
Java后端真实面试题大全(有详细答案)--高频/真题
IT利刃出鞘的博客
11-24 14万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
Java基础之——Stream 流、方法引用
前尘忆梦的博客
09-17 414
Stream 流、方法引用 1、Stream 流 1.1、引言 传统集合的多步遍历代码 几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如： import java.util.ArrayList; import java.util.List; /* 使用传统的方式，遍历集合，对集合中的元素进行过滤 */ public class Demo01ForEa
Java中高级核心知识
weixin_70730532的博客
06-02 1543
前言：java是一门面向对象的编程语言，功能强大、简单易用，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。在Java简单入门之后很多人不知道下一阶段该做什么，对自己的学习进程没有一个系统性的规划，或者是知道该学什么，却又找不到对应的内容。在这里我对上述问题做了一个整合，希望对大家有所帮助。目录：一、Java(一).基础1. Java基本功1.1.Java入门（基础概念与常识）1.1.1. Java语言有哪些特点?1.1.2.关于JVMJDK和JRE最详细通俗的解答1.1.2.1.J
Java进阶知识笔记13--【Stream流、方法引用】
Kuber
10-09 453
【Stream流、方法引用】 主要内容 Stream流 方法引用 第一章 Stream流 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带 来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 引言 传统集合的多步遍历代码 几乎所有的集合（如Collection 接口或Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，
JAVA核心技术--高级特征(第八版)--第三部分
11-23
本书分为四部分，确保全面且系统地讲解了Java开发中的关键知识点，而这里我们将聚焦于第三部分。 在Java的高级特性中，多线程是不可或缺的一环。在《部分6》中，作者可能会详细讲解如何创建和管理线程，包括Thread...
Java基础：Stream流和方法引用
xpy2428507302的博客
06-14 1105
可以理解为一条流水线，可以对流水线上的数据进行各种操作（筛选、打印等）。结合了 Lambda表达式，简化集合、数组的操作① 先得到一个 Stream 流，将数据放上去② 利用 Stream 流中的中间方法进行各种操作。③ 利用 Stream 流中的终结方法进行各种操作。方法引用：把已经存在的方法拿过来用，当作函数式接口中重写的抽象方法的方法体。方法引用可以比 Lambda表达式 的写法更加简便。① 引用处必须是函数式接口。② 被引用方法必须已经存在（如果不存在，需要自定义方法或者使用第三方工具类）
使用XStream是实现XML与Java对象的转换(5)--Object Stream
08-03
虽然具体的文件列表中只有一个名为“使用XStream是实现XML与Java对象的转换(5)--Object Stream.docx”的文档，我们无法直接查看其内容，但可以合理猜测文档会涵盖以下知识点： 1. XStream库的基本介绍和安装 2. XML...
字节跳动Java开发面试题及参考答案（综合篇）
大模型大数据攻城狮的专栏
12-20 744
数字签名是一种用于验证数字信息（如文件、消息、软件等）的来源和完整性的技术手段。从技术原理来讲，数字签名基于非对称加密算法。发送方首先使用自己的私钥对要发送的信息进行加密处理，这个加密后的信息片段就是数字签名。然后将数字签名和原始信息一起发送给接收方。接收方在收到信息后，会使用发送方的公钥来解密数字签名。如果解密成功，就可以验证信息确实是由拥有该私钥的发送方发送的，并且可以通过一些验证算法来检查原始信息在传输过程中是否被篡改。
Java——int和String类型相互转换、valueOf()函数细节
qq_51706641的博客
12-24 922
本文总结一下Java中`int`和`String`类型相互转换的一些常用方法和函数，这些方法在处理不同类型的数据时非常有用，尤其是在数据输入输出、格式化和解析等场景中。
Jmeter压测实战：Jmeter二次开发之自定义函数
cs888zsy的博客
12-20 1211
Jmeter是Apache基金会下的一款应用场景非常广的压力测试工具，具备轻量、高扩展性、分布式等特性。Jmeter已支持实现随机数、计数器、时间戳、大小写转换、属性校验等多种函数，方便使用人员使用。如果在使用过程中存在和业务强耦合的常用功能函数，在Jmeter不支持的情况下，那就需要单独开发自定义函数实现特定功能。
springBoot发布https服务及调用
最新发布
木槿
12-25 172
（1）自签名证书：如果你只是用于开发或测试环境，可以生成一个自签名证书。（2）CA 签名证书：对于生产环境，应该使用由受信任的证书颁发机构 (CA) 签名的证书。这将创建一个有效期为 10 年的自签名证书，并将其存储在文件中。你需要提供一些信息，如组织名称等。注意记住密码和别名。
基于SpringBoot的山西文旅网系统
Q_1928499906的博客
12-23 819
该系统旨在通过信息化手段，整合山西文旅资源，为游客提供便捷、高效的旅游服务，同时推动山西文旅产业的数字化转型和升级。展望未来，随着技术的不断发展和文旅产业的不断壮大，基于SpringBoot的山西文旅网系统将继续优化和完善功能，为游客提供更加优质、便捷的服务体验。它能够为山西省内的文旅产业相关企业和机构提供便捷、高效的在线旅游服务支持，推动山西文旅产业的数字化转型和升级。同时，系统还支持数据备份和恢复功能，确保数据的完整性和可用性。同时，通过合理的系统架构和优化的代码设计，提高了系统的运行效率和响应速度。
纯真社区版IP库CZDB数据格式使用教程
l_user的专栏
12-25 246
纯真社区版IP库是一种免费且公开的IP地理位置数据库，主要面向非商业用途。其最新推出的CZDB格式是一种全新的数据文件格式，自2024年10月起将成为官方维护和更新的唯一版本。
Ubuntu系统部署程序：修改IP、部署docker、nginx、Redis、onlyoffice、java
m0_74823595的博客
12-24 593
部署onlyoffice,data目录要给权限，不然可能会启动有问题，从日志里面可以查看报错。安装java，此处为安装包部署，容器就不用说了，没啥意思。记录一次Ubuntu系统的程序部署。
springboot492基于java线上历史馆藏系统(论文+源码)_kaic
涉及毕业论文、远程调试、小程序、管理系统、JAVA、C#、IDEA、VS开发工具等
12-25 569
摘 要计算机网络发展到现在已经好几十年了，在理论上面已经有了很丰富的基础，并且在现实生活中也到处都在使用，可以说，经过几十年的发展，互联网技术已经把地域信息的隔阂给消除了，让整个世界都可以即时通话和联系，极大的方便了人们的生活。所以说，历史馆藏系统用计算机技术来进行设计，不仅在管理方面更加的系统化，操作性强，最重要的是关于数据的保存和使用都能节约大量的时间，该系统非常的好用。历史馆藏系统管理数据的工具是MySQL，编码的语言是Java，运用的框架是Spring 、SpringMVC、Mybatis框架。该
【Java基础面试题041】Java中的深拷贝和浅拷贝有什么区别？
lklalmq的博客
12-25 400
常见实现方式是重写Object.clone()方法，默认方法这个方法只是对对象的字段进行字段拷贝，对于基本类型的字段会复制值，对于引用类型的字段则复制引用。深拷贝创建的新对象与原对象完全独立，任何一个对象的修改都不会影响另一个。二修改浅拷贝对象中的引用类型的字段会影响要原对象，因为它们共享相同的引用。浅拷贝只复制对象的引用，而不复制引用指向的实际对象，也就是说，浅拷贝创建一个新对象，但它的字段（若是对象类型）深拷贝不仅复制对象本身，还递归复制对象中所有引用的对象。指向的是原对象中的相同内存地址。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿胡爱编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>