Stream流

于 2024-05-30 00:49:06 发布
阅读量438 收藏 9
点赞数 3
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70851493/article/details/139306034
版权

他提供了一种处理集合和数组的方式，可以用于过滤、映射、排序、聚合等操作，使代码更加简洁、易懂。结合了lambda表达式，简化集合、数组的操作。

使用步骤：

1）先得到一条Stream流，并把数据放上去。

2）使用中间方法，对流水线上的数据进行操作。

3）使用终结方法对流水线上的数据进行操作。

中间方法：方法调用完毕之后，还可以调用其他方法。

终结方法：最后一步，调用完毕后，不能调用其他方法

获取Stream流方式：

1.单列集合

public class test {
    public static void main(String [] args) {
    	//创建单列集合
    	ArrayList<String> list=new ArrayList<>();
    	Collections.addAll(list, "a","b","c","d","e");
    	list.stream().forEach(s->System.out.println(s));//遍历
    	}
}

2.双列集合

public class test {
    public static void main(String [] args) {
    	//创建双列集合
    	HashMap<String, Integer> hm=new HashMap<>();
    	hm.put("a", 1);
    	hm.put("f", 3);
    	hm.put("d",5);
    	hm.put("s", 9);
    	//一种方法
    	hm.keySet().stream().forEach(s->System.out.println(s));
    	System.out.println("--------------");
    	//第二种方法
    	hm.entrySet().stream().forEach(t->System.out.println(t));
    	}
}

3.数组

public class test {
    public static void main(String [] args) {
    	//创建数组
    	String [] arr= {"a","b","c","d","t"};
    	Arrays.stream(arr).forEach(s->System.out.print(s));
    	}
}

4.一堆零散

public class test {
    public static void main(String [] args) {
    
    	Stream.of(1,2,3,4,5,6).forEach(s->System.out.println(s));
    }
}

 

Stream流中间方法

1.过滤（filter）

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","李四","张无忌","李若","张开账","荣天真");
    	list.stream().filter(s->s.startsWith("张"))
    	             .filter(s->s.length()==3)
    	             .forEach(s->System.out.println(s));
    }
}

 

2.获取前几个元素（limit）、跳过前几个元素（skip）

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","李四","张无忌","李若","张开账","荣天真");
    	list.stream().limit(3)
    	             .forEach(s->System.out.println(s));
    	
    }
}

 

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","李四","张无忌","李若","张开账","荣天真");
    	list.stream().skip(3)
    	             .forEach(s->System.out.println(s));
    	
    }
}

 

3.去重（distinct——依赖hashCode和equals方法，若为自定义对象，则要重写该方法）

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","张三","张三","李若","张开账","荣天真");
    	list.stream().distinct()
    	             .forEach(s->System.out.println(s));
    	
    }
}

4.合并a和b两个流为一个流（concat）

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","李若","张开账","荣天真");
    	
    	ArrayList<Integer>list1=new ArrayList<>();
    	Collections.addAll(list1, 1,2);
    	
    	Stream.concat(list.stream(), list1.stream()).forEach(s->System.out.println(s));
    	
    }
}

Stream流的终结方法

1.统计（count）

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","李若","张开账","荣天真");
    	
        long count=list.stream().count();
        System.out.println(count);
    }
}

2.收集流中的数据，放到集合中（toArray）

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三","李若","张开账","荣天真");
        //第一种方法
       Object[] arr1= list.stream().toArray();
       System.out.println(Arrays.toString(arr1));
       //第二种方法
       String [] arr2=list.stream().toArray( value-> new String[value]);
       System.out.println(Arrays.toString(arr2));
    }
}

3.收集流中的数据，放到集合中（list，set，map）

List:

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三-男-20","李若-女-21","张开账-男-19","荣天真-男-21");
        //收集List集合当中
    	//把所有的男性收集起来
         List<String> newlist=list.stream()
    	                          .filter(s->"男".equals(s.split("-")[1]))
    	                          .collect(Collectors.toList());
           System.out.println(newlist);
    }
}

 

