当前位置： 首页 > news >正文

Java的stream流其一

news 2025/7/16 11:46:00

文章目录

  • 1,内部类
    • 1.1,成员内部类
    • 1.2, 静态内部类
    • 1.3,局部内部类
    • 1.4,匿名内部类
  • 2,Lamda表达式
    • 2.1基本格式
    • 2.2 省略规则
  • 3,函数式接口
    • 3.1,消费型接口（Consumer<T>）
    • 3.2, 供给型接口（Supplier<T>）
    • 3.3,函数型接口（Function<T, R>）
    • 3.4, 断言型接口（Predicate<T>）
    • 3.5,Comparator
  • 4,Stream流
    • 4.1,创建流
    • 4.2,中间操作
      • filter
      • map
      • distinct
      • sorted
      • limit
      • skip
      • flatMap
    • 4.3,终结操作
      • forEach
      • count
      • max&min
      • collect
      • 查找与匹配
        • anyMatch
        • allMatch
        • noneMatch
        • findAny
        • findFirst
      • reduce归并
    • 4.4,常用方法
    • 4.5,注意事项

1,内部类

内部类是指定义在另一个类内部的类。Java中有四种类型的内部类：

  1. 成员内部类 - 定义在外部类的成员位置
  2. 局部内部类 - 定义在方法或作用域内
  3. 匿名内部类 - 没有名字的内部类
  4. 静态嵌套类 - 使用static修饰的内部类

1.1,成员内部类

  • 定义在外部类的内部，作为外部类的一个成员。
  • 可以访问外部类的所有成员（包括私有成员）。外部类也可以访问内部类的私有成员
  • 必须通过外部类的实例来创建。
public class Outer {private int x = 10;public class Inner {public void printX() {System.out.println(x); // 直接访问外部类的私有成员}}public static void main(String[] args) {Outer outer = new Outer();Inner inner = outer.new Inner(); // 创建内部类实例inner.printX(); // 输出: 10}
}

1.2, 静态内部类

  • 使用static关键字修饰的内部类。
  • 只能访问外部类的静态成员。
  • 可以直接通过外部类名创建实例，无需先创建外部类的实例。
public class Outer {private static int x = 10;public static class Inner {public void printX() {System.out.println(x); // 访问外部类的静态成员}}public static void main(String[] args) {Outer.Inner inner = new Outer.Inner(); // 直接创建静态内部类实例inner.printX(); // 输出: 10}
}

1.3,局部内部类

  • 定义在方法或代码块内部的类。
  • 只能在定义它的方法或代码块中使用。
  • 可以访问外部类的成员，以及方法中的 final 局部变量（Java 8 + 中可以访问非 final 但实际上不可变的局部变量）。
public class Outer {public void display() {final int y = 20; // 局部变量（Java 8+可省略final）class LocalInner {public void printY() {System.out.println(y); // 访问局部变量}}LocalInner inner = new LocalInner();inner.printY(); // 输出: 20}public static void main(String[] args) {Outer outer = new Outer();outer.display();}
}

1.4,匿名内部类

匿名内部类是没有名字的内部类，通常用于创建接口或抽象类的即时代码实现。

  • 没有显式类名的局部内部类，必须在定义的同时实例化。
  • 通常用于创建实现某个接口或继承某个类的对象，且只需使用一次。
  • 语法简洁，但可能降低代码可读性。
public class Outer {public void display() {// 实现Runnable接口的匿名内部类Runnable r = new Runnable() {@Overridepublic void run() {System.out.println("匿名内部类实现Runnable接口");}};new Thread(r).start(); // 启动线程}public static void main(String[] args) {Outer outer = new Outer();outer.display();}
}

2,Lamda表达式

​ Lambda是JDK8中一个语法糖。他可以对某些匿名内部类的写法进行简化。它是函数式编程思想的一个重要体现。让我们不用关注是什么对象。而是更关注我们对数据进行了什么操作。

2.1基本格式

(参数列表)->{代码}

2.2 省略规则

