您的位置: 首页  >  文章  >  简单了解Stream流的操作

简单了解Stream流的操作

分类: 文章 • 2024-04-12 14:43:44

1.和for循环代码简单的对比

package com.xgg.stream.test;

import java.util.ArrayList;

/*
 * 1.ArrayList集合一道使用Stream流
 *   赵丽颖,98、刘亦菲,99、宋小宝,88、岳云鹏,90 
 *   我只要后面的数字按照int类型输出，并且大于90 的
 * 分析 java8 以前 
 * 1.自定义一个ArrayList，存放指定的若干个字符串
 * 2.我们只要后面的，那么就要分割字符串split，然后取用结果当中的一号元素
 * 3.根据字符串切割出来的"98"这些仍然是字符串，需要转换成int类型，Integer.parseInt();
 * 4.判断的到的集合中int类型是不是大于90
 * 5.对筛选之后的结果进行打印输出
 */
public class DemoStreamTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.声明一个集合存放数据
		ArrayList<String> list=new ArrayList<>();
		list.add("赵丽颖,98");
		list.add("鹿晗,95");
		list.add("宋小宝,87");
		//java 8 之前的操作
		javaBegin(list);
       //java 8之后 StreamApi 更优写法 filter代表过滤  map代表映射
		list.stream().map(x->x.split(",")[1]).map(Integer::parseInt)
		.filter(n->n>90).forEach(System.out::println);// 输出的还是98  95
	}

	private static void javaBegin(ArrayList<String> list) {
		
		//分割字符串
		ArrayList<String> scoreList=new ArrayList<>();
		for(int i=0;i<list.size();i++) {
			String record =list.get(i);
			String[] array=record.split(",");
			String score=array[1];
			scoreList.add(score);
		}
		//将String字符串转换成int
		ArrayList<Integer> intList =new ArrayList<>();
		for(int i=0;i<scoreList.size();i++) {
			String score=scoreList.get(i);
			int intScore=Integer.parseInt(score);
			intList.add(intScore);
		}
		//过滤小于90 的数据
		ArrayList<Integer> listOver =new ArrayList<>();
		for(int i=0;i<intList.size();i++) {
			int score=intList.get(i);
			if(score>90) {
				listOver.add(score);
			}
		}
		//便利数组打印出来
		for(int i=0;i<listOver.size();i++) {
			int score=listOver.get(i);
			System.out.println(score);//输出98 95
		}
	}

}

简单了解Stream流的操作

2.如何使用Stream流

   2.1 得到流

         根据集合获取流  集合名称.Stream()
         根据数组获取流   Stream.of(数组名称)

   2.2  map映射  map(用于转换的Lambda表达式)

   2.3 filter过滤   filter(能产生布尔结果的Lambda,如果参数Lambda是个true值，则留下这个元素,如果是false 则不要这个元素)

   2.4  forEach 遍历 forEach(Lambda表达式) 意思是对流当中的每一个元素进行操作

 

package com.xgg.stream.test;

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

/*
 * java8中的“流”其实就是Stream接口的对象
 * jdk提供了一个流接口java.unit.stream<T>
 * 
 * 如何获取流
 * 1.根据集合获取流  集合名称.Stream()
 * 2.根据数组获取流   Stream.of(数组名称)
 * 
 * 获取流之后可以使用映射方法map(用于转换的Lambda表达式)
 * 映射：就是将一个对象转换成另一个对象，把老对象映射到新对象上去
 * 
 * "95"  转换成为    95  将一个字符串转换成为一个int
 * 
 * 如果希望对流当中的数据进行过滤，可以使用过滤方法
 * filter(能产生布尔结果的Lambda,如果参数Lambda是个true值，则留下这个元素,如果是false 则不要这个元素)
 * 
 * 
 * 如果希望在流当中进行便利 使用 forEach(Lambda表达式)：意思是对流当中的每一个元素进行操作
 * 参数Lambda表达式必须是一个能够消费一个参数，而且不产生数据结果的Lambda
 * 
 *   x->System.out.println(x)
 *   
 *   System.out::println
 *   
 */
public class DemoGetStream {
	public static void main(String[] args) {
		 ArrayList<String> list=new ArrayList<>();
		 list.add("100");
		 list.add("200");
		 list.add("300");
		 //1.根据集合获取流
		 Stream <String> streamA=list.stream();
		 
		 //使用map映射 将字符串转换成为 数字
		 Stream <Integer> streamA1 =methodMap(streamA);
		 
		 //使用过滤 filter  过滤只要大于150 的数据
		 Stream <Integer> streamA2=methodFilter(streamA1) ;
		 //调用forEach
		 streamA2.forEach(System.out::println);//输出200,300
		 
		 //2.根据数组获取流 数组当中的元素必须是引用类型 (基本类型只能放包装类)
		 String [] array={"Hello","World","Today"};
		 Stream streamB=Stream.of(array);
		 

		 
		 
	}

	private static Stream<Integer> methodFilter(Stream<Integer> streamA1) {
		/*
		 * Stream<Integer> streamB=streamA1.filter((Integer num)->{ Boolean
		 * flag=num>150; return flag; });
		 */
		/*
		 * Stream<Integer> streamC=streamA1.filter( num->{ Boolean flag=num>150; return
		 * flag; });
		 */
		/*
		 * Stream<Integer> streamD=streamA1.filter( num->{ return num>150; });
		 */
		Stream<Integer> streamE=streamA1.filter( num-> num>150);
			
			
		
		return streamE;
	}

	private static  Stream <Integer> methodMap(Stream <String> streamA) {
		//映射括号内为Lambda表达式
		/*
		 * Stream<Integer> streamB=streamA.map((String x)->{ int
		 * result=Integer.parseInt(x); return result; } );
		 */
		//一个参数省略小括号
		/*
		 * Stream<Integer> streamC=streamA.map(x->{ int result=Integer.parseInt(x);
		 * return result; } );
		 */
		//方法体只有一句话省略大括号
		/*
		 * Stream<Integer> streamD=streamA.map(x->{ return Integer.parseInt(x); } );
		 */
		/*
		 * Stream<Integer> streamE=streamA.map(x-> Integer.parseInt(x) );
		 */
		//然后已经有现成的方法，使用方法引用  调用成员变量
		Stream<Integer> streamF=streamA.map( Integer::parseInt  );
	      return streamF;
	}
}

3.并发的Stream流

package com.xgg.stream.test;

import java.util.ArrayList;

/*
 * 流当中的元素如果特别多，那么只有一个人在逐一的处理，那么效率特别慢
 * 那么对流 当中的元素，使用多个人进行同时处理，这就是“并发”
 * 
 * 如何才能获取“并发流”(支持并发操作的流)
 * .parallelStream()
 * 
 * 注意事项
 * 1.使用并发流操作时，到底有几个人在进行同时操作呢？不用管，jdk自己处理
 * 2.如果正确使用，就不会出现多个人抢到一个元素的情况
 * 3.如果已经获取了一个普通的流，那么只要在调用一下parallel方法也会变成并发流
 * 
 */
public class DemoStreamConcurrent {

	public static void main(String[] args) {
		ArrayList<String> list =new ArrayList<>();
		for (int i=0;i<=100;i++) {
			list.add("Hello-"+i);
		}
        //这是一个普通的流 一个一个的操作 ，顺序不会乱 
		//list.stream().forEach(System.out::println);
		
		//并发流 多个人一起处理   顺序会乱
		//list.parallelStream().forEach(System.out::println);
		//普通流转换成并发流
		list.stream().parallel().forEach(System.out::println);
	}

}

 

相关推荐