Set:

其中还包含set与list之间的区别：

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三-男-20","张三-男-20","李若-女-21","张开账-男-19","荣天真-男-21");
    	//把所有的男性收集起来
         List<String> newlist=list.stream()
    	                          .filter(s->"男".equals(s.split("-")[1]))
    	                          .collect(Collectors.toList());
           System.out.println(newlist);
         
         Set<String> newSet=list.stream()
                 .filter(s->"男".equals(s.split("-")[1]))
                 .collect(Collectors.toSet());
             System.out.println(newSet);
         
    }
}

3.Map

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "张三-男-20","李若-女-21","张开账-男-19","荣天真-男-21");
        //收集Map集合当中
    	//将姓名作为键，年纪作为值
      Map<String, Integer> map= list.stream().collect(Collectors.toMap(
        		 s->s.split("-")[0] //键
        		 ,  
        		 s->Integer.parseInt(s.split("-")[2]) //值
    		  ));
         
         System.out.println(map);
    }
}

综合练习

1.数据过滤：定义一个集合，并添加一些整数1，2，3,4，5，6，7，8，9，10过滤奇数，只留下偶数。并将结果保存起来。

public class test {
    public static void main(String [] args) {
    
    	ArrayList<Integer>list=new ArrayList<>();
    	Collections.addAll(list, 1,2,3,4,5,6,7,8,9);
         List<Integer> l=list.stream().filter(s->s%2==0)
        		             .collect(Collectors.toList());
         System.out.print(l);
    }
}

2.创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄”zhangsan, 23"
“lisi, 24"
"wangwu, 25”
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值。

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list=new ArrayList<>();
    	Collections.addAll(list, "zhangsan,23","lisi,24","wangwu,25");
        Map<String, Integer> map=list.stream()
        		      .filter(s->(Integer.parseInt(s.split(",")[1])>=24))
                      .collect(Collectors.toMap(
                    		  s->s.split(",")[0]
                    		  ,
                    		  s->Integer.parseInt(s.split(",")[1])
                    		  ));
        
        System.out.println(map);
    }
}

3.现在有两个ArrayList集合，第一个集合中:存储6名男演员的名字和年龄。第二个集合中:存储6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如:张三，23
要求完成如下的操作:
1,男演员只要名字为3个字的前两人
2，女演员只要姓杨的，并且不要第一个
3,把过滤后的男演员姓名和女演员姓名合并到一起
4,将上一步的演员信息封装成Actor对象。（类型转换，用map方法）
5，将所有的演员对象都保存到List集合中。
备注:演员类Actor,属性只有一个: name, age
 

public class test {
    public static void main(String [] args) {
    
    	ArrayList<String>list1=new ArrayList<>();
    	Collections.addAll(list1, "张小寒,23","伍仟,24","吴谦,25","王军科,21","张函,25","李现,22");
        
    	ArrayList<String>list2=new ArrayList<>();
    	Collections.addAll(list2, "王晓鸥,21","杨小密,22","赵小刀,25","谢娜,23","杨晨诗,20","吴雨桐,26");
        Stream<String>s1=list1.stream()
    	      .filter(s->(s.split(",")[0]).length()==3)
    	      .limit(2);
        
        Stream<String>s2=list2.stream()
        		.filter(s->s.split(",")[0].startsWith("杨"))
                .skip(1);
        
      List<Actor>list=Stream.concat(s1, s2)
               .map(s-> new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1])))
               .collect(Collectors.toList());
        System.out.println(list);
    }
}

