JAVA8新特性(上篇)

司内小分享, boss让我整理一下JAVA8新特性, 噢噢噢噢!!!还有这好事儿, 正好趁着这个机会好好学习下. 基于我不写笔记学不下去的习惯(分享也要有文档), 就出现了本篇内容. 主要讲使用条件和方式, 原理请自行Google

上篇: Lambda表达式, Collector, Optional
下篇: Stream流, LocalDateTime

说明: 测试中生成box测试数据均为一下方法生成

public static List generateBoxes() {
    List boxes = new ArrayList<>();
    boxes.add(new Box().setName("黄色箱子").setColor("yellow").setSize(5));
    boxes.add(new Box().setName("绿色箱子").setColor("green").setSize(8));
    boxes.add(new Box().setName("红色箱子").setColor("red").setSize(2));
    boxes.add(new Box().setName("黑色箱子").setColor("black").setSize(6));
    boxes.add(new Box().setName("紫色箱子").setColor("purple").setSize(10));
    boxes.add(new Box().setName("蓝色箱子").setColor("blue").setSize(1));
    return boxes;
}

函数式编程: 允许把函数作为基本运算单元, 可以作为方法的参数,又称闭包.
方法引用: 是指如果某个方法签名和接口恰好一致(只看参数类型和返回类型，不看方法名称，也不看类的继承关系)，就可以直接传入方法引用。

Lambda
函数式接口: 有且只有一个必须实现方法的接口(由于JAVA8中接口可以有了默认实现, 所以定义了一个 @FunctionalInterface 注解作为函数式接口的标记)
如:Comparator、Runnable以及四大函数式接口Consumer(返回void)、Function(返回映射泛型)、Predicate(返回boolean)、Supplier(返回定义的泛型)
Lambda表达式可以直接访问外部域变量, 但只能引用标记了 final 的外层局部变 量，不能lambda 内部修改定义在域外的局部变量.方法引用
如果某个方法签名和接口恰好一致，就可以直接传入方法引用四大函数式接口
简单的讲就是四类函数容器(容器的概念和思想很重要啊)

Lambda表达式: “->”
方法引用: “::”

Lambda:
可选类型声明： 不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号： 一个参数无需定义圆括号，但无参数或者多个参数需要定义圆括 号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需 要指定表达式返回了一个数值。方法引用
1)在使用lambda表达式时, 如果匿名函数的返回值类型和参数类型都已经确定, 则可以将任何符合要求的方法以方法引用的方式传入
2)第一不关心方法名; 第二不关心类的继承关系; 第三不关心方法实现

以数组、集合排序为例

Lambda

private static void lambda() {
    System.out.println("源数据boxes_1:");
    List boxes = GenerateUtil.generateBoxes();
    System.out.println(boxes);
    System.out.println("java7排序:");
    // 本质是创建匿名内部类
    // 编译时会生成Xxx$n.class
    boxes.sort(new Comparator() {
        @Override
        public int compare(Box o1, Box o2) {
            return o1.getSize() - o2.getSize();
        }
    });
    System.out.println(boxes);
    System.out.println("=======================================");
    System.out.println("源数据boxes_1");
    List boxes2 = GenerateUtil.generateBoxes();
    System.out.println(boxes2);
    System.out.println("java8排序:");
    // 本质是匿名函数
    boxes2.sort((box1, box2) -> box1.getSize() - box2.getSize());
    System.out.println(boxes2);
	// 特别的, 可以用来创建函数式接口的实例
    Comparator comparator = (o1, o2) -> o1.getSize() - o2.getSize();
}

方法引用

public static int ohMyGod(Integer num1, Integer num2) {
	// 为了与原数字排序方式混淆, 此处使用倒序排序
    return num2 - num1;
}

private static void methodReference() {
    Integer[] numbers = {5, 8, 2, 3, 4, 1, 9, 0};
    Arrays.sort(numbers, LambdaDemo::ohMyGod);
//        Arrays.sort(numbers, Math::max);
    System.out.println(Arrays.toString(numbers));
}

如上: ohMyGod的方法返回值和参数与compare方法一致, 此处就可以使用方法引用, Math的max方法也符合要求, 也可以使用. 这两个方法名字, 继承和实现关系, 方法实现都不相同, 但不影响使用.

