stream流

最新推荐文章于 2025-06-10 22:38:01 发布

一点都不萌

最新推荐文章于 2025-06-10 22:38:01 发布

阅读量181

点赞数

文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_43405620/article/details/109015271

版权

stream流比传统的集合遍历方式代码更加简化
以下为传统方式：

package stream;

import java.util.ArrayList;
import java.util.List;
/*
 以下对集合中的元素进行了三次遍历
 一共三个循环，每个循环的作用不一样。
 我们对集合的元素进行操作的时候，总是需要进行循环。
但是循环不是我们的目的，我们的目的是输出结果

 */
public class TraditionalList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一个List集合，存储姓名
		List<String> list = new ArrayList<>();
		list.add("张莹莹");
		list.add("周莹莹");
		list.add("张莹");
		list.add("陈莹");
		list.add("张问问");

		//对list集合中的元素进行过滤，只要以张开头的元素存储到一个新的集合中
		List<String> list1 = new ArrayList<>();
		for(String s : list) {
			if(s.startsWith("张")) {
				list1.add(s);
			}
		}
		
		//对list1集合进行过滤，只要姓名长度为3的人，存储到一个新集合中
		List<String> list2 = new ArrayList<>();
		for(String s : list1) {
			if(s.length()==3) {
				list2.add(s);
			}
		}
		//遍历筛选完后的list2集合并打印
		for(String s:list2) {
			System.out.println(s);
		}
	}

}

使用stream流后（注意.filter后面若连续条件则不加分号）：

package stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class StreamDemo1 {
/*
 *  * Stream可以简化我们的过程，stream流是JDK1.8之后出现的，
 * 关注的是做什么，而不是怎么做。
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一个List集合，存储姓名
		List<String> list = new ArrayList<>();
		list.add("张莹莹");
		list.add("周莹莹");
		list.add("张莹");
		list.add("陈莹");
		list.add("张问问");
		list.stream()
		.filter(new Predicate<String>() {

			@Override
			public boolean test(String name) {
				// TODO Auto-generated method stub
				return name.startsWith("张");
			}
			
		})
		.filter(new Predicate<String>() {

			@Override
			public boolean test(String name) {
				// TODO Auto-generated method stub
				return name.length()==3;
			}
			
		})
		.forEach(new Consumer<String>() {

			@Override
			public void accept(String name) {
				// TODO Auto-generated method stub
				System.out.println(name);
			}
			
		});
	}

}

使用Lambda表达式后：

package stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class StreamDemo1 {
/*
 *  * Stream可以简化我们的过程，stream流是JDK1.8之后出现的，
 * 关注的是做什么，而不是怎么做。
 */
	public static void main(String[] args) {
		//创建一个List集合，存储姓名
		List<String> list = new ArrayList<>();
		list.add("张莹莹");
		list.add("周莹莹");
		list.add("张莹");
		list.add("陈莹");
		list.add("张问问");

		list.stream()
		.filter(name->name.startsWith("张"))
		.filter(name->name.length()==3)
		.forEach(name->System.out.println(name));
	}

}

输出结果：
张莹莹
张问问

Filter()可以实现按条件对集合进行过滤。
注意stream流的创建方法。

以下场景：你是公司某个岗位的HR，收到了大量的简历，为了节约时间，现需按照一点规则过滤一下这些简历。比如要经常熬夜加班，所以只招收男性。

package stream;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;



//求职者的实体类
public class Person {
	private String name;//姓名
	private Integer age;//年龄
	private String gender;//性别
	//构造方法
	public Person(String name,Integer age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	//其他getter、setter方法略
	public void setGender(String gender) {
		this.gender = gender;
	}
	public String getGender() {
		return gender;
	}
	//重写toString()，方便观看结果
	public String toString() {
		return "Person{" +
				"name=" + name + '\'' +
				",age = " + age +
				",gender = " + gender +'\'' +
				"}";
	}
	
	public static void main(String[] args) {
		Collection<Person> collection = new ArrayList<>();
		collection.add(new Person("张莹莹",22,"女"));
		collection.add(new Person("张王五",22,"男"));
		collection.add(new Person("陈练",22,"男"));
		collection.add(new Person("张莹",22,"女"));
		collection.add(new Person("张偶",22,"女"));
		
		Stream<Person> personStream = collection.stream().filter(new Predicate<Person>() {

			@Override
			public boolean test(Person person) {
				return "男".contentEquals(person.getGender());//只保留男性
			}
			
		});
		collection = personStream.collect(Collectors.toList());//将Stream转化为list
		System.out.println(collection.toString());
	}
}

collect(toList())，在流中生成列表。
collect也就是收集器，是Stream一种通用的、从流生成复杂值的结构。只要将它传给collect方法，也就是所谓的转换方法，其就会生成想要的数据结构。

使用Lambda简化代码后：

		/*Stream<Person> personStream = collection.stream().filter(new Predicate<Person>() {

			@Override
			public boolean test(Person person) {
				// TODO Auto-generated method stub
				return "男".contentEquals(person.getGender());
			}
			
		});
		collection = personStream.collect(Collectors.toList());
		*/
		//使用Lambda表达式简化代码
		Stream<Person> personStream = collection.stream().filter(person->"男".equals(person.getGender()));
		collection = personStream.collect(Collectors.toList());
		System.out.println(collection.toString());

Stream流的常用创建方法：


		List<String> list = new ArrayList<>();
		Stream<String> stream = list.stream();

将数组转成Stream流

		Integer[] nums = new Integer[10];
		Stream<Integer> stream = Arrays.stream(nums);

使用Stream中的静态方法：of()

		String[] arr = {"ddd","ddddffff"};
		Stream<String> stream2 = Stream.of(arr);

也可以使用Arrays里的stream方法，将数组转换为流：

		String[] arr = {"ddd","ddddffff"};
		Stream<String> stream3 = Arrays.stream(arr);
		//或者:
		Integer[] nums = new Integer[2];
		Stream<Integer> stream4 = Arrays.stream(nums);

forEach是一个终结方法，遍历之后就不能继续调用stream流中的其他方法。

		
		Stream<String> stream = Stream.of("张单","李单","王单","辰单");
	//使用Stream流中的方法forEach对数据进行遍历
	/*	stream.forEach((String name)->{
			System.out.println(name);
		});*/
		//Lambda表达式简化代码：
		stream.forEach(name->System.out.println(name));
	}

stream流属于管道流，只能被消费（使用）一次，
第一个stream流调用完毕方法，数据就会流转到下一个stream上
所以第一个stream流就不能再调用方法了。

stream中的map方法可以将当前流中的T类型数据转换为R类型数据。
例如：需要将字符串类型的整数转换（映射）为Integer类型的整数

package stream;

import java.util.stream.Stream;

public class StreamMap {

	public static void main(String[] args) {
	
		Stream<String> stream = Stream.of("1","2","3");
		//使用map方法，把字符串类型的整数转换（映射）为Integer类型的整数
		Stream<Integer> stream2 = stream.map((String s)->Integer.parseInt(s)
		);
		//遍历
		stream2.forEach(i->System.out.println(i));
	}

}

stream中的count用于统计stream流中元素个数，是一个终结方法，不能在使用这个方法后再调用stream流中的其他方法。

package stream;

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

public class streamCount {

	public static void main(String[] args) {
		Collection<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		list.add(3);
		Stream<Integer> s = list.stream();
		long count =s.count();
		System.out.println(count);
	}
}