StreamAPI与Optional类

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量106 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AHawkeye/article/details/117631756
版权

Stream API说明

在这里插入图片描述

为什么使用Stream API

在这里插入图片描述

什么是Stream

在这里插入图片描述

操作三步骤

在这里插入图片描述

创建Stream

方式一：集合

在这里插入图片描述

方式二：数组

在这里插入图片描述

方式三：Stream类的静态方法of()

在这里插入图片描述

方式四：创建无限流（了解）

在这里插入图片描述

package com.stream.xzc;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Test1 {
    @Test
    public void test1(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("A",20,1000));
        list.add(new Employee("B",15,2000));
        list.add(new Employee("C",20,3000));
        list.add(new Employee("D",15,500));
        //返回一个顺序流
        Stream<Employee> stream = list.stream();
        //返回一个并行流
        Stream<Employee> parallelStream = list.parallelStream();
    }

    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //Arrays静态方法返回一个流
        IntStream intStream = Arrays.stream(arr);

        Employee e1 = new Employee("E",20,1000);
        Employee e2 = new Employee("F",18,500);
        Employee[] arr2 = new Employee[]{e1,e2};
        Stream<Employee> employeeStream = Arrays.stream(arr2);

    }

    @Test
    public void test3(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
        
    }
}

Stream的中间操作

筛选与切片

在这里插入图片描述

package com.stream.xzc;

import org.junit.Test;

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

public class Test2 {
    @Test
    public void test1(){
        //filter
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("A",20,1000));
        list.add(new Employee("B",15,2000));
        list.add(new Employee("C",20,3000));
        list.add(new Employee("D",15,500));
        list.add(new Employee("E",20,2000));
        Stream<Employee> stream = list.stream();
        // forEach是终止操作，先拿来用，必须终止之后中间操作才有效果 forEach里面的consumer优先使用方法引用
        //stream.filter(e -> e.getSalary() > 1000).forEach(employee -> System.out.println(employee));
        stream.filter(e -> e.getSalary() > 1000).forEach(System.out::println);
        System.out.println("================");
        //此时stream已经被终止了 需要重新声明 只要前三个
        Stream<Employee> stream2 = list.stream();
        stream2.limit(3).forEach(System.out::println);
        System.out.println("================");
        //此时stream已经被终止了 需要重新声明 跳过前3个
        Stream<Employee> stream3 = list.stream();
        stream3.skip(3).forEach(System.out::println);
        System.out.println("================");
        //此时stream已经被终止了 需要重新声明 去重
        list.add(new Employee("F",20,1000));
        list.add(new Employee("F",20,1000));
        list.add(new Employee("F",20,1000));
        System.out.println("去重前");
        for (Employee e : list){
            System.out.println(e);
        }
        System.out.println("去重后");
        list.stream().distinct().forEach(System.out::println);
    }

}

Employee{name=‘B’, age=15, salary=2000}
Employee{name=‘C’, age=20, salary=3000}
Employee{name=‘E’, age=20, salary=2000}
================
Employee{name=‘A’, age=20, salary=1000}
Employee{name=‘B’, age=15, salary=2000}
Employee{name=‘C’, age=20, salary=3000}
================
Employee{name=‘D’, age=15, salary=500}
Employee{name=‘E’, age=20, salary=2000}
================
去重前
Employee{name=‘A’, age=20, salary=1000}
Employee{name=‘B’, age=15, salary=2000}
Employee{name=‘C’, age=20, salary=3000}
Employee{name=‘D’, age=15, salary=500}
Employee{name=‘E’, age=20, salary=2000}
Employee{name=‘F’, age=20, salary=1000}
Employee{name=‘F’, age=20, salary=1000}
Employee{name=‘F’, age=20, salary=1000}
去重后
Employee{name=‘A’, age=20, salary=1000}
Employee{name=‘B’, age=15, salary=2000}
Employee{name=‘C’, age=20, salary=3000}
Employee{name=‘D’, age=15, salary=500}
Employee{name=‘E’, age=20, salary=2000}
Employee{name=‘F’, age=20, salary=1000}

Stream的中间操作

映射

在这里插入图片描述
考察flatmap先考察这个
在这里插入图片描述
在这里插入图片描述
那么map就类似add，flagmap就类似addAll。

package com.stream.xzc;