  • 参数类型可以省略
  • 方法体只有一句代码时大括号return和唯一一句代码的分号可以省略
  • 方法只有一个参数时小括号可以省略
  • 以上这些规则都记不住也可以省略不记

3,函数式接口

函数式接口（Functional Interface）是 Java 8 引入的一个核心概念，它是一种特殊的接口，只包含一个抽象方法（但可以有多个默认方法或静态方法）。函数式接口的主要作用是支持 Lambda 表达式和方法引用，使 Java 具备函数式编程的能力。

函数式接口必须满足以下条件：

  • 只包含一个抽象方法（Single Abstract Method，简称 SAM）。
  • 可以包含多个默认方法（default 修饰）或静态方法。
  • 推荐使用 @FunctionalInterface 注解标记

示例：

@FunctionalInterface
public interface MyFunction {void apply(int value); // 唯一的抽象方法default void print() { // 默认方法System.out.println("Default method");}static void staticMethod() { // 静态方法System.out.println("Static method");}
}

3.1,消费型接口（Consumer）

  • 作用：接收一个输入参数，不返回结果（void），用于 “消费” 数据（如打印、存储等操作）。

  • 核心方法：void accept(T t)

  • 示例

    // 定义一个 Consumer，用于打印字符串
Consumer<String> printer = s -> System.out.println(s);
printer.accept("Hello"); // 输出：Hello// 集合遍历（forEach 接收 Consumer）
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");// forEach：接收 Consumer，消费每个元素
names.stream().forEach(name -> System.out.println("Hello, " + name));// peek：接收 Consumer，用于调试（不改变元素）
names.stream().filter(name -> name.length() > 3).peek(name -> System.out.println("Filtered: " + name)).map(String::toUpperCase).forEach(System.out::println);

3.2, 供给型接口（Supplier）

  • 作用：不接收参数，返回一个结果（T），用于 “供给” 数据（如生成随机数、创建对象）。

  • 核心方法：T get()

  • 示例

    // 定义一个 Supplier，生成随机数
Supplier<Double> random = () -> Math.random();
System.out.println(random.get()); // 输出随机数// 生成无限流（generate）、延迟创建对象。
Supplier<Integer> randomSupplier = () -> new Random().nextInt(100);Stream.generate(randomSupplier).limit(5)  // 限制只取前5个元素.forEach(System.out::println);// 使用 Supplier 创建对象流
Supplier<String> helloSupplier = () -> "Hello";
Stream.generate(helloSupplier).limit(3).forEach(System.out::println);

3.3,函数型接口（Function<T, R>）

作用：接收一个输入参数（T），返回一个结果（R），用于 “转换” 数据（如类型转换、数值计算）。

核心方法：R apply(T t)

List<String> words = Arrays.asList("hello", "world");// map：接收 Function，将每个元素转换为另一种类型
Function<String, Integer> lengthFunction = s -> s.length();
List<Integer> lengths = words.stream().map(lengthFunction).collect(Collectors.toList());
System.out.println(lengths); // 输出：[5, 5]

3.4, 断言型接口（Predicate）

  • 作用：接收一个输入参数，返回一个 布尔值（true 或 false），用于 “判断” 条件是否成立。
  • 核心方法：boolean test(T t)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);// filter：接收 Predicate，保留满足条件的元素
Predicate<Integer> isEven = num -> num % 2 == 0;
numbers.stream().filter(isEven).forEach(System.out::println); // 输出：2, 4, 6

3.5,Comparator

Comparator 接口中确实存在 compare(T o1, T o2) 和 equals(Object obj) 两个抽象方法，但函数式接口的核心定义是：只包含一个 “用户定义的抽象方法”。而 equals 方法是 Object 类的方法，所有类都默认继承了 equals 方法，因此接口中声明的 equals 方法会被视为对 Object.equals 的重写声明，而非一个新的抽象方法。

4,Stream流

4.1,创建流

单列集合： 集合对象.stream()

        List<Author> authors = getAuthors();Stream<Author> stream = authors.stream();

数组：Arrays.stream(数组) 或者使用Stream.of来创建

        Integer[] arr = {1,2,3,4,5};Stream<Integer> stream = Arrays.stream(arr);Stream<Integer> stream2 = Stream.of(arr);

双列集合：转换成单列集合后再创建。

Map.Entry 是 Map 接口的一个内部接口（类似内部类），用于表示 Map 中的一个键值对。它提供了以下主要方法：

