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

news2024/11/15 19:26:17

文章目录

  • Stream流
    • 流式思想概述
    • 获取流
    • 常用方法
  • 方法引用
    • 方法引用符
    • 通过对象名引用成员方法
    • 通过类名称引用静态方法
    • 通过super引用成员方法
    • 通过this引用成员方法
    • 类的构造器引用
    • 数组的构造器引用

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热爱者了解文章，作者将会持续更新中，期待各位友友的关注和收藏。。。

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

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

相关文章

游戏如何应对黑灰产工作室

游戏如何应对黑灰产工作室

游戏黑灰产工作室&#xff0c;是指以非法渠道、非法手段通过游戏进行牟利的团伙。使用脚本、外挂是黑灰产工作室的显著特征&#xff0c;其常见的牟利方式有&#xff1a;打金工作室、资源囤积号、初始号、自抽号、代练工作室以及营销欺诈等。 ▲ 常见的游戏黑灰产工作室牟利路径…
阅读更多...
正向传播和反向传播

正向传播和反向传播

正向传播&#xff08;Forward Propagation&#xff09; 正向传播是指将输入数据通过神经网络&#xff0c;计算出预测值的过程。具体步骤如下&#xff1a; 输入层&#xff1a;接受输入数据。隐藏层&#xff1a;每个隐藏层中的神经元接收上一层的输出&#xff0c;进行加权求和&…
阅读更多...
ENSP防火墙综合配置

ENSP防火墙综合配置

综合拓扑&#xff1a; 实验要求&#xff1a; 要求一 生产区的安全策略配置 办公区的安全策略 要求二 生产区的安全策略 游客和办公区的安全策略 因为ISP返回的数据包会被防火墙最后的默认安全策略给拒绝&#xff0c;所以&#xff0c;把要ISP返回的数据给允许通过 要求三 增加…
阅读更多...
Lingo学习（三）——工厂合并、运算符、内置函数

Lingo学习（三）——工厂合并、运算符、内置函数

一、工厂合并 &#xff08;一&#xff09; 工厂合并——生产二维矩阵 【引入】 sets: factory /1..6/ : a; plant /1..8/ : d; Cooperation(factory,p lant) : c, x; endsets 以上程序可…
阅读更多...
Go语言入门之Map详解

Go语言入门之Map详解

Go语言入门之Map详解 1.基础定义 map是一个无序的&#xff0c;k-v键值对格式的集合 &#xff08;1&#xff09;特点 类型特点&#xff1a;map为引用类型&#xff0c;所以在函数中更新value值会永久改变顺序特点&#xff1a;map的遍历是无序的&#xff0c;因为底层是哈希表&am…
阅读更多...
按下快门前的算法——对焦

按下快门前的算法——对焦

对焦算法可以分为测距式&#xff0c;相位式&#xff0c;反差式。 其中测距式是通过激光&#xff0c;&#xff08;TOF&#xff0c;Time of Flight&#xff09;等主动式地得知物距&#xff0c;然后对焦。更常用的是后两者。 反差式CDAF&#xff08;Contrast Detection Auto Foc…
阅读更多...
微调及代码

微调及代码

一、微调&#xff1a;迁移学习&#xff08;transfer learning&#xff09;将从源数据集学到的知识迁移到目标数据集。 二、步骤 1、在源数据集&#xff08;例如ImageNet数据集&#xff09;上预训练神经网络模型&#xff0c;即源模型。 2、创建一个新的神经网络模型&#xff…
阅读更多...
【Python实战因果推断】31_双重差分2

【Python实战因果推断】31_双重差分2

目录 Canonical Difference-in-Differences Diff-in-Diff with Outcome Growth Canonical Difference-in-Differences 差分法的基本思想是&#xff0c;通过使用受治疗单位的基线&#xff0c;但应用对照单位的结果&#xff08;增长&#xff09;演变&#xff0c;来估算缺失的潜…
阅读更多...
PostgreSQL 中如何处理数据的批量更新和事务日志管理？

PostgreSQL 中如何处理数据的批量更新和事务日志管理？

文章目录 PostgreSQL 中数据的批量更新和事务日志管理 PostgreSQL 中数据的批量更新和事务日志管理 在数据库的世界里&#xff0c;数据的批量更新和事务日志管理就像是一场精心编排的舞蹈&#xff0c;需要精准的步伐和协调的动作。对于 PostgreSQL 而言&#xff0c;这两个方面…
阅读更多...
LLM基础模型系列：Fine-Tuning总览

LLM基础模型系列：Fine-Tuning总览