Collector: 可变的聚合操作, 定义一个可变容器, 将新输入的元素添加到可变容器中(可以认为是可变容器的操作容器)
Collectors: 收集器工具类, 定义部分常用收集器

有三个泛型:
T: 元素类型
A: 可变容器类型
R: 结果容器类型
有五个方法:
Supplier: 创建新的结果容器
Accumulator: 合并元素到结果容器中
Combiner: 合并两个结果容器
Finisher: 将结果容器转为最终表示
Characteristics: 给collector设置特征值

工作原理即使用Collector中定义的方法对内容进行可达到目的性的操作

有三个特征值:
CONCURRENT: 表示结果容器只有一个
UNORDERED: 表示流中的元素无序
IDENTITY_FINISH: 表示中间结果容器类型与最终结果类型一致

Collector

自定义一个实现

public class MyCollector implements Collector, List> {
	// 创建一个新容器
    @Override
    public Supplier> supplier() {
        System.out.println("supplier execute");
        return ArrayList::new;
    }
	// 向容器中添加元素
    @Override
    public BiConsumer, T> accumulator() {
        System.out.println("accumulator execute");
        return List::add;
    }
	// 容器合并
    @Override
    public BinaryOperator> combiner() {
        System.out.println("combiner execute");
        return (container1, container2) -> {
            container1.addAll(container2);
            return container1;
        };
    }
	// 结果容器
    @Override
    public Function, List> finisher() {
        System.out.println("finisher execute");
        return (result) -> result;
    }

    @Override
    public Set characteristics() {
        return Collections.unmodifiableSet(EnumSet
                .of(Collector.Characteristics.IDENTITY_FINISH));
    }
}

自定义一个操作

public static  R operate(T[] ts1, A ts2, Collector collector) {
    // 获取一个新容器
    A a = collector.supplier().get();
    BiConsumer accumulator = collector.accumulator();
    // 向新容器中添加元素
    for (T t : ts1) {
    	// 遇到c时便不再继续添加
        if ("c".equals(t)) {
            break;
        }
        accumulator.accept(a, t);
    }
    BinaryOperator combiner = collector.combiner();
    // 合并容器操作
    A apply = combiner.apply(a, ts2);
    Function finisher = collector.finisher();
    // 容器转为结果操作
    return finisher.apply(apply);
}

private static void myCollector() {
	// 创建一个数组和一个集合, 进行操作
    String[] strings = {"a", "b", "c", "d"};
    List strs = new ArrayList<>(Arrays.asList("e", "f", "g"));
    List operate = Operations.operate(strings, strs, new MyCollector<>());
    System.out.println(operate);
}

Optional box = Optional.of(new Box());
Optional box1 = Optional.ofNullable(new Box());
Optional box2 = Optional.empty();

private static void orElse() {
    Box b = null;
    Box box1 = Optional.ofNullable(b).orElse(new Box().setName("1"));
    Box box2 = Optional.ofNullable(b).orElseGet(() -> new Box().setName("2"));
    Box box = Optional.ofNullable(b).orElseThrow(() -> new RuntimeException("box 不存在!"));
}

Optional box = Optional.of(new Box().setName("1"));
Optional s1 = box.map((b) -> b.getName());
Optional s2 = box.flatMap((b) -> Optional.ofNullable(b.getName()));

Optional box = Optional.empty();
Random random = new Random();
int i = random.nextInt();
if (i % 2 == 0) {
    box = Optional.of(new Box().setName("1"));
}
System.out.println(box.isPresent() ? "不为 null" : "为 null");
box.ifPresent(System.out::println);

double random = Math.random() * 10;
Optional box = Optional.of(new Box().setName("1").setSize((int) random));
Optional box1 = box.filter(b -> b.getSize() > 4);
System.out.println(box1);

User user = new User();
String s = Optional.ofNullable(user)
        .map(User::getAddress)
//         .orElse(new Address())
        .map(Address::getProvince)
//         .orElseGet(Province::new)
        .flatMap((p -> {
            City city = new City();
            p.setCity(city);
            return Optional.of(city);
        }))
        .map(City::getStreet)
        .orElseThrow(() -> new RuntimeException("容器中值为 null"));