Stream流和Optional

最新推荐文章于 2023-10-14 23:37:25 发布
最新推荐文章于 2023-10-14 23:37:25 发布
阅读量804 收藏 4
点赞数
分类专栏： 学习 文章标签： java 算法 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44675451/article/details/126439470
版权

一、Stream

1.获取Stream流

  1. 所有的 Collection 集合都可以通过 stream 默认方法获取流（顺序流）；
  2. 所有的 Collection 集合都可以通过parallelStream获取并行流
  3. Stream 接口的静态方法 of 可以获取数组对应的流。
  4. Arrays的静态方法stream也可以获取流

根据Collection获取流
Collection接口中有一个stream()方法,可以获取流 , default Stream stream():获取一个Stream流

通过List集合获取:
通过Set集合获取

  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<>();
	// ...
	}

根据Map获取流

使用所有键的集合来获取流
使用所有值的集合来获取流

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();
}

根据数组获取流

Stream接口,表示流,泛型T是用来限制流中元素的类型
Stream流中有一个static Stream of(T… values)
通过数组获取:
通过直接给多个数据的方式

    public static void main(String[] args) {
    //使用 Stream.of
	String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
	Stream<String> stream = Stream.of(array);
    
    //使用Arrays的静态方法
    Arrays.stream(array)
	}

Stream中方法可以分为两种：

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

1.forEach（终结方法）
遍历方法：

public static void main(String[] args) {
	Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
	stream.forEach(name‐> System.out.println(name));
}

2.过滤：filter

public static void main(String[] args) {

        //创建一个流
        Stream<String> stream = Stream.of("张三丰", "刘德华", "张国荣", "彭于晏", "纳什", "吴彦祖", "吴绮蓉");

        //对流中元素过滤,只要姓张的人
        Stream<String> stream2 = stream.filter(name -> {
            return name.startsWith("张");
        });
        
        //遍历过滤后的流
        stream2.forEach(name -> System.out.println(name));
    }

3.映射(转换)：map
将流中的元素映射到另一个流中

	@Test
    public void test(){

        //创建一个流，里面是字符串类型的整数
        Stream<String> stream1 = Stream.of("2", "32", "2", "33", "2");
        
        //把stream1流中的整数全部转成int类型
        Stream<Integer> stream2 = stream1.map((String s) -> {
            return Integer.parseInt(s);
        });

        //遍历
        stream2.forEach((i)-> System.out.println(i));

    }

4.统计个数：count（终结方法）
返回一个long值代表元素个数

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
	}
}

5.取用前几个（截取）：limit
对流进行截取，只取用前n个。参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作

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
	}
}

6.跳过前几个元素：skip
流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流.

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
	}
}

7.组合（合并流）：concat

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);
	}
}

8.映射(打开后再转换)：flatMap
内部传入一个Function函数式接口，跟map的区别就是这个会把流中的元素打开，再组合成一个新的流。

// map和flatMap的练习
public class StreamDemo {

    @Test
    public void test(){
        List<String> list = Arrays.asList("aa","bb","cc","dd");

        // 练习1 (map) 输出的全是大写
        list.stream().map(s -> s.toUpperCase()).forEach(System.out::println);
        System.out.println("----------");

        // 练习2（map）流里还有流，需要两个遍历才行看到里面内容
        Stream<Stream<Character>> streamStream = list.stream().map(StreamDemo::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });

        System.out.println("---------");
        // 练习3（flatMap）流里还有流，使用flatMap可以直接把里面的流打开，一次遍历就可以了
        Stream<Character> characterStream = list.stream().flatMap(StreamDemo::fromStringToStream);
        characterStream.forEach(System.out::println);
        
    }

    /**
     *  将字符串中的多个字符构成的集合转换为对应的stream
     * @param str
     * @return
     */
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList();
        // 将字符串转成字符数组，并遍历加入list集合
        for(Character c : str.toCharArray()){
            list.add(c);
        }
        // 返回list集合的stream流
        return list.stream();
    }
}

10.排序

	 /**
     * 排序的练习
     */
    @Test
    public void test2(){

        List<Integer> integers = List.of(124, 2, 15, 12, 51, -5, 5);
        // 按照自然排序
        integers.stream().sorted().forEach(System.out::println);

        System.out.println("---------");

        List<Integer> integers2 = List.of(124, 2, 15, 12, 51, -5, 5);
        // 定制排序(大到小)，需要传入Comparator接口（如果流中的是引用类型，只能用定制排序）
        // 简写：integers2.stream().sorted((e1,e2) -> e2-e1).forEach(System.out::println);
        integers2.stream().sorted((e1,e2) -> {
            return e2-e1;
        }).forEach(System.out::println);
    }

11…检测匹配（终结方法）：
返回一个Boolean值

是否全部匹配：allMatch

是否至少匹配一个：anyMatch