由于对大型语言模型&#xff0c;人工智能从业者经常被问到这样的问题&#xff1a;如何训练自己的数据&#xff1f;回答这个问题远非易事。生成式人工智能的最新进展是由具有许多参数的大规模模型驱动的&#xff0c;而训练这样的模型LLM需要昂贵的硬件&#xff08;即许多具有大量…
阅读更多...
常见 Web漏洞分析与防范研究

常见 Web漏洞分析与防范研究

前言&#xff1a; 在当今数字化时代&#xff0c;Web应用程序扮演着重要的角色&#xff0c;为我们提供了各种在线服务和功能。然而&#xff0c;这些应用程序往往面临着各种潜在的安全威胁&#xff0c;这些威胁可能会导致敏感信息泄露、系统瘫痪以及其他不良后果。 SQL注入漏洞 …
阅读更多...
自主研发接口测试框架

自主研发接口测试框架

测试任务&#xff1a;将以前完成的所有的脚本统一改写为unitest框架方式 1、需求原型 1.1 框架目录结构 V1.0&#xff1a;一般的设计思路分为配置层、脚本层、数据层、结果层&#xff0c;如下图所示 V 2.0&#xff1a;加入驱动层testdriver 1.2 框架各层需要完成的工作 1、配…
阅读更多...
【CT】LeetCode手撕—70. 爬楼梯

【CT】LeetCode手撕—70. 爬楼梯

目录 题目1- 思路2- 实现⭐70. 爬楼梯——题解思路 3- ACM实现 题目 原题连接&#xff1a;70. 爬楼梯 1- 思路 思路 爬楼梯 ——> 动规五部曲 2- 实现 ⭐70. 爬楼梯——题解思路 class Solution {public int climbStairs(int n) {if(n<1){return 1;}// 1. 定义 dp 数…
阅读更多...
html5——CSS基础选择器

html5——CSS基础选择器

目录 标签选择器 类选择器 id选择器 三种选择器优先级 标签指定式选择器 包含选择器 群组选择器 通配符选择器 Emmet语法&#xff08;扩展补充&#xff09; 标签选择器 HTML标签作为标签选择器的名称&#xff1a; <h1>…<h6>、<p>、<img/> 语…
阅读更多...
数据平滑处理（部分）

数据平滑处理（部分）

一、 移动平均&#xff08;Moving Average&#xff09; 是一种最简单的数据平滑方法&#xff0c;用于平滑时间序列数据。它通过计算一定窗口内数据点的平均值来减少噪音&#xff0c;同时保留数据的趋势。移动平均包括简单移动平均&#xff08;SMA&#xff09;或指数加权移动平均…
阅读更多...
初始网络知识

初始网络知识

前言&#x1f440;~ 上一章我们介绍了使用java代码操作文件&#xff0c;今天我们来聊聊网络的一些基础知识点&#xff0c;以便后续更深入的了解网络 网络 局域网&#xff08;LAN&#xff09; 广域网&#xff08;WAN&#xff09; 路由器 交换机 网络通信基础 IP地址 端…
阅读更多...
可观察性优势：掌握当代编程技术

可观察性优势：掌握当代编程技术

反馈循环是我们开发人员工作的关键。它们为我们提供信息&#xff0c;并让我们从用户过去和现在的行为中学习。这意味着我们可以根据过去的反应进行主动开发。 TestComplete 是一款自动化UI测试工具&#xff0c;这款工具目前在全球范围内被广泛应用于进行桌面、移动和Web应用的…
阅读更多...
“闭门造车”之多模态思路浅谈：自回归学习与生成

“闭门造车”之多模态思路浅谈：自回归学习与生成

©PaperWeekly 原创 作者 | 苏剑林 单位 | 科学空间 研究方向 | NLP、神经网络 这篇文章我们继续来闭门造车&#xff0c;分享一下笔者最近对多模态学习的一些新理解。 在前文《“闭门造车”之多模态思路浅谈&#xff1a;无损》中&#xff0c;我们强调了无损输入对于理想的…
阅读更多...
压缩文件的解析方式

压缩文件的解析方式

我们常用的压缩文件有两种&#xff1a;后缀为.zip或者.rar&#xff0c;接下来将介绍解析两种压缩文件的代码。需要用到三个jar包&#xff1a;commons-io-2.16.1.jar、junrar-7.5.5.jar、slf4j-api-2.0.13.jar&#xff0c;可以在官网下载&#xff0c;也可以发私信。 这段代码是一…
阅读更多...
2.GAP：通用访问协议

2.GAP：通用访问协议

GAP的简单理解 GAP这个名字&#xff0c;直接翻译过来不好理解。 简单点可以理解为&#xff1a; 这是蓝牙设备在互联之前&#xff0c;过程中&#xff0c;第一个用于交流的协议。在代码上&#xff0c;会给这个协议实现&#xff0c;连接参数的设置&#xff0c;连接事件的实现&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023