  • getKey()：返回键。
  • getValue()：返回值。
  • setValue(V value)：修改当前键对应的值（需谨慎使用，可能影响 Map 的一致性）。

map.entrySet() 是获取 Map 中所有键值对的标准方式，它将 Map 转换为 Set<Map.Entry<K, V>>，便于遍历和处理。结合 Stream API，可以更高效地实现复杂的数据处理逻辑。

        Map<String,Integer> map = new HashMap<>();map.put("蜡笔小新",19);map.put("黑子",17);map.put("日向翔阳",16);Set<Map.Entry<String, Integer>> entries = map.entrySet();Stream<Map.Entry<String, Integer>> stream = entries.stream();

4.2,中间操作

filter

​ 可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中。

Stream<T> filter(Predicate<? super T> predicate);

Stream<T> filter(Predicate<? super T> predicate) 是 Java Stream API 中用于过滤元素的核心方法。

例如：

​ 打印所有姓名长度大于1的作家的姓名

List<Author> authors = getAuthors();
authors.stream().filter(author -> author.getName().length()>1).forEach(author -> System.out.println(author.getName()));

map

​ 可以把对流中的元素进行计算或转换。

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

例如：

​ 打印所有作家的姓名

List<Author> authorList = getAuthors();
List<String> collect = authorList.stream().distinct().map(author -> author.getName()).collect(Collectors.toList());

distinct

​ 可以去除流中的重复元素。

例如：

​ 打印所有作家的姓名，并且要求其中不能有重复元素。

List<Author> authors = getAuthors();
authors.stream().distinct().forEach(author -> System.out.println(author.getName()));

sorted

​ 可以对流中的元素进行排序。

Stream<T> sorted(Comparator<? super T> comparator);

例如：

​ 对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。

List<Author> authors = getAuthors();
//对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。
authors.stream().distinct().sorted((o1, o2) -> o2.getAge()-o1.getAge()).forEach(author -> System.out.println(author.getAge()));

limit

​ 可以设置流的最大长度，超出的部分将被抛弃。

例如：

​ 对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素,然后打印其中年龄最大的两个作家的姓名。

List<Author> authors = getAuthors();
authors.stream().distinct().sorted((o1, o2) -> o2.getAge()-o1.getAge()).limit(2).forEach(author -> System.out.println(author.getName()));

skip

​ 跳过流中的前n个元素，返回剩下的元素

例如：

​ 打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。

//打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。
List<Author> authors = getAuthors();
authors.stream().distinct().sorted((o1, o2) -> o2.getAge()-o1.getAge()).skip(1).forEach(author -> System.out.println(author.getName()));

flatMap

​ map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素。

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

例一：

​ 打印所有书籍的名字。要求对重复的元素进行去重。

//打印所有书籍的名字。要求对重复的元素进行去重。
List<Author> authors = getAuthors();authors.stream().flatMap(author -> author.getBooks().stream()).distinct().forEach(book -> System.out.println(book.getName()));

例二：

​ 打印现有数据的所有分类。要求对分类进行去重。不能出现这种格式：哲学,爱情

//打印现有数据的所有分类。要求对分类进行去重。不能出现这种格式：哲学,爱情     爱情
List<Author> authors = getAuthors();
authors.stream().flatMap(author -> author.getBooks().stream()).distinct().flatMap(book -> Arrays.stream(book.getCategory().split(","))).distinct().forEach(category-> System.out.println(category));

4.3,终结操作

forEach

​ 对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么具体操作。

void forEach(Consumer<? super T> action);

例子：

​ 输出所有作家的名字

//        输出所有作家的名字
List<Author> authors = getAuthors();authors.stream().map(author -> author.getName()).distinct().forEach(name-> System.out.println(name));

count

​ 可以用来获取当前流中元素的个数。

例子：

​ 打印这些作家的所出书籍的数目，注意删除重复元素。

//        打印这些作家的所出书籍的数目，注意删除重复元素。
List<Author> authors = getAuthors();long count = authors.stream().flatMap(author -> author.getBooks().stream()).distinct().count();
System.out.println(count);

max&min

​ 可以用来或者流中的最值。

Optional<T> max(Comparator<? super T> comparator);

例子：

​ 分别获取这些作家的所出书籍的最高分和最低分并打印。

//        分别获取这些作家的所出书籍的最高分和最低分并打印。//Stream<Author>  -> Stream<Book> ->Stream<Integer>  ->求值
List<Author> authors = getAuthors();
Optional<Integer> max = authors.stream().flatMap(author -> author.getBooks().stream()).map(book -> book.getScore()).max((score1, score2) -> score1 - score2);Optional<Integer> min = authors.stream().flatMap(author -> author.getBooks().stream()).map(book -> book.getScore()).min((score1, score2) -> score1 - score2);
System.out.println(max.get());
System.out.println(min.get());

为什么比较器相同？

对于数值类型（如 Integer），比较器 (s1, s2) -> s1 - s2 表示升序排序：

