折纸的不归路(27)

最新推荐文章于 2024-09-19 13:19:42 发布

「已注销」

最新推荐文章于 2024-09-19 13:19:42 发布

阅读量144

点赞数

文章标签： java

本文链接：https://blog.csdn.net/lanaiwanqiQAQ/article/details/108269978

版权

一.stream补充

1.如何把Stream对象变为其他类型

a.变为数组类型toArray()
b.变为集合类型 collect

变为List Collectors.toList
变为Set Collectors.toSet
变为Collection Collectors.toCollection(对应的collection的实现类)

c.变为字符串类型 collector

 (Collectors.joining).toString

2.关于Stream的操作

当把一个数据结构包装成Stream后,就要开始对里面的元素进行各类操作了。
常见的操作可以归类如下。

Intermediate:中间操作
map (mapToInt, flatMap 等)、filter、distinct、sorted、
peek、limit、skip、parallel、sequential、unordered
Terminal: 最终操作
forEach、forEachOrdered、toArray、reduce、collect、min、
max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator
Short-circuiting: 短路操作
anyMatch、allMatch、noneMatch、findFirst、findAny、limit

中间操作

map/flatMap

把Stream中的每一个元素,映射成另外一个元素。

//转换大写
	Stream<String> stream = Stream.of("hello","world","tom");
	List<String> output = stream.
			 		map(String::toUpperCase).
				  	collect(Collectors.toList());

filter

filter 过滤对原始 Stream 进行某项测试,
通过测试的元素被留下来生成一个新 Stream。

peek

对每个元素执行操作并返回一个新的 Stream

limit/skip

		limit / skip
		//limit是取前5个
	list.stream().limit(5).forEach(System.out::println);
		//skip是跳过5个取后面的所有
		list.stream().skip(5).forEach(System.out::println);

最终操作

forEach：即是Stream的方法，也是Collection的方法

match:匹配

package jdk8day3;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest08 {
	public static void main(String[] args) {
		// 匹配match  最终操作
		
		
		List<String> list = Arrays.asList("test", "hello", "world", "java", "tom", "C", "javascript");
		Stream<String> stream = list.stream();
		
		//allmatch,必须所有的元素都匹配该条件,则返回true,否则返回false
//		boolean b1 = stream.allMatch(s->s.startsWith("j"));
//		System.out.println(b1);
		
		//anymatch
//		boolean b2 = stream.anyMatch(s->s.startsWith("j"));
//		System.out.println(b2);
		
		//nonematch
		boolean b3 = stream.noneMatch(s->s.startsWith("J"));
		System.out.println(b3);
		
	}
}

count:

package jdk8day3;

import java.util.*;

public class StreamTest09 {
	public static void main(String[] args) {
		// count 获得Stream种的元素个数   最终操作
		List<String> list = Arrays.asList("test", "hello", "world", "java", "tom", "C", "javascript");
		//先过滤,再排序,最后获得个数
		long count = 
		list.stream().filter(s->s.startsWith("j"))
		.sorted().peek(s->System.out.println("符合要求的结果:"+s))
		.count();
		System.out.println(count);
	}
}

reduce:

package jdk8day3;

import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.*;

public class StreamTest10 {
	public static void main(String[] args) {
		// reduce 规约合约 把多个元素通过规则合并成一个元素 最终操作
		// 计算1+2+3+4+5+6+7+8+9+10
		// Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
		IntStream intStream1 = IntStream.rangeClosed(1, 10);
		// 第一种用法:传递一个合并规则,返回值为对应的泛型的Optional对象
		System.out.println(intStream1.reduce((a, b) -> a + b).getAsInt());

		// 第二种用法:传递一个种子和一个合并规则返回一个泛型类型
		IntStream intStream2 = IntStream.rangeClosed(1, 10);
		int result = intStream2.reduce(0, (a, b) -> a + b);
		System.out.println(result);

		// 需求:多个字符串合并为一个字符串
		Stream<String> stream2 = Stream.of("A", "B", "C", "D");
		// ABCD
		String result1 = stream2.reduce((s1, s2) -> s1 + s2).get();
		// (s1,s2->s1+s2等价于)
		System.out.println(result1);
	}
}

4、Stream的一些静态方法

generate

package jdk8day3;

import java.util.stream.Stream;

public class StreamTest13 {
	public static void main(String[] args) {
//		Stream静态方法of,generate,iterator生产的对象都是Stream对象
		//静态方法generate 根据条件产生Stream对象,产生的数据是无限的
		//需要使用limit来限制
		//需求:生成100个随机数(100以内的)并由此创建出Stream实例
		Stream.generate(()-> (int)(Math.random()*100))
		.limit(100)
		.forEach(System.out::println);
		
		//静态方法 iterate 套娃 从种子开始,
		//上一个函数的结果作为下一个函数的参数
		//生成一个等差数列
		Stream.iterate(0,a->a+2)
		.forEach(System.out::println);
		
	}
}

iterate

package jdk8day3;

import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.*;

public class StreamTest10 {
	public static void main(String[] args) {
		// reduce 规约合约 把多个元素通过规则合并成一个元素 最终操作
		// 计算1+2+3+4+5+6+7+8+9+10
		// Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
		IntStream intStream1 = IntStream.rangeClosed(1, 10);
		// 第一种用法:传递一个合并规则,返回值为对应的泛型的Optional对象
		System.out.println(intStream1.reduce((a, b) -> a + b).getAsInt());

		// 第二种用法:传递一个种子和一个合并规则返回一个泛型类型
		IntStream intStream2 = IntStream.rangeClosed(1, 10);
		int result = intStream2.reduce(0, (a, b) -> a + b);
		System.out.println(result);

		// 需求:多个字符串合并为一个字符串
		Stream<String> stream2 = Stream.of("A", "B", "C", "D");
		// ABCD
		String result1 = stream2.reduce((s1, s2) -> s1 + s2).get();
		// (s1,s2->s1+s2等价于)
		System.out.println(result1);
	}
}

需求:
1.先调用stream方法
2.再排序,按照字符串的长度进行排序,长的在前短的再后
3.再过滤,字符串必须是以字符’j’开头的
4.再进行映射,把每个字符串后面拼接上"_briup"
5.再调用reduce进行合并数据,使用"|"连接字符串
6.最后返回Optional类型数据, 处理好的字符串数据就封装在这个对象中

public class StreamTest11 {
	public static void main(String[] args) {
		List<String> list = Arrays.asList("test", "hello", "javap","world", "java", "tom", "C", "javascript");
		//全部写成一行
		Optional<String> op =
		list.stream()
		.sorted((s1,s2)->s2.length()-s1.length())
		.filter(s->s.startsWith("j"))
		.map(s->s+"_briup")
		.reduce((s1,s2)->s1+"|"+s2);
		System.out.println(op.get());	
	}
}