折纸的不归路(26)

一.Optional类

java.util包
是用来解决空指针对象的空指针异常问题的
原始的处理手段:判断该对象是否为null来判断的
使用了Option类,允许将null值包装进该类中

1.如何创建Option类

该类没有构造方法,通过静态方法of和fuNullable来创建,of可以存放任何和类型的数据,但是不可以放null值,ofNullable也可以存放任何类型的数据,但是可以存放null值

2.如何使用Optional类

isPresent()

返回值为boolean类型,如果optional对象中有值,则返回值为true,可以通过get()方法获取,如果对象中值为null,则返回值为false

ifPresent(cosumer)

没有返回值,参数传递一个消费型函数式接口的实现,代表如果Optional对象中有值,则进行消费接口的逻辑,如果没有值,则不做任何操作

package jdk8day2;

import java.util.Optional;

public class OptionalTest {
	public static void main(String[] args) {
		// 创建
		Optional<String> op1 = Optional.of("hello");
		Optional<String> op2 = Optional.ofNullable(null);

		//使用
		//isPresent方法,判断op中是否有值
		//如果返回值为true,可以通过个体方法获得
		if(op1.isPresent()) {
			System.out.println(op1.get());
		}
		if(op2.isPresent()) {
			System.out.println(op2.get());
		}
		System.out.println("=========");
		
		//ifPresent方法,如果op容器中有值,则执行消费接口
		op1.ifPresent(s->System.out.println("op1_"+s));
		op2.ifPresent(s->System.out.println("op2_"+s));
		//op2没有值,不会输出
		System.out.println("=========");
		
		//orElse方法,如果op中有值,则返回值,如果没有值则返回默认值
		System.out.println(op1.orElse("op1的默认值"));
		System.out.println(op2.orElse("op2的默认值"));
		//op2无值,所以返回默认值
		System.out.println("=========");
		
		//orElseGet方法,与orElse获取值的方式不一样
		op1.orElseGet(()->"op1的第二个默认值");
		op2.orElseGet(()->"op2的第二个默认值");
		System.out.println("=========");
		
		//orElseThrow,如果为空就抛异常
		try {
			op1.orElseThrow(()->new Exception("asdasd"));
			op2.orElseThrow(Exception::new);
			//op2为空,抛出异常
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("=========");
		
		//map方法是做映射的
		//获取一下op中字符串的长度
		Optional<Integer> map1 = op1.map(s->s.length());
		Optional<Integer> map2 = op2.map(s->s.length());
		System.out.println(op1.isPresent());
		System.out.println(op2.isPresent());
		System.out.println("=========");
		
		//flatMap方法,和Map方法相似
		//但是要求Function参数中只可以返回Optional类型
		Optional<Integer> fm1 = op1.flatMap(
				s->Optional.of((s+"op1").length()));
		System.out.println(fm1.orElse(0));
		//op1在字符拼接后字符长度为8
		System.out.println("=========");
		
		//filter过滤
		String result = op1.filter(
				//此时op1值为hello,长度为5,如果判断数字大于5,
				//会输出默认值,如果小于5,会输出op1的值
				s->s.length()>2).orElse("op1最后一次默认");
		System.out.println(result);
		System.out.println("=========");
		
		//链式编程
		//需求
		int i = op1.filter(s->s.equals("hello"))//判断op1中是否含有hello
				.map(s->s.length())//获得op1的长度
				.filter(s->s>3)//判断op1的长度是否大于3,是的话输出op1的长度
				.orElse(10);//否则输出默认值10
		System.out.println(i);
		System.out.println("=========");
	}
}

二.Stream

java.util.stream.Stream
定义:应用在一组数据元素上一次执行的操作序列
主要作用:对于Collection集合功能的增强
中间操作:返回值为Stream对象的操作
最终操作:返回值为其他数据类型的对象的操作
数据源:数组,集合(Collection)

应用场景:
现在有一个List集合,我想对list集合中每个字符串进行验证,验证字符长度大于3的留下来,留下来的拼接上后缀,拼接完毕之后组合成一个字符串,中间用空格隔开,如果拼接成功返回该字符串,如果拼接失败返回另一个默认值

使用Stream可以用一行代码完成上述功能
如何创建一个Stream对象
通过数据来源创建对象
1.普通数据
2.数组
3.集合
提供了三个基本数据类型的Stream
IntStream 相当于 Stream<Integer>
不连续的数字创建用 IntStream.of(int值)
连续的数字创建可以用以下两个方法
range(x,y). ----> [x,y)
rangeClosed(x,y) ----->[x,y]
DoubleStream
LongStream

package jdk8day2;

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

public class StreamTest1 {
	public static void main(String[] args) {
		// 获得stream的对象
		// 普通对象
		Stream<String> stream1 = Stream.of("hello", "world", "tom");
		//数组对象
		String[] str = new String[] {"hello", "world", "tom"};
		Stream<String[]> stream2 = Stream.of(str,str);
		//通过集合去获得(经常使用的方式)
		List<String> list = Arrays.asList(str);
		Stream<String> stream3 = list.stream();
		Stream<List<Integer>> stream4 = Stream.of(
				Arrays.asList(1,2,3),
				Arrays.asList(4,5),
				Arrays.asList(6,7,8));
	}
}

Stream对象转为固定的数据类型

package jdk8day2;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest2 {
	public static void main(String[] args) {
		// Stream对象能不能转回来,通过最终操作转为固定的数据类型
		//先准备一个Stream
		Stream<String> stream = Stream.of("hello", "world", "tom");
		
//		// 1.转成数组toArray
//		String[] arr = stream.toArray(String[]::new);
//		System.out.println(Arrays.toString(arr));
//		
//		// 2.转成集合collect
		//转List
//		List<String> list1 = stream.collect(Collectors.toList());
//		List<String> list2 = stream.collect(Collectors.toCollection(LinkedList::new));
//		
//		//转Set
//		Set<String> set1 = stream.collect(Collectors.toSet());
//		Set<String> set2 = stream.collect(Collectors.toCollection(HashSet::new));
	
		// 3.转成字符串
		String str = stream.collect(Collectors.joining()).toString();
		System.out.println(str);
		//当执行了最终操作之后,该stream失效,所以
	}
}

例,将集合中所有元素变成大写:

package jdk8day2;

import java.util.*;

import java.util.stream.Stream;


public class StreamTest3 {
	public static void main(String[] args) {
		// 测试map操作,map操作是一个中间操作
		// map代表给集合中每一个元素进行映射,变成零为一个元素
		// 先准备一个Stream
		Stream<String> stream = Stream.of("hello", "world", "tom");
		//需求:把该集合中所有元素变成大写
//		Stream<String> s1 = stream.map(s->s.toUpperCase());
		Stream<String> s1 = stream.map(String::toUpperCase);//与上面等价
//		List<String> list = s1.collect(Collectors.toList());
//		list.forEach(System.out::println);
		//合并
//		stream.map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);
		//简化
		stream.map(String::toUpperCase).forEach(System.out::println);
		//forEach也是stream的方法
		
		
		
		//需求:对一列数字做平方操作
		Stream<Integer> stream2 = Stream.of(1,2,3,4,5);
		Stream<Integer> stream3 = stream2.map(s->s*s);
		stream3.forEach(System.out::println);
		
	}
}

三.心得

今天的内容在接受上来说感觉还可以,但是感觉自己在写代码过程中可能用不到这方面的内容,多的还是作为了解,能读懂程序.java基础的内容就要结束了,明天加油!