  • 若 s1 < s2，返回负数，s1 排在 s2 前面。
  • 若 s1 > s2，返回正数，s1 排在 s2 后面。

当 max() 使用这个比较器时，它会选择最后一个元素（即最大值）。
当 min() 使用这个比较器时，它会选择第一个元素（即最小值）。

collect

​ 把当前流转换成一个集合。

例子：

​ 获取一个存放所有作者名字的List集合。

//        获取一个存放所有作者名字的List集合。
List<Author> authors = getAuthors();
List<String> nameList = authors.stream().map(author -> author.getName()).collect(Collectors.toList());
System.out.println(nameList);

​ 获取一个所有书名的Set集合。

//        获取一个所有书名的Set集合。
List<Author> authors = getAuthors();
Set<Book> books = authors.stream().flatMap(author -> author.getBooks().stream()).collect(Collectors.toSet());System.out.println(books);

​ 获取一个Map集合，map的key为作者名，value为List

toMap（）方法要求传入两个函数型接口，第一个用来获取key，第二个用来获取value

public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,Function<? super T, ? extends U> valueMapper) {return toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
}

//        获取一个Map集合，map的key为作者名，value为List<Book>
List<Author> authors = getAuthors();Map<String, List<Book>> map = authors.stream().distinct().collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()));System.out.println(map);

查找与匹配

anyMatch

​ 可以用来判断是否有任意符合匹配条件的元素，结果为boolean类型。

例子：

​ 判断是否有年龄在29以上的作家

//        判断是否有年龄在29以上的作家
List<Author> authors = getAuthors();
boolean flag = authors.stream().anyMatch(author -> author.getAge() > 29);
System.out.println(flag);
allMatch

​ 可以用来判断是否都符合匹配条件，结果为boolean类型。如果都符合结果为true，否则结果为false。

例子：

​ 判断是否所有的作家都是成年人

//        判断是否所有的作家都是成年人
List<Author> authors = getAuthors();
boolean flag = authors.stream().allMatch(author -> author.getAge() >= 18);
System.out.println(flag);
noneMatch

​ 可以判断流中的元素是否都不符合匹配条件。如果都不符合结果为true，否则结果为false

例子：

​ 判断作家是否都没有超过100岁的。

//        判断作家是否都没有超过100岁的。
List<Author> authors = getAuthors();boolean b = authors.stream().noneMatch(author -> author.getAge() > 100);System.out.println(b);
findAny

​ 获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。

例子：

​ 获取任意一个年龄大于18的作家，如果存在就输出他的名字

//        获取任意一个年龄大于18的作家，如果存在就输出他的名字
List<Author> authors = getAuthors();
Optional<Author> optionalAuthor = authors.stream().filter(author -> author.getAge()>18).findAny();optionalAuthor.ifPresent(author -> System.out.println(author.getName()));
findFirst

​ 获取流中的第一个元素。

例子：

​ 获取一个年龄最小的作家，并输出他的姓名。

//        获取一个年龄最小的作家，并输出他的姓名。
List<Author> authors = getAuthors();
Optional<Author> first = authors.stream().sorted((o1, o2) -> o1.getAge() - o2.getAge()).findFirst();first.ifPresent(author -> System.out.println(author.getName()));

reduce归并

​ 对流中的数据按照你指定的计算方式计算出一个结果。（缩减操作）

​ reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和初始化值进行计算，计算结果再和后面的元素计算。

​ reduce两个参数的重载形式内部的计算方式如下：

T result = identity;
for (T element : this stream)result = accumulator.apply(result, element)
return result;

​ 其中identity就是我们可以通过方法参数传入的初始值，accumulator的apply具体进行什么计算也是我们通过方法参数来确定的。

例子：

​ 使用reduce求所有作者年龄的和

//        使用reduce求所有作者年龄的和
List<Author> authors = getAuthors();
Integer sum = authors.stream().distinct().map(author -> author.getAge()).reduce(0, (result, element) -> result + element);
System.out.println(sum);

​ 使用reduce求所有作者中年龄的最大值

//        使用reduce求所有作者中年龄的最大值
List<Author> authors = getAuthors();
Integer max = authors.stream().map(author -> author.getAge()).reduce(Integer.MIN_VALUE, (result, element) -> result < element ? element : result);System.out.println(max);

4.4,常用方法

