1.3 java8新特性总结

java8中重要的4个新特性：

• Lambda
• Stream
• Optional
• 日期时间API
• 接口方法（default和static方法，jdk9可定义private方法）

一、Lambda

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @author zhaojigang
 * @date 2018/5/19
 */
public class LambdaTest {
    /**
     * Lambda 是一个匿名函数。
     * 1、语法
     * Lambda表达式引入了操作符为"->"，该操作符将Lambda分为两个部分：
     * 左侧:指定了Lambda表达式需要的所有参数
     * 右侧:指定了Lambda体，即Lambda表达式要执行的功能。
     *
     * 2、示例
     */
    public void testLambda() {
        /**
         * 语法格式一：无参，无返回值
         */
        Runnable task = () -> System.out.println("hello lambda");
        /**
         * 语法格式二：一个参数，无返回值
         * 注意：参数类型可以通过
         */
        Consumer<String> consumer = str -> System.out.println(str);
        /**
         * 语法格式三：一个参数，有返回值
         * 注意：当Lambda体只有一条语句时，省略大括号和return
         */
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
    }

    /**
     * 函数式接口：只包含一个抽象方法的接口。
     * 1、可以通过Lambda表达式来创建该接口的对象
     * 2、可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口
     *
     * Java内置了四大核心函数式接口：
     * 1、Consumer<T>：void accept(T t)，消费型接口
     * 2、Supplier<T>：T get()，供给型接口
     * 3、Function<T, R>：R apply(T t)，函数型接口
     * 4、Predicate<T>：boolean test(T t)，断言型接口
     * 还有部分子接口。
     */
    public void testFunctionalInterface() {
        Consumer<String> consumer = str -> System.out.println(str);
    }
}

二、Stream

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.stream.LongStream;

/**
 * @author zhaojigang
 * @date 2018/5/19
 */
public class StreamTest {

    static List<Integer> integerList = new ArrayList<Integer>() {{
        add(1);
        add(2);
        add(3);
        add(4);
        add(5);
        add(5);
        add(5);
    }};

    static List<Integer> integerList2 = new ArrayList<Integer>() {{
        add(10);
        add(20);
        add(30);
    }};

    static Map<String, List<Integer>> map1 = new HashMap<>();

    static {
        map1.put("list1", integerList);
        map1.put("list2", integerList2);
    }

    /**
     * 分片与筛选
     */
    public static void test1() {
        integerList.stream()
                .filter(x -> x > 2) // 3,4,5,5,5
                .skip(2) //5,5,5
                .limit(2) //5,5 短路:一旦获取到2个元素后不再向后迭代
                .distinct() //5
                .forEach(System.out::println);
    }

    /**
     * 映射
     * map(Function f)：接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素
     * flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
     */
    public static void test2() {
        integerList.stream()
                .map(x -> x + 10)
                .forEach(System.out::println);

        map1.values().stream()
                .flatMap(x -> x.stream()) // x是每一个List，flatMap将每一个List的Stream合并起来
                .forEach(System.out::println);

    }

    /**
     * 排序
     * sorted()：产生一个新流，其中按自然顺序排序（按照元素的Comparable接口）
     * sorted(Comparator comp)：产生一个新流，其中按比较器顺序排序（按照自定义的Comparator）
     */
    public static void test3() {
        integerList.stream()
                .sorted()
                .forEach(System.out::println);

        integerList.stream()
                .sorted((x, y) -> {
                    if (x < y) {
                        return 1;
                    } else {
                        return -1;
                    }
                })
                .forEach(System.out::println);

    }

    /**
     * 查找与匹配
     * allMatch(Predicate p)：检查是否匹配所有元素
     * anyMatch(Predicate p)：检查是否至少匹配一个元素
     * noneMatch(Predicate p)：检查是否没有匹配所有元素
     * findFirst()：返回第一个元素
     * findAny()：返回当前流中的任意元素
     * count()：返回流中元素总数
     * max(Comparator c)：返回流中最大值
     * min(Comparator c)：返回流中最小值
     */
    public static void test4() {
        final boolean allMatch = integerList.stream().allMatch(x -> x > 4);
        final boolean anyMatch = integerList.stream().anyMatch(x -> x > 4);
        final boolean noneMatch = integerList.stream().noneMatch(x -> x > 4);
        final Optional<Integer> first = integerList.stream().filter(x -> x > 3).findFirst();
        final Optional<Integer> any = integerList.stream().filter(x -> x > 3).findAny();
        final long count = integerList.stream().filter(x -> x > 4).count();
        final Optional<Integer> max = integerList.stream()
                .max((x, y) -> {
                    if (x < y) {
                        return 1;
                    } else {
                        return -1;
                    }
                });

    }

