JDK-1.8中Stream方法示例

布满荆棘的人生 2022-06-04 08:13 146阅读 0赞

流的操作分为两种，分别为中间操作 和 终端操作。

1.  中间操作  
    当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”。 中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线。
2.  终端操作  
    当所有的中间操作完成后，若要将数据从流水线上拿下来，则需要执行终端操作。 终端操作将返回一个执行结果，这就是你想要的数据。

使用流一共需要三步：

1.  准备一个数据流
2.  执行中间操作  
    中间操作可以有多个，它们可以串连起来形成流水线。
3.  执行终端操作  
    执行终端操作后本次流结束，你将获得一个执行结果

接下来我们讲解每个步骤的一些基本用法

1)准备数据流

1>集合

这里以常用的数据类型String举例,当然你也可以设置Integer,Long,Double,Object

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

2>数组

通过Arrays类提供的静态函数stream()获取数组的流对象：

String[] names = {"chaimm","peter","john"};
    Stream<String> stream = Arrays.stream(names);

3>值

通过Stream的静态方法of

Stream<String> stream = Stream.of("chaimm","peter","john");

4>文件

通过读取文件的方式获取

Stream<String> lines = Files.lines(Paths.get("F:\\logs\\xwan.log"),Charset.defaultCharset());
    			lines.forEach(System.out::println);

5>Stream默认

Stream<String> streamStr = Stream.empty();

2)中间操作

具体的结果我就不打印了,有不懂的可以Q我(![偷笑][titter.gif]大家一起进步),或者自行百度

数据初始化:

private static List<String> stringCollection = new ArrayList<>();
    	static {
    		stringCollection.add("ddd2");
    		stringCollection.add("aaa2");
    		stringCollection.add("bbb1");
    		stringCollection.add("aaa1");
    		stringCollection.add("bbb3");
    		stringCollection.add("ccc");
    		stringCollection.add("bbb2");
    		stringCollection.add("ddd1");
    	}

1>  filter过滤     通过lambda表达式筛选符合条件的值

@SuppressWarnings("unused")
    	private static void filter() {
    		stringCollection
    			.stream()
    			.filter((s) -> s.startsWith("a"))
    			.forEach(System.out::println);
    	}

2>sorted排序   默认为自然升序,也可以通过lambda表达式自定义

@SuppressWarnings("unused")
    	private static void sorted() {
    		stringCollection
    			.stream()
    			.filter((s) -> s.startsWith("a"))
    			.sorted()
                            //.sorted((a,b) -> a.compareTo(b))  -- 自定义
                            //.sorted(Comparator.reverseOrder()) -- 自然降序
                            //.sorted(Comparator.naturalOrder()) -- 自然升序
                           .forEach(System.out::println);
    	}

3>map  对流数据进行计算整理

@SuppressWarnings("unused")
    	private static void map() {
    		stringCollection
    			.stream()
    			.filter((s) -> s.startsWith("a"))
    			.map(String::toUpperCase)
    			.sorted()
    			.forEach(System.out::println);
    	}

4>flatMap

@SuppressWarnings("unused")
    	private static void flatMap() {
    		String[] strs = {"java8", "is", "easy", "to", "use"};  
    		List<String> distinctStrsByFlatMap = Arrays.stream(strs)  
                    .map(str -> str.split(""))  // 映射成为Stream<String[]>  
                    .flatMap(Arrays::stream)  // 扁平化为Stream<String>  
                    .distinct()  
                    .collect(Collectors.toList()); 
    		System.out.println(distinctStrsByFlatMap);
    		Stream.of(stringCollection.stream(), Arrays.stream(strs)) 
            .flatMap(Function.identity())  // 扁平化为Stream<String>
            .forEach(a -> {
            	System.out.println(a +"---->hahhaha");
            });
    	}

5>distinct   去重

@SuppressWarnings("unused")
    	private static void distinct() {
    		stringCollection
    			.stream()
    			.map((s) -> {
    				String result = s;
    				if(s.length()>3) {
    					result = s.substring(0, s.length()-1);
    				}
    				return result;
    			})
    			.distinct()
    			.forEach(System.out::println);
    	}

6>peek  和forEach的打印是有别的,前者可以理解为Debug模式或者内存模式,对用户最后结果是不透明的

@SuppressWarnings("unused")
    	private static void peek() {
    		stringCollection
    			.stream()
    			.peek(System.out::println)
    			.map(String::toUpperCase).count();
    	}

7>limit 和mysql数据库的分页很类似,去除前面几条数据

@SuppressWarnings("unused")
    	private static void limit() {
    		stringCollection
    			.stream()
    			.limit(2)
    			.map(String::toUpperCase)
    			.sorted()
    			.forEach(System.out::println);
    	}

8>skip 跳过前面几条数据,不包含前面几条数据

@SuppressWarnings("unused")
    	private static void skip() {
    		stringCollection
    			.stream()
    			.sorted()
    			.skip(2)
    			.map(String::toUpperCase)
    			.forEach(System.out::println);
    	}

