002-JDK8流的使用

一、Optional 的使用

1.创建 Optional 实例

• 获取空对象 Optional.empty()

@Test(expected = NoSuchElementException.class)
public void getEmpty(){
   
    Optional<UserInfo> optional = Optional.empty();
    System.out.println("============="+optional.get());;
}

注意：获取变量 optional 会报 NoSuchElementException。

• 获取对象 Optional.of()

@Test(expected = NullPointerException.class)
public void getOf(){
   
    UserInfo userInfo = new UserInfo();
    UserInfo userInfo1 = null;
    Optional<UserInfo> opt = Optional.of(userInfo);
    System.out.println("============="+opt.get());
}

注意：如果是空对象，会直接报 NullPointerException；
如果有对象，会直接返回对象；
使用场景：如果需要有报出空指针异常需要，可以用这个。

• 获取对象 Optional.ofNullable()

@Test(expected = NoSuchElementException.class)
public void getOfNullable(){
   
    UserInfo userInfo = new UserInfo();
    UserInfo userInfo1 = null;
    Optional<UserInfo> opt = Optional.ofNullable(userInfo1);
    System.out.println("============="+opt.get());
}

注意：如果有对象，直接返回对象；
如果没有对象，会返回空对象，获取空对象会报 NoSuchElementException
使用场景：如果不需要报出空指针，可以使用这个得到一个空对象

2.访问 Optional 对象的值

• get() 方法

@Test
public void whenCreateOfNullableOptional_thenOk() {
   
    String name = "John";
    Optional<String> opt = Optional.ofNullable(name);
    System.out.println(opt.get());
}

使用场景：用于获取Optional里面的值

3.判断 Optional 里面的对象是否为空对象

• Optional.isPresent()

@Test
public void getIsPresent(){
   
    UserInfo userInfo1 = new UserInfo();
    UserInfo userInfo2 = null;
    Optional<UserInfo> optional = Optional.ofNullable(userInfo1);
    if(optional.isPresent()){
   
        System.out.println("========有对象：UserInfo========");
    }else {
   
        System.out.println("===========空对象：empty==========");
    }
}

注意：isPresent 返回一个 boolean值 ，用于判断 对象是否为空对象，更灵活一点。

• Optional.ifPresent(Object obj)

@Test
public void getIfPresent(){
   
    UserInfo userInfo1 = new UserInfo();
    UserInfo userInfo2 = null;
    Optional<UserInfo> optional = Optional.ofNullable(userInfo2);
    optional.ifPresent(userInfo -> {
   
        System.out.println("========有对象才执行的操作==========");
    });
}

注意：支持传入一个对象参数，如果不为空，则执行里面的 Lambda 表达式，否则，不执行里面的操作； 一般用于 如果对象存在就操作，如果不存在就跳过的场景。

4.返回默认值

• orElse()

@Test
public void getOrElseNull() {
   
    UserInfo userInfo1 = null;
    UserInfo userInfo2 = new UserInfo();
    UserInfo result = Optional.ofNullable(userInfo1).orElse(userInfo2);
    System.out.println("========result========="+result.toString());// userInfo2
}

@Test
public void getOrElse() {
   
    UserInfo userInfo1 = new UserInfo();
    userInfo1.setId(1l);
    UserInfo userInfo2 = new UserInfo();
    userInfo2.setId(2l);
    UserInfo result = Optional.ofNullable(userInfo1).orElse(userInfo2);
    System.out.println("========result========="+result.toString());// userInfo1
}

注意：如果有值则返回该值，否则返回传递给它的参数值。如果是空字符串，也是有对象；

• orElseGet()

@Test
public void getOrElseNull() {
   
    UserInfo userInfo1 = null;
    UserInfo userInfo2 = new UserInfo();
    UserInfo result = Optional.ofNullable(userInfo1).orElseGet(()->userInfo2);
    System.out.println("========result========="+result.toString());// userInfo2
}

@Test
public void getOrElse() {
   
    UserInfo userInfo1 = new UserInfo();
    userInfo1.setId(1l);
    UserInfo userInfo2 = new UserInfo();
    userInfo2.setId(2l);
    UserInfo result = Optional.ofNullable(userInfo1).orElseGet(()->userInfo2);
    System.out.println("========result========="+result.toString());// userInfo1
}

注意：orElseGet(()->object),里面是用Lambda表达式。

• orElse与orElseGet的区别

