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() //
                 .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方法。