9>iterate  迭代,类似与循环打印,如果不加入limit限制,会出现无线循环

@SuppressWarnings("unused")
    	private static void iterate() {
    		Stream.iterate(1, n -> n+2)-- 参数1:从什么数开始 n+2为增长基数2,例如结果:1,3,5,7,9
    		.limit(10)
    		.forEach(System.out::println);
    	}

10>generate  随机生成的意思,暂时就这么理解吧

@SuppressWarnings("unused")
    	private static void generate() {
    		Random b = new Random();
    		Stream.generate(() ->{
    			return b.nextInt(10);
    		})
    		.limit(10)
    		.forEach(System.out::println);
    	}

11>concat 流合并,流拼接,流整合,通俗点,![尴尬][awkward.gif]

@SuppressWarnings("unused")
    	private static void concat() {
    		Stream<Integer> intStream =Stream.of(1,2,3,4);
    		Stream<String> strStream =Stream.of("8","5","7");
    		Stream.concat(intStream,strStream)
    		.sorted((a,b) -> {
    			String a1 = String.valueOf(a);
    			String b1 = String.valueOf(b);
    			return b1.compareTo(a1);
    		})
    		.forEach(System.out::println);  
    		
    	}

3)最终操作

1>toArray  转换成数组流

@SuppressWarnings("unused")
    	private static void toArray() {
    		Object[] array = stringCollection
    			.stream()
    			.toArray();
    		Stream.of(array).forEach(System.out::println);
    	}

2>reduce 和大数据中的reduce有异曲同工之妙

@SuppressWarnings("unused")
    	private static void reduce() {
    		Optional<String> reduce = stringCollection
    			.stream()
    			.sorted()
    			.reduce((s1, s2) -> s1 + "#" + s2);
    		//如果存在,就输出值
    		//isPresent,存在返回true,不存在返回false
    		reduce.ifPresent(System.out::println);
    	}

3>anyMatch 有一些数据能匹配都返回true

@SuppressWarnings("unused")
    	private static void anyMatch() {
    		boolean flag = stringCollection
    			.stream()
    			.anyMatch((s) -> s.startsWith("a"));
    		System.out.println(flag);
    	}

4>allMatch  所有的数据都匹配才返回true

@SuppressWarnings("unused")
    	private static void allMatch() {
    		boolean flag = stringCollection
    			.stream()
    			.allMatch((s) -> s.startsWith("a"));
    		System.out.println(flag);
    	}

5>noneMatch   都不匹配就返回true

@SuppressWarnings("unused")
    	private static void noneMatch() {
    		boolean flag = stringCollection
    			.stream()
    			.filter((s) -> s.startsWith("b"))
    			.noneMatch((s) -> s.startsWith("a"));
    		System.out.println(flag);

6>count 返回满足条件数据的条数

@SuppressWarnings("unused")
    	private static void count() {
    		long count = stringCollection
    			.stream()
    			.filter((s) -> s.startsWith("a"))
    			.count();
    		System.out.println(count);
    	}

7>min  满足条件的最小数

@SuppressWarnings("unused")
    	private static void min() {
    		Optional<String> min = stringCollection
    			.stream()
    			.min((a,b) -> a.compareTo(b));
    		min.ifPresent(System.out::println);
    	}

8:>max 满足条件的最大数

@SuppressWarnings("unused")
    	private static void max() {
    		Optional<String> max = stringCollection
    			.stream()
    			.max((a,b) -> a.compareTo(b));
    		max.ifPresent(System.out::println);
    	}

9>findFirst 找到第一条满足条件的数据

@SuppressWarnings("unused")
    	private static void findFirst() {
    		Optional<String> max = stringCollection
    			.stream()
    			.findFirst();
    		max.ifPresent(System.out::println);
    	}

10>findAny  找到满足条件的任意一条数据(在并行流中,可能数据结果不一致)

@SuppressWarnings("unused")
    	private static void findAny() {
    		Optional<String> max = stringCollection
    			.stream()
    			//.filter(s -> s.startsWith("M"))
    			.findAny();
    		max.ifPresent(System.out::println);
    	}

11>collect 该功能比较强大,可以进行数据的二次整合,如返回list,返回count,返回平均数等

@SuppressWarnings("unused")
    	private static void collect() {
    		List<String> collect = stringCollection
    				.stream()
    				.filter(s -> s.startsWith("a"))
    				//.collect(Collectors.toList());
    				.collect(Collectors.toList());
    		System.out.println(collect);
    		long count = stringCollection
    				.stream()
    				.filter(s -> s.startsWith("a"))
    				.collect(Collectors.counting());
    		System.out.println(count);
    	}

[titter.gif]: /images/20220604/162c42026ba949ad9c0081e8fe979e53.png
[awkward.gif]: /images/20220604/b45b5bc795e64e7daa2597c5d5da77d8.png