@Test
public void getOrElseGetDifference(){
   
    UserInfo userInfo1 = new UserInfo();
    UserInfo result1 = Optional.ofNullable(userInfo1).orElse(createNewUser("result1"));
    System.out.println("========result1========="+result1.toString());// userInfo1

    UserInfo result2 = Optional.ofNullable(userInfo1).orElseGet(()->createNewUser("result2"));
    System.out.println("========result2========="+result2.toString());// userInfo1
}

private UserInfo createNewUser(String str){
   
    System.out.println("============"+str+"创建新对象了============");
    return new UserInfo();
}

// 结果如下：
// ============result1创建新对象了======
// ========result1=========
// ========result2=========

注意：两者结果差不多，区别在于如果对象存在的情况下，orElse 里面的方法依然会执行，orElseGet里面的方法不会执行；
在执行较密集的调用时，比如调用 Web 服务或数据查询，这个差异会对性能产生重大影响；
优先选用 orElseGet。

• orElseThrow

@Test(expected = IllegalArgumentException.class)
public void getOrElseGetThrow() {
   
    UserInfo userInfo1 = new UserInfo();
    UserInfo userInfo2 = null;
    UserInfo result1 = Optional.ofNullable(userInfo1).orElseThrow(IllegalArgumentException::new);
    System.out.println("========result1========="+result1.toString());// userInfo1
}

注意：如果对象为null，抛出 IllegalArgumentException 异常，而不再是 空指针

5.转换值

• map()

@Test()
public void getMap() {
   
    UserInfo userInfo = new UserInfo();
    userInfo.setUserName("xiaogang");
    String userName = Optional.ofNullable(userInfo)
            .map(UserInfo::getUserName).orElse("xiaoming");
    System.out.println("========userName========="+userName);// userInfo1
}

注意：map()只支持传入对象属性。

• flatMap()

@Test()
public void getFlatMap() {
   
    UserInfo userInfo = new UserInfo();
    userInfo.setUserName("xiaogang");
    userInfo.setUserCode("111");
    String userName = Optional.ofNullable(userInfo)
            .flatMap(UserInfo::getPosition).orElse("xiaoming");
    System.out.println("========userName========="+userName);// userInfo1
}

public class UserInfo extends Model<UserInfo> {
   
    public Optional<String> getPosition() {
   
        return Optional.ofNullable(userCode);
    }
}

注意：flatMap()只支持传入方法。

6.过滤值

• filter

@Test()
public void getFilter() {
   
    UserInfo userInfo = new UserInfo();
    userInfo.setUserName("xiaogang");
    Optional<UserInfo> result = Optional.ofNullable(userInfo)
            .filter(u->StringUtils.isNotBlank(u.getUserName()) && Objects.equals("xiaogang",u.getUserName()));
    System.out.println("========result========="+result);// userInfo1
}

注意：支持传入过滤条件，刷选出指定条件的对象。

二、Stream 流的使用

1.Filter：筛选

	@Test
    public void test1() {
   
        List<TestEntity> list = new ArrayList<>();
        list.add(new TestEntity("张三", 20));
        list.add(new TestEntity("李四", 30));
        List<TestEntity> filterList = list.stream().filter(a -> a.getName().equals("张三")).collect(Collectors.toList());
        System.out.println(filterList);// [TestEntity(name=张三, age=20, address=武汉)]
    }

2.Map：映射

用法：把集合每个元素重新映射，元素个数不变，但是元素值发生了变化
mapToInt：映射（mapToLong/mapToDouble 用法类似）
用法：将流中的元素映射为一个IntStream

	@Test
    public void test2() {
   
        // 用法一：字符串数组转整型集合
        List<Integer> b = Arrays.stream("1,2,3".split(",")).map(s -> Integer.parseInt(s.trim())).collect(Collectors.toList());
        System.out.println(b);// [1, 2, 3]

        // 用法二：获取集合对象中的某个字段集合
        List<TestEntity> list = new ArrayList<>();
        list.add(new TestEntity("张三", 20));
        list.add(new TestEntity("李四", 30));
        List<Integer> list1 = list.stream().map(TestEntity::getAge).collect(Collectors.toList());
        System.out.println(list1);// [20, 30]
    }
    
	@Test
    public void test3() {
   
        // 假设有一个包含整数的列表，我们想把每个整数乘以2
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        IntStream intStream = numbers.stream().mapToInt(num ->