Java8 StreamAPI和Optional

/**
 * 一、Stream的三个操作步骤
 * <p>
 * 1. 创建Stream. 2. 中间操作 3. 终止操作
 */
// 创建Stream
// 1. 可以通过collection系列集合的stream或parallelStream
    List<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream();

    // 2. 通过Arrays中的静态方法stream()获取数组流
    Employee[] emps = new Employee[10];
    Stream<Employee> stream2 = Arrays.stream(emps);

    // 3. 通过Stream类中的静态方法of()
    Stream<String> stream3 = Stream.of("aa", "bb", "cc");

    // 4. 创建无限流
    // 迭代
    Stream<Integer> stream4 = Stream.iterate(0, x -> x + 2);
    stream4.limit(10).forEach(System.out::println);
    // 生成
    Stream.generate(() -> Math.random());
// 中间操作
/**
   *
   * 排序
   * sorted() - 自然排序
   * sorted(Comparator com) - 定制排序
   *
   * */
 /**
   * 映射
   * map - 接受lambda，将元素转换成其他形式或者提取信息。接收另一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
   * flatMap - 接收一个函数作为参数，将流中的每个值都换为另一个流，然后把所有的流连接成一个流
   */
  /**
   * 筛选与切片
   * filter-接受Lambda,从流中排除某些元素
   * limit-截断流，使其元素不超过给定数量
   * skip(n) - 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不超过n个，则返回一个空流，与limit(n)互补
   * distinct - 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
   */
// 终止操作
/**
   * 查找与匹配
   * allMatch - 检查是否匹配所有元素
   * anyMatch - 检查是否至少匹配一个元素
   * noneMatch - 检查是否没有匹配所有元素
   * findFirst - 返回第一个元素
   * findAny - 返回当前流中的任意元素
   * count - 返回流中元素的总个数
   * max - 返回流中最大值
   * min - 返回流中最小值
   */

  /**
   * 归约
   * reduce(T identity, BinaryOperator) / reduce(BinaryOperator) - 可以将流中元素反复结合起来，得到一个值 ，初始值，二元运算符
   */

  /**
   * 收集
   * collect - 将流转化为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
   */

public class TestOptional {

  /**
   * Optional容器类的常用方法：
   * Optional.of(T t) : 创建一个Optional实例，传入null还是报错空指针异常
   * Optional.empty() : 创建一个空的Optional实例，调用get时报错java.util.NoSuchElementException: No value present
   * Optional.ofNullable(T t) : 若 t 不为null, 创建Optional实例，否则创建Optional.empty()实例
   * isPresent() : 判断是否包含值
   * orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
   * orElseGet(Supplier s) : 如果调用对象包含值，返回该值，否则返回s提供的值
   * map(Function f) : 如果有值对其处理，并返回处理后的Optional,否则返回Optional.empty()
   * flatMap(Function f) : 和map差不多
   */

  @Test
  public void test3() {
    Optional<Employee> op = Optional.of(new Employee("张三", 18, 111));
//    Optional<Integer> age = op.map(e -> e.getAge());
//    System.out.println(age.get());

    Optional<Integer> age = op.flatMap(e -> Optional.of(e.getAge()));
    System.out.println(age.get());
  }

  @Test
  public void test2() {
    Optional<Employee> op = Optional.empty();
    Employee emp = op.orElse(new Employee());
    System.out.println(emp);
  }

  @Test
  public void test1() {
    Optional<Employee> op = Optional.empty();
    System.out.println(op.get());
  }

  @Test
  public void test() {
    Optional<Employee> op = Optional.of(new Employee());
    Employee emp = op.get();
    System.out.println(emp);
  }
}