是否没有匹配的：noneMatch

	 /**
     * 匹配的练习
     */
    @Test
    public void test3(){
        List<Integer> integers = List.of(124, 2, 15, 12, 51, -5, 5);
        // 判断是否全部大于5
        boolean b = integers.stream().allMatch(i -> i > 5);
        // 结束输出false
        System.out.println(b);

        System.out.println("-------");

        List<Integer> integers2 = List.of(124, 2, 15, 12, 51, -5, 5);
        // 检测是否匹配至少一个元素
        boolean b1 = integers2.stream().anyMatch(i -> i > 5);
        // 输出true
        System.out.println(b1);

        System.out.println("-------");

        List<Integer> integers3 = List.of(124, 2, 15, 12, 51, -5, 5);
        // 检查是否没有匹配的元素
        boolean b2 = integers3.stream().noneMatch(i -> i > 1000);
        // 输出true，全部不匹配
        System.out.println(b2);
    }

12.查找元素
查找第一个元素：findFirst，返回Optional类型
查找其中一个元素：findAny，返回Optional类型

public void test4(){
        List<Integer> integers = List.of(124, 2, 15, 12, 51, -5, 5);
        // 输出第一个元素
        Optional<Integer> first = integers.stream().findFirst();
        // 输出结果是Optional[124]
        System.out.println(first);

        System.out.println("-------------");

        List<Integer> integers2 = List.of(124, 2, 15, 12, 51, -5, 5);
        // 返回其中一个元素
        Optional<Integer> any = integers2.stream().findAny();
        System.out.println(any);
    }

13.查找最大最小值（终结方法）

	 /**
     * 查找最大最小值
     */
    @Test
    public void test5(){
        List<Person> list = new ArrayList<>();
        list.add(new Person("马化腾",25,3000));
        list.add(new Person("李彦宏",27,2545));
        list.add(new Person("雷军",35,4515));
        list.add(new Person("马云",55,9877));

        //  查找年龄最大的人
        Optional<Person> max = list.stream().max((e1, e2) -> e1.getAge() - e2.getAge());
        // 返回马云，55岁年龄最大
        System.out.println(max.get());

        System.out.println("--------");

14.规约
是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
		// 求和方式1
		Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
		// 求和方式2
		Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
		// 求和方式3
		Integer sum3 = list.stream().reduce(0, Integer::sum);
		
		// 求乘积
		Optional<Integer> product = list.stream().reduce((x, y) -> x * y);

		// 求最大值方式1
		Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
		// 求最大值写法2
		Integer max2 = list.stream().reduce(1, Integer::max);

		System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
		System.out.println("list求积：" + product.get());
		System.out.println("list求和：" + max.get() + "," + max2);
	}
}

15.收集（终结方法）
将流转化为其他形式，接收一个Collector接口的实现
toList/toSet/toMap。
流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
		List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
		Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		
		Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
				.collect(Collectors.toMap(Person::getName, p -> p));
		System.out.println("toList:" + listNew);
		System.out.println("toSet:" + set);
		System.out.println("toMap:" + map);
	}
}

16.迭代：iterate
可以使用Stream.iterate创建流值，即所谓的无限流。

//Stream.iterate(initial value, next value)
	Stream.iterate(0, n -> n + 1)
                .limit(5)
                .forEach(x -> System.out.println(x));
0
1
2
3
4

二、Optional

Java8引入了Optional类来解决NullPointerException的问题。
在这里插入图片描述更多