import org.junit.Test;

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

public class Test3 {
    @Test
    public void test(){
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        //list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        list.stream().map(String::toUpperCase).forEach(System.out::println);
        System.out.println("========================================");
        //获取工资大于1000的员工的工资
        List<Employee> list2 = new ArrayList<>();
        list2.add(new Employee("A",20,1000));
        list2.add(new Employee("B",15,2000));
        list2.add(new Employee("C",20,3000));
        list2.add(new Employee("D",15,500));
        list2.add(new Employee("E",20,2000));
        Stream<Employee> stream = list2.stream();
        //employee的stream映射成integer的stream
        Stream<Integer> integerStream = stream.map(Employee::getSalary);
        integerStream.filter(s -> (s > 1000)).forEach(System.out::println);

        System.out.println("=======================================");
    }
    public static Stream<Character> stringToCharacterStream(String s){
        ArrayList<Character> list = new ArrayList<>();
        for (Character c: s.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }
    @Test
    public void test2(){
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        //list中一个元素返回一个stream
        Stream<Stream<Character>> streamStream = list.stream().map(Test3::stringToCharacterStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
        System.out.println("==================================");
        Stream<Character> characterStream = list.stream().flatMap(Test3::stringToCharacterStream);
        characterStream.forEach(System.out::println);

    }
}

在这里插入图片描述
在这里插入图片描述
map如果把流中的每一个元素映射成一个流，并返回一个由流构成的流，进行forEach就必须两层，一层lambda表达式，一层方法引用，此时可以用flatMap把里面的流打开，形成一对多的映射，返回一个一层流。

Stream的中间操作

排序

在这里插入图片描述

package com.stream.xzc;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;


public class Test4 {
    @Test
    public void test(){
        List<Integer> list1 = Arrays.asList(123, 434, 54, 12, 1223, 50, 0);
        list1.stream().sorted().forEach(System.out::println);

        List<Employee> list = new ArrayList<>();
        list.add(new Employee("A",20,1000));
        list.add(new Employee("B",15,2000));
        list.add(new Employee("C",20,3000));
        list.add(new Employee("D",15,500));
        list.add(new Employee("E",20,2000));
        list.stream().sorted(Comparator.comparingInt(Employee::getSalary).thenComparing(Employee::getAge)).forEach(System.out::println);

    }
}

在这里插入图片描述

Stream的终止操作

匹配与查找

在这里插入图片描述
在这里插入图片描述

package com.stream.xzc;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

public class Test5 {
    @Test
    public void test(){
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("A",20,1000));
        list.add(new Employee("B",15,2000));
        list.add(new Employee("C",20,3000));
        list.add(new Employee("D",15,500));
        list.add(new Employee("E",20,2000));
        Stream<Employee> stream = list.stream();
        System.out.println(stream.allMatch(e -> e.getAge() > 18));
        Stream<Employee> stream1 = list.stream();
        System.out.println(stream1.anyMatch(e -> e.getSalary() >2000));
        Stream<Employee> stream2 = list.stream();
        System.out.println(stream2.noneMatch(e->e.getSalary() > 3000));
        Stream<Employee> stream3 = list.stream();
        Optional<Employee> first = stream3.findFirst();
        System.out.println(first);
        Stream<Employee> stream4 = list.stream();
        Optional<Employee> any = stream4.findAny();
        System.out.println(any);
        Stream<Employee> stream5 = list.stream();
        System.out.println(stream5.count());
        Stream<Employee> stream6 = list.stream();
        System.out.println(stream6.max(Comparator.comparingInt(Employee::getSalary)));
        Stream<Employee> stream7 = list.stream();
        System.out.println(stream7.min(Comparator.comparingInt(Employee::getSalary)));
    }
}

在这里插入图片描述

归约

在这里插入图片描述

package com.stream.xzc;

import org.junit.Test;

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

public class Test6 {
    @Test
    public void test(){
        List<Integer> list1 = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        //第一个参数初始值
        //System.out.println(list1.stream().reduce(0,(x,y)->x+y));
        System.out.println(list1.stream().reduce(0,Integer::sum));

        List<Employee> list = new ArrayList<>();
        list.add(new Employee("A",20,1000));
        list.add(new Employee("B",15,2000));
        list.add(new Employee("C",20,3000));
        list.add(new Employee("D",15,500));
        list.add(new Employee("E",20,2000));

        System.out.println(list.stream().map(Employee::getSalary).reduce(Integer::sum));
    }
}

在这里插入图片描述

收集

收集也就是流转集合
在这里插入图片描述
在这里插入图片描述

package com.stream.xzc;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Test7 {
    @Test
    public void test(){
        //查找工资大于1000的员工 结果返回一个List
        List<Employee> list = new ArrayList<>();
        list.add(new Employee("A",20,1000));
        list.add(new Employee("B",15,2000));
        list.add(new Employee("C",20,3000));
        list.add(new Employee("D",15,500));
        list.add(new Employee("E",20,2000));

        List<Employee> collect = list.stream().filter(e -> e.getSalary() > 1000).collect(Collectors.toList());
        System.out.println(collect);
    }
}

在这里插入图片描述

Optional类

在这里插入图片描述
在这里插入图片描述

package com.optional.xzc;
import com.stream.xzc.Employee;

import java.util.Optional;

public class Test {
    @org.junit.Test
    public void test(){
        Employee e = new Employee("hawkeye",10,1000);
        Optional<Employee> o = Optional.of(e);
        System.out.println(o);
        Employee e1 = null;
        Optional<Employee> o1 = Optional.ofNullable(e1);
        System.out.println(o1);
        Optional<Employee> o2 = Optional.empty();
        System.out.println(o2);
    }
}

在这里插入图片描述

Optional使用举例

新建一个Dog类和一个Person类
在这里插入图片描述
在这里插入图片描述
不用Optional类时，我们这样通过Person获得Dog的名字

public String getDogName(Person p){
        if(p!=null){
            Dog d = p.getDog();
            if(d!=null){
                return d.getName();
            }
        }
        return null;
    }

先看一下orElse方法的作用，形参就是一个备胎。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package com.optional.xzc;


import org.junit.Test;

import java.util.Optional;

public class Test2 {
    @Test
    public void test(){
        Person p1 = new Person("p1",new Dog());
        Person p2 = null;
        Person p3 = new Person("p3",new Dog("p3's dog"));
        Person p4 = new Person("p4",null);
        System.out.println(getDogName(p1));
        System.out.println(getDogName(p2));
        System.out.println(getDogName(p3));
        System.out.println(getDogName(p4));
    }
    public static String getDogName(Person p){
        Optional<Person> optionalPerson = Optional.ofNullable(p);
        Person hawkeye = optionalPerson.orElse(new Person("Hawkeye", new Dog("Hawkeye's dog")));
        Optional<Dog> optionalDog = Optional.ofNullable(hawkeye.getDog());
        Dog dog = optionalDog.orElse(new Dog("绝对非空的dog"));
        return dog.getName();
    }



}

在这里插入图片描述

p1人存在，也有狗，只不过狗是空参构造，所以没名字
p2人不存在，给了一个备胎 hawkeye，他有狗
p3人存在，也有狗，狗有名字
p4人存在，但狗指定为null，即不存在，走到了最后一层。
这里主要是注意使用orElse方法，使用get方法会抛异常。
get可以和of方法搭配，orElse和ofNullable搭配。
当然也可以用isPresent先判断是不是空。

AHawkeye
关注
专栏目录
java8使用Stream API方法总结
08-26
3. 通过 Stream 类中的静态方法 of() 创建 Stream ```java Stream<String> stream = Stream.of("aa", "bb", "cc"); ``` 4. 通过 Stream 的 iterate() 方法创建无限流 ```java Stream<Integer> integerStream = ...
Stream/Optional常用方法
晴转多云的博客
10-11 184
Stream流：创建动态list，可以添加元素。foreach：用于遍历，会中断流操作；
java8：创建Stream及常用API和Optional类
yubin1285570923的博客
08-14 1087
一、四种创建Stream方式 1. Collection 提供了两个方法 stream() 与 parallelStream() List<String> list = new ArrayList<>(); Stream<String> stream = list.stream();//获取一个顺序流 Stream<String&...
重学Java8新特性(二) : Stream API、Optional类
Guizy
08-05 853
重学Java8新特性(二) : Stream API, Optional介绍
JDK8新特性 - Stream API及Optional类
江南烟雨却痴缠丶
04-29 769
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。 Stream是什么 它是数据渠道，用于操作数据源（集...
Java - Stream API 和 Optional 类的介绍
平凡小智
04-12 1162
Java 8中的新特性Stream API 优点： 1. 便于并行 2. 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。 相比于串行的流，并行的流可以很大程度上提高程序的执行效率。 3. Java 8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API可以声明性地 通过parallel()与sequential()在并行流与顺序流之间进行切换。 1.强大的Stream API Java8 中有两个最为重要的改变。第一个是Lambda表达式；另外一个.
Java 8 Stream Api 中的 map和 flatMap 操作方法
08-25
另外，map 和 flatMap 操作不仅可以在 Stream Api 中使用，也可以在 Optional<T> 中使用，作用都差不多。 map 和 flatMap 操作是 Java 8 Stream Api 中两个非常有用的操作方法，掌握这两个操作方法可以帮助开发者更...
深入探索 Java 8 Stream API 的 Collectors.maxBy() 方法
09-15
在 Java 8 引入的 Stream API 中，Collectors 类提供了多种强大的工具，用于处理集合数据。其中，Collectors.maxBy() 方法尤其引人注目，因为它允许开发者以声明式的方式轻松找到流中的最大元素。本文将深入探讨 ...
深入探讨 Java 8 Stream API 的 Collectors.minBy() 方法
09-15
在 Java 8 引入的 Stream API 中，java.util.stream.Collectors.minBy() 方法是一个强大的工具，用于在集合操作中找到流中按照指定比较器最小的元素。与 maxBy() 方法相对应，minBy() 提供了一种声明式的方式来确定...
Java8中Lambda表达式使用和Stream API详解
08-26
其中，Lambda表达式和Stream API是两个核心的改进。在这篇文章中，我们将深入探讨这两个特性，并通过实例来理解它们的用法。 首先，Lambda表达式是Java8中的一个革命性变化，它允许开发者以一种更简洁、更易读的...
Day.36 Java 8新特性: Stream API、Optional 类
a111042555的博客
03-15 1647
JavaSE基础 Stream API
Java8新特性——StreamAPI(一)
热门推荐
大闲人柴毛毛
08-28 9万+
1. 流的基本概念1.1 什么是流？流是Java8引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集合，它就像SQL语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你，无需我们自己手写代码。因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它
Java8 Stream API介绍
weixin_34029949的博客
09-01 344
Stream API是Java8中处理集合的关键组件，提供了各种丰富的函数式操作。 Stream的创建 任何集合都可以转换为Stream： //数组 String[] strArr = new String[]{"aa","bb","cc"}; Stream<String> stre...
实例理解Java8新特性中Stream API和Optional类的使用
Duktig的博客
06-21 1456
在学习Java8新特性中Stream API和Optional类的时候，发现学习的时候不系统，用的时候总是忘记怎么去使用。所以总结一些实例，便于理解其使用。 实例理解Java8新特性中Stream API和Optional类的使用
Java8新特性——————Stream API和Optional类
qq_2533491534的博客
02-21 245
Stream API 1，Stream API的理解： ①，Stream关注的是对数据的运算，与CPU打交道。集合关注的是数据的储存，与内存打交道 ②，java8提供了一套api，使用这套api可以对内存中的数据进行过滤，排序，映射，归约等操作。类似于sql对数据库中表的相关操作。 2，注意点 ①，Stream 自己不会存储元素 ②，Stream 不会改变源对象。相反，他们会返回一个持有结果的新S...
服务器虚拟化
最新发布
Hellc007的博客
10-30 381
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 953
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 445
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Java Web开发教程：从入门到精通
孤客科技
10-25 1087
Java Web开发是一个充满挑战和机遇的领域。通过本文的学习，您应已掌握Java Web开发的基础知识和实践技巧。不断实践、深入学习，将使您在这个领域越走越远。希望您能在未来的开发旅程中创造出更多精彩的Web应用！如有任何问题或想法，欢迎在评论区留言讨论！期待您的参与与分享！
Stream与Optional API 详解
06-09
Stream和Optional是Java 8中新增的API，它们为我们处理数据提供了更加便捷、高效的方式。 Stream是一种流式处理的API，它可以对集合、数组等数据源进行操作，如过滤、映射、排序、去重等操作，最终返回一个结果。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值