  • negate：Predicate接口中的方法。negate方法相当于是在判断添加前面加了个! 表示取反
  • or：在使用Predicate接口时候可能需要进行判断条件的拼接。而or方法相当于是使用||来拼接两个判断条件。
  • and：在使用Predicate接口时候可能需要进行判断条件的拼接。而and方法相当于是使用&&来拼接两个判断条件
List<Author> authors = getAuthors();
authors.stream().filter(((Predicate<Author>) author -> author.getAge() > 17).or(author -> author.getName().length() < 2)).forEach(author -> System.out.println(author.getName()));
authors.stream().filter(((Predicate<Author>) author -> author.getAge() > 17).negate()).forEach(author -> System.out.println(author.getAge()));
authors.stream().filter(((Predicate<Author>) author -> author.getAge() > 17).and(author -> author.getName().length() > 1)).forEach(author -> System.out.println(author));

4.5,注意事项

  • 惰性求值（如果没有终结操作，没有中间操作是不会得到执行的）
  • 流是一次性的（一旦一个流对象经过一个终结操作后。这个流就不能再被使用）
  • 不会影响原数据（我们在流中可以多数据做很多处理。但是正常情况下是不会影响原来集合中的元素的。这往往也是我们期望的）

文章转载自：
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://.
http://www.dtcms.com/a/281481.html

相关文章：

  • 美图RoboNeo发布：一句话修图建站 | AI早报
  • Rembg开源项目全面解析：从原理到实践应用
  • 银河麒麟(Kylin) - V10 GFB高级服务器操作系统ARM64部署昇腾910b训练机以及Docker安装
  • AiPy+豆包：数据分析可视化，一键生成GUI工具
  • 复习笔记 39
  • 2025牛客暑期多校训练记录
  • 1688图片搜索逆向工程与多模态搜索融合实践——基于CLIP模型的特征向量检索优化
  • 4-Nodejs模块化
  • 倒计时熔断机制的出价逻辑
  • 入门华为人工智能，HCIA/HCIP/HCIE该怎么选？
  • 【kubernetes】--ConfigMap
  • slam中的eskf观测矩阵推导
  • 2025年最新香港站群服务器租用价格参考
  • 杭州轻创创业服务有限公司——以卓越品质赢得市场信赖
  • 【字节跳动】数据挖掘面试题0019：带货直播间推荐：现在有一个带货的直播间，怎么把它精准地推送给有需要的用户
  • IPD-流程设计-DT角色说明书参考模板
  • DeepSDF论文复现1---数据集生成2---原理解析
  • JVM——JVM由哪部分组成？
  • python+selenium UI自动化初探
  • 算法学习笔记：22.贪心算法之霍夫曼编码 ——从原理到实战，涵盖 LeetCode 与考研 408 例题
  • PHP连接MySQL数据库的多种方法及专业级错误处理指南
  • 乌邦图ubuntu20.04鱼香一键安装ros2（foxy）
  • 第一篇 - 常规过滤及分组汇总---轻量级文件存储提速查询
  • RabbitMQ消息队列
  • R语言安装包
  • 降本增效！自动化UI测试平台TestComplete并行测试亮点
  • 如何在 Shopify 上创建运输政策
  • 一、CV_图像分类简介
  • 基于图形渲染的鼠标增强工具技术浅析
  • 【相干、相参】 雷电名词溯源