qq_44675451
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解JAVA Stream流
08-18
Stream流不是一种数据结构，它也不是集合元素，而是一种算法和计算的方式，专门用于对集合对象进行各种便利、高效的聚合操作，或者大批量数据操作。 创建Stream流可以通过Collection.stream()函数创建一个Stream...
Java Stream 流的使用过程解析
08-25
Java Stream 流提供了多种筛选和切片方法，包括 filter、distinct、limit、skip 等。 * filter 方法：接受一个返回 boolean 的函数作为参数，用于筛选流中的元素。例如，筛选出 vegetarian 菜单的 Dish 对象：`List...
你认识强大的 Stream 和 Optional 吗？
热门推荐
sid10t.
11-10 3万+
文章目录前言Stream创建流操作流过滤映射匹配组合转换流完整实例 前言 早已仰慕 Stream 流久已，终于有机会彻底的了解其特性以及用法了，关于源码的深度理解可能还需要继续增加功底，在学 Stream 的时候，同时认识了强大的 Optional，奈斯！ 接下来的博文直接上用法了，想了解更多，建议阅读以下两篇博文： 一文带你入门Java Stream流，太强了 Java 8 Optional 最佳指南   Stream 流的操作可以分为两种类型： 1）中间操作，可以有多个，每次返回一个新的流，可
java 8 Stream,Optional的流库详解
weixin_46082526的博客
09-26 1768
java 8 的流库1.从迭代到流的操作1. Stream的两种 stream() | parallelStream()2. foreach()3. count()2.流的创建1. Stream.of(T... values)2. Stream.empty()3. Stream.generate()4. Stream.iterate()5. Stream.ofNullable(T)3.filter、map和flatMap方法1. filter()2. map()3. flatMap()4.抽取子流和组
JAVA中Optional和stream流入门
QQ563627436的博客
05-04 2707
JAVA中Optional和stream流入门
使用java8 新特性stream流对List＜Map＜String, Object＞＞集合进行遍历、过滤、查询、去重、排序、分组
MidYear的博客
07-14 1万+
对于一个List<Map<String, Object>>类型的数据，可以使用Java 8的新特性stream流来进行遍历、过滤、查询、去重、排序、分组等操作。
java maptolong,转换Map< String，NavigableMap< Long，Collection< String>>>列出< String...
weixin_30395941的博客
02-16 436
I am trying to convert Map>> into List Java 8.I wrote some code but got stuck some where in mid.userTopics.values().stream().map(new Function>, Collection>() {@Overridepublic Collection a...
java Stream 流使用
04-15
虽然Stream的语法可能在初看时显得复杂，但随着熟练度的提升，你会发现它提高了代码的简洁性和可读性，尤其在处理大量数据时，使用并行流可以显著提升性能。 要完全掌握Stream的使用，需要熟悉各种操作方法以及它们...
Java如何使用Optional与Stream取代if判空逻辑（JDK8以上）
08-25
主要给大家介绍了关于Java如何使用Optional与Stream取代if判空逻辑（JDK8以上）的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
shuffle-stream:随机播放流
07-08
用法 var shuffle = require ( 'shuffle-stream' ) , opts = { // Optional, default false. Set to true if not // pushing buffers or strings. objectMode : false // Optional, default 0. When greater than ...
java新特性stream与Optional
Da_ci_hua的博客
07-02 440
java8新特性，谁还不会stream流
Java函数式编程Stream.collect()方法使用小结
weixin_44729970的博客
11-23 2万+
steam():把一个源数据，可以是集合，数组，I/O channel， 产生器generator 等，转化成流。 Collectors(): 类实现了很多归约操作，例如将流转换成集合和聚合元素。通过stream().collect()方法可简单获得我们所需要的数据结构。 先创建一个prodList的集合数据 @Data public class Product { private Long id; private Integer num; private BigDecimal pr
Stream流&Optional
@GhostQinMo
03-29 316
StreamAPI介绍
java8实战读书笔记：数值流、Stream创建与Optional类的使用
中间件兴趣圈
06-02 1441
java8学习笔记目录： java8实战读书笔记：Lambda表达式语法与函数式编程接口 java8实战读书笔记：复合Lambda表达式 java8实战读书笔记：初识Stream、流的基本操作（流计算） 本节将详细介绍Java8中的数值流、流的创建与Optional类的使用。 本节目录1、数值流1.1 原始数据特化流1.1.1 映射到数据流1.1.2 转换回对象流1.1.3 常用函数2、构...
Optional 和 Stream
happyJared
07-31 1147
Optional Optional 不是函数式接口，而是用于防止 NullPointerException 的一个工具类。 Optional 是一个简单的容器，其值可能是 null 或者不是 null。在 Java8 之前，一般某个函数应该返回非空对象，但是有时却什么也没有返回，而在 Java8 中，你应该返回 Optional 而不是 null。 // ...
Arrays
weixin_43719015的博客
09-26 387
Arrays类常用方法解析 1. Arrays 类的定义 Arrays类位于 java.util 包中，主要包含了操纵数组的各种方法（都是静态的) 2. Arrays 类的常用方法 Arrays.asList(T… data) 注意：该方法返回的是 Arrays 内部静态类 ArrayList，而不是我们平常使用的 ArrayList,，该静态类 ArrayList 没有覆盖父类的 add...
使用流-Java8
抽象的螺旋
02-10 820
概述 流让你从外部迭代转向内部迭代。 实际上所有的元素只会迭代一次，只是在迭代每个元素时，元素会执行赋予的所有操作。 这种处理数据的方式很有用，因为你让Stream管理如何处理数据。这样Stream API就可以在背后进行多种优化。此外，使用内部迭代的话，Stream API可以决定并行运行你的代码。这要是用外部迭代的话就办不到了，因为你只能用单一线程挨个迭代。 在本章中，你将会看到Stream API支持的许多操作。这些操作能让你快速完成复杂的数据查询，如筛选、切片、映射、查找、匹配和规约。接下来，我们会
Arrays.Stream()和Stream.of()的区别分析
最新发布
qq_56979518的博客
10-14 460
在学习Stream的时候发现了一个问题，对于int类型的数组，在获取流的时候，使用 Stream.of() 的时候可以使用转成List类型集合，但是使用 Arrays.stream() 却会报错，这立马引起了我的好奇心，以下是研究过程。
【Java】Stream使用
zhangying_496的博客
08-10 1135
【java】Stream 使用
Stream流与optional
06-09
Stream流和Optional的关系： Stream和Optional都是Java 8中新增的特性，它们的使用可以大大简化代码，提高代码的可读性。Stream和Optional常常一起使用，例如对集合中的数据进行处理时，使用Stream来处理数据，使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值