折纸的不归路(27)

一.stream补充

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

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

  1. 变为List Collectors.toList
  2. 变为Set Collectors.toSet
  3. 变为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());	
	}
}

二.心得

今天主要内容还是java8的新特性,主要是stream流的相关方法使用,也逐渐对lambda表达式和方法的引用的写法更熟悉了,没有一开始那么陌生了,马上java的基础学习阶段就要结束了,即将开始下一步的学习,加油吧!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值