多喝烫水__
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java Stream流详解
唯有努力，方可自信！
06-10 2万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
stream流详解
weixin_45785893的博客
11-17 2万+
Stream流 一 ：Stream流的介绍 stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果； stream不会改变数据源，通常情况下会产生一个新的集合； stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。 对stream操作分为终端操作和中间操作，那么这两者分别代表什么呢？ 终端操作：会消费流，这种操作会产生一个结果的，如果一个流被消费过了，那它就不能被重用的。 中间操作：中间操作会产生另一个流。因此中间操作可以用来创建执行一系列动作的管道。一个特别需要注意的点
Stream流详解
ss810540895的博客
08-05 3万+
stream流操作是Java 8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。............
Stream流的常用方法
DQ6667的博客
04-11 4万+
1、快速创建List List list = Stream.of("1", "2").collect(Collectors.toList()); 2、取对象的某一列 低效方式： List<String> userNameList = new ArrayList<>(); for (String) List<String> userNameList = list.stream().map(User::getName).collect(Collectors.toList(
Java - Stream流详解
weixin_73869209的博客
06-05 1万+
Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。Stream流的处理是惰性求值的，只有在执行终止操作时才会开始处理数据。
Stream流和Optional
qq_45888932的博客
02-19 2341
Stream流
Java之Stream流
nuist_NJUPT的博客
08-07 2481
本文主要介绍了Stream流，包括集合和数组的Stream流创建方式，List和Set集合直接使用stream()方法创建,Map集合间接使用stream()方法创建，而数组使用Stream流的静态方法of()创建，介绍了Stream流的中间操作，包括过滤filter(),限制limit()和跳过skip()，拼接concat)(),去重distinct(),排序sorted()等，最后介绍了终结草族forEach()和count()，最后给出Stream流的收集操作和综合练习。......
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
Stream流常用方法
12-22
以下将详细介绍从标题和描述中提及的Stream流的常用方法： 1. **获取Stream流** - **从Collection获取**：所有实现了`Collection`接口的类（如`List`, `Set`, `Queue`等）都提供了`stream()`方法，用于将集合转换...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
stream流操作demo
01-14
- I/O流也可以转换为Stream，如`Files.lines()`。 3. **中间操作（Intermediate Operations）** - `filter(Predicate p)`: 过滤满足条件的元素。 - `map(Function f)`: 将每个元素转换为另一种类型。 - `...
Java中的stream流的概念解析及实际运用总结
09-02
Java中的Stream流是一种抽象的数据处理方式，它允许我们以声明性的方式处理数据集合。Stream API自Java 8引入，极大地提升了Java程序员处理数据的效率和代码的简洁性。Stream流与传统的集合操作不同，它并不直接修改...
Java中的Stream流
12-22
1.Stream流  Stream流完全不是I/O流，而是按照流水线处理方式来考虑代码中的思想。  JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直达重点，可以提高效率。  Stream流中使用了大量...
java Stream流
12-22
Java Stream流是Java 8及以后版本引入的一个重要特性，它为处理集合提供了新的方式，尤其是在函数式编程中。Stream不同于传统的输入输出流InputStream和OutputStream，它的主要目标是增强Java集合框架，提供一种高效...
stream 流方式
最新发布
04-25
stream流是Java中用于处理输入输出的一种方式。它提供了一种便捷的方式来读取和写入数据，可以用于处理文件、网络连接等各种输入输出操作。 stream流可以分为输入流和输出流两种类型。输入流用于从外部读取数据，输出流用于向外部写入数据。 常见的输入流包括： 1. FileInputStream：用于从文件中读取数据。 2. ByteArrayInputStream：用于从内存中的字节数组读取数据。 3. InputStreamReader：用于从字符流中读取数据。 常见的输出流包括： 1. FileOutputStream：用于向文件中写入数据。 2. ByteArrayOutputStream：用于向内存中的字节数组写入数据。 3. OutputStreamWriter：用于向字符流中写入数据。 使用stream流的一般步骤如下： 1. 创建相应的输入流或输出流对象。 2. 打开流，准备读取或写入数据。 3. 通过流对象提供的方法进行读取或写入操作。 4. 关闭流，释放资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值