    /**
     * 规约
     * <p>
     * reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回T，其中iden是初始值
     * reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回Optional<T>
     */
    public static void test5() {
        // 计算：100+1+2+3+4+5+5+5
        final Integer sum = integerList.stream().reduce(100, (x, y) -> x + y);
        final Optional<Integer> sumOptional = integerList.stream().reduce((x, y) -> x + y);
    }

    /**
     * 收集
     * 常用：
     * 1、将流元素收集到List：List<Employee> emps= list.stream().collect(Collectors.toList());
     * 2、将流元素收集到Set：List<Employee> emps= list.stream().collect(Collectors.toSet());
     * 3、连接流中每个字符串：String str= list.stream().map(Employee::getName).collect(Collectors.joining());
     * 4、分组： Map<Emp.Status, List<Emp>> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
     *
     * 不常用：
     * 1、根据true或false进行分区：Map<Boolean,List<Emp>>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));
     * 2、根据比较器选择最大值：Optional<Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
     * 3、根据比较器选择最小值：Optional<Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
     * 4、将流元素收集到任意指定集合：Collection<Employee> emps=list.stream().collect(Collectors.toCollection(ArrayList::new));
     * 5、计算流中元素的个数：long count = list.stream().collect(Collectors.counting());
     * 6、对流中元素的属性求和：int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
     * 7、计算流中元素Integer属性的平均值：double avg= list.stream().collect(Collectors.averagingInt(Employee::getSalary));
     */
    public static void test6() {
    }

    /**
     * 并行流与串行流
     * 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
     * 底层：fork/join
     * Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换
     */
    public static void test7(){
        long start = System.currentTimeMillis();

        final OptionalLong sum = LongStream.rangeClosed(0, 100000000000L)
                .parallel()
                .reduce(Long::sum);

        System.out.println(sum + "-" + (System.currentTimeMillis() - start));
    }

    public static void main(String[] args) {
        test7();
    }
}

三、Optional

import java.util.Optional;

/**
 * @author zhaojigang
 * @date 2018/5/19
 */
public class OptionalTest {

    public static void main(String[] args) {
//        String godName = "shijia";
        String godName = null;
        // 常用方式
        final String god = Optional.ofNullable(godName).orElse("yesu");
        System.out.println(god);
    }
}

四、日期时间API

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author zhaojigang
 * @date 2018/5/19
 */
public class TimeTest {

    /**
     * 一、日期创建：
     * LocalDate localDate = LocalDate.now();
     * LocalTime localTime = LocalTime.now();
     * LocalDateTime localDateTime = LocalDateTime.now();
     *
     * LocalDate localDate = LocalDate.of(2016, 10, 26);
     * LocalTime localTime = LocalTime.of(02, 22, 56);
     * LocalDateTime localDateTime = LocalDateTime.of(2016, 10, 26, 12, 10, 55);
     *
     * 二、日期加减运算
     * plusDays, plusWeeks, plusMonths, plusYears
     * minusDays, minusWeeks, minusMonths, minusYears
     * plus, minus
     *
     * 三、日期比较计算
     * isBefore, isAfter
     *
     * 四、是否闰年
     * isLeapYear
     *
     * 五、时间戳与时间间隔运算
     * Instant 时间戳：以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算
     * Duration:用于计算两个“时间”间隔
     * Period:用于计算两个“日期”间隔
     *
     * 六、时间校正器
     * TemporalAdjuster/TemporalAdjusters 调整时间：例如获取下一个周日等
     *
     * 七、日期解析和格式化
     * java.time.format.DateTimeFormatter类
     */
    public static void main(String[] args) {
        /**
         * 计算时间间隔
         */
        Instant in1 = Instant.now();
        Instant in2 = Instant.now();
        System.out.println(Duration.between(in1, in2).toMillis());

        /**
         * 日期格式化
         */
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime time1 = LocalDateTime.now();
        String formatDateTime = time1.format(formatter);

        /**
         * 日期解析
         */
        LocalDateTime dateTime = LocalDateTime.parse(formatDateTime, formatter);
    }
}

日期操作我们通常会使用Apache commons包，但是这样就会引入一个包，能够使用java本身的就是用java本身的。

五、接口方法

/**
 * @author zhaojigang
 * @date 2018/5/19
 */
public class InterfaceTest {
    public static void main(String[] args) {
        MyImpl myClass = new MyImpl();
        System.out.println(myClass.getName());
        System.out.println(MyInterface.getAge());
    }
}

interface MyInterface {
    default String getName(){
        return "nana";
    }

    static Integer getAge(){
        return 18;
    }
}

/**
 * 若一个接口中定义了一个默认方法，而另外一个父类中又定义了一个同名的方法时，取父类
 * 若一个接口中定义了一个默认方法，而另外一个实现接口中又定义了一个同名的方法时，实现类需要执行重写其中一个
 */
class MyImpl implements MyInterface {
}

在jdk9中，接口中可以定义private方法。