品茗Java8新特性

 4,002浏览     wenqyAdmin   

看了下openjdk官网 http://openjdk.java.net/projects/jdk/14/ jdk14今年就要发布稳定版本了，连java8都没有系统的学习过。那就来学习下java8吧，这是一个长期维护的版本。这里主要来学习java8的一些新特性。对应demo可以下载链接：

https://github.com/wenqy/java-study

接口默认方法

使用default关键字，为接口声明添加非抽象的方法实现接口默认方法

  1. public interface DefaultInterfaceMethod {
  3.     double calc(int a);
  5.     /**
  6.      * 接口使用 <b>default</b>关键字，添加非抽象方法实现（扩展方法）
  7.      * @param a
  8.      * @return
  9.      * @author wenqy
  10.      * @date 2020年1月16日 上午9:55:20
  11.      */
  12.     default double sqrt(int a) {
  13.         return Math.sqrt(a);
  14.     }
  15. }

然后实现匿名内部类，并调用默认方法

  1. DefaultInterfaceMethod interfaceMethod = new DefaultInterfaceMethod() {
  3.     @Override
  4.     public double calc(int a) {
  5.         return sqrt(a * 100);
  6.     }
  7. };
  8. System.out.println(“calc：” + interfaceMethod.calc(100)); // calc：100.0
  9. System.out.println(“sqrt：” + interfaceMethod.sqrt(16)); // sqrt：4.0

Lambda表达式

来看下排序的例子，静态工具方法Collections.sort接受一个list，和一个Comparator接口作为输入参数，java8之前需要一个匿名对象，java8可以用Lambda表达式变得简洁

  1.     /**
  2.      * Java8之前方法（匿名对象）实现排序
  3.      * @param names
  4.      * @author wenqy
  5.      * @date 2020年1月16日 上午10:07:45
  6.      */
  7.     private static void sortByBefore8Method(List<String> names) {
  8.         Collections.sort(names, new Comparator<String>() {
  9.             @Override
  10.             public int compare(String a, String b) {
  11.                 return b.compareTo(a);
  12.             }
  13.         });
  14.     }
  16.     /**
  17.      * 用Lambda表达式排序，Java编译器能够自动识别参数类型
  18.      * @param names
  19.      * @author wenqy
  20.      * @date 2020年1月16日 上午10:09:40
  21.      */
  22.     private static void sortByLambda(List<String> names) {
  23. //      可以这样写
  24. //      Collections.sort(names, (String a, String b) -> {
  25. //          return b.compareTo(a);
  26. //      });
  28. //      也可以这样写
  29. //      Collections.sort(names, (String a, String b) -> b.compareTo(a));
  31. //      还可以这样写
  32.         Collections.sort(names, (a, b) -> b.compareTo(a));
  33.     }

Java编译器能够自动识别参数的类型，所以可以省略掉类型不写。

函数式接口

每一个lambda都能够通过一个特定的接口，与一个给定的类型进行匹配。一个所谓的函数式接口必须要有且仅有一个抽象方法声明。每个与之对应的lambda表达式必须要与抽象方法的声明相匹配。由于默认方法不是抽象的，因此你可以在你的函数式接口里任意添加默认方法。

任意只包含一个抽象方法的接口，我们都可以用来做成lambda表达式。为了让你定义的接口满足要求，你应当在接口前加上@FunctionalInterface 标注。编译器会注意到这个标注，如果你的接口中定义了第二个抽象方法的话，编译器会抛出异常。

  1. /**
  2.  * 
  3.  * 每一个lambda都能够通过一个特定的接口，与一个给定的类型进行匹配。
  4.  * 一个所谓的函数式接口必须要有且仅有一个抽象方法声明。
  5.  * 每个与之对应的lambda表达式必须要与抽象方法的声明相匹配。
  6.  * 
  7.  * @FunctionalInterface 标注。
  8.  *  编译器会注意到这个标注，如果接口中定义了第二个抽象方法的话，编译器会抛出异常
  9.  * 
  10.  * @version V5.0
  11.  * @author wenqy
  12.  * @date   2020年1月16日
  13.  */
  14. @FunctionalInterface
  15. public interface Converter<F, T> {
  17.     /**
  18.      * 类型转换  F->T
  19.      * @param from
  20.      * @return
  21.      * @author wenqy
  22.      * @date 2020年1月16日 上午10:22:32
  23.      */
  24.     T convert(F from);
  26. //  T mapping(F from);
  27. }

方法和构造函数引用

函数式接口可以通过方法或构造函数引用使代码变得更简洁。Java 8 允许你通过::关键字获取方法或者构造函数的的引用。

  1. static class Something {
  2.     String startsWith(String s) {
  3.         return String.valueOf(s.charAt(0));
  4.     }
  5. }
  7. private static <F, T> void convert(Converter<F,T> converter, F from) {
  8.     T converted = converter.convert(from);
  9.     System.out.println(converted);
  10. }
  12. public static void main(String[] args) {
  13.     Converter<String, Integer> converter1 = Integer::valueOf; // 静态方法引用
  14.     convert(converter1,“123”); // “1”
  16.     Something something = new Something();
  17.     Converter<String, String> converter2 = something::startsWith; // 对象方法引用
  18.     convert(converter2,“Java”); // “J”
  20.     PersonFactory<Person> personFactory = Person::new;  // 构造函数引用(构造参数需一致)
  21.     Person person = personFactory.create(“Peter”, “Parker”);
  22.     System.out.println(person); // Person [firstName=Peter, lastName=Parker]
  23. }

Lambda访问范围

对于lambda表达式外部的变量，其访问权限的粒度与匿名对象的方式非常类似。你能够访问局部对应的外部区域的局部final变量，以及成员变量和静态变量。默认方法无法在lambda表达式内部被访问。

我们可以访问lambda表达式外部的final局部变量，但是与匿名对象不同的是，变量num并不需要一定是final，然而，num在编译的时候被隐式地当做final变量来处理。

  1.     static class Lambda {
  2.         static int outerStaticNum;
  3.         int outerNum;
  5.         /**
  6.          * 访问成员变量
  7.          * 
  8.          * @author wenqy
  9.          * @date 2020年1月16日 上午11:15:31
  10.          */
  11.         void accessOuterNum() {
  12.             Converter<Integer, String> converter = (from) -> {
  13.                 outerNum = 23;
  14.                 return String.valueOf(outerNum + from);
  15.             };
  16.             System.out.println(“accessOuterNum：” + converter.convert(2)); // 25
  17. //          outerNum = 3;
  18.         }
  20.         /**
  21.          * 访问静态变量
  22.          * 
  23.          * @author wenqy
  24.          * @date 2020年1月16日 上午11:18:41
  25.          */
  26.         void accessOuterStaticNum() {
  27.             Converter<Integer, String> converter = (from) -> {
  28.                 outerStaticNum = 72;
  29.                 return String.valueOf(outerStaticNum + from);
  30.             };
  31.             System.out.println(“accessOuterStaticNum：” + converter.convert(2)); // 74
  32. //          outerStaticNum = 3;
  33.         }
  35.         /**
  36.          * 访问局部变量
  37.          *      可以访问lambda表达式外部的final局部变量
  38.          *      但是与匿名对象不同的是，变量num并不需要一定是final
  39.          * @author wenqy
  40.          * @date 2020年1月16日 上午11:06:09
  41.          */
  42.         void accessLocalVariable() {
  43. //          final int num = 1;
  44.             int num = 1;
  45.             Converter<Integer, String> stringConverter =
  46.                     (from) -> String.valueOf(from + num);
  47.             System.out.println(“accessLocalVariable：” + stringConverter.convert(2));     // 3
  48. //          num = 3; // 编译的时候被隐式地当做final变量来处理，无法改变值
  49.         }
  50.     }
  52.     public static void main(String[] args) {
  53.         Lambda lambda = new Lambda();
  54.         lambda.accessLocalVariable();
  55.         lambda.accessOuterNum();
  56.         lambda.accessOuterStaticNum();
  58. //      默认方法无法在lambda表达式内部被访问,无法通过编译
  59. //      DefaultInterfaceMethod formula = (a) -> sqrt( a * 100);
  60.     }

内置函数式接口

Java 8 API 还提供了很多新的函数式接口，来降低程序员的工作负担。让我们来看下几个内置的函数式接口

Predicate是一个布尔类型的函数，该函数只有一个输入参数。Predicate接口包含了多种默认方法，用于处理复杂的逻辑动词（and, or，negate）

Function接口接收一个参数，并返回单一的结果。默认方法可以将多个函数串在一起（compse, andThen）

Supplier接口产生一个给定类型的结果。与Function不同的是，Supplier没有输入参数

Consumer代表了在一个输入参数上需要进行的操作

Comparator接口在早期的Java版本中非常著名。Java 8 为这个接口添加了不同的默认方法

Optional不是一个函数式接口，而是一个精巧的工具接口，用来防止NullPointerException产生。他是一个简单的值容器，这个值可以是null，也可以是non-null。考虑到一个方法可能会返回一个non-null的值，也可能返回一个空值。为了不直接返回null，我们在Java 8中就返回一个Optional

  1. /**
  2.      * 布尔类型函数
  3.      * 
  4.      * @author wenqy
  5.      * @date 2020年1月16日 上午11:39:26
  6.      */
  7.     private static void testPredicates() {
  8.         System.out.println(“——>testPredicates——>”);
  9.         Predicate<String> predicate = (s) -> s.length() > 0;
  10.         System.out.println(predicate.test(“foo”)); // true
  11.         System.out.println(predicate.negate().test(“foo”)); // false
  13.         Predicate<Boolean> nonNull = Objects::nonNull;
  14.         Predicate<Boolean> isNull = Objects::isNull;
  15.         System.out.println(nonNull.test(null)); // false
  16.         System.out.println(isNull.test(null)); // true
  18.         Predicate<String> isEmpty = String::isEmpty;
  19.         Predicate<String> isNotEmpty = isEmpty.negate();
  20.         System.out.println(isEmpty.test(“”)); // true
  21.         System.out.println(isNotEmpty.test(“”)); // false
  22.     }
  24.     /**
  25.      * 内置 Function 函数，将多个函数串联
  26.      * 
  27.      * @author wenqy
  28.      * @date 2020年1月16日 上午11:41:35
  29.      */
  30.     private static void testFunctions() {
  31.         System.out.println(“——>testFunctions——>”);
  32.         Function<String, Integer> toInteger = Integer::valueOf;
  33.         Function<String, String> backToString = toInteger.andThen(String::valueOf);
  34.         System.out.println(backToString.apply(“123”));     // “123”
  35.     }
  37.     /**
  38.      * 内置 Supplier 函数
  39.      *  产生一个给定类型的结果
  40.      * @author wenqy
  41.      * @date 2020年1月16日 上午11:52:51
  42.      */
  43.     private static void testSuppliers() {
  44.         System.out.println(“——>testSuppliers——>”);
  45.         Supplier<Person> personSupplier = Person::new;
  46.         Person person = personSupplier.get();   // new Person
  47.         person.setFirstName(“wen”);
  48.         person.setLastName(“qy”);
  49.         System.out.println(person);
  50.     }
  52.     /**
  53.      * 内置 Consumer 函数
  54.      *  输入参数上需要进行操作
  55.      * @author wenqy
  56.      * @date 2020年1月16日 下午1:48:33
  57.      */
  58.     private static void testConsumers() {
  59.         System.out.println(“——>testConsumers——>”);
  60.         Consumer<Person> greeter = (p) -> System.out.println(“Hello, “ + p.getFirstName());
  61.         greeter.accept(new Person(“Luke”, “Skywalker”));
  62.     }
  64.     /**
  65.      * 
  66.      * 内置 Comparator 函数
  67.      *      用于比较
  68.      * @author wenqy
  69.      * @date 2020年1月16日 下午1:54:29
  70.      */
  71.     private static void testComparators() {
  72.         System.out.println(“——>testComparators——>”);
  73.         Comparator<Person> comparator = (p1, p2) -> p1.getFirstName().compareTo(p2.getFirstName());
  75.         Person p1 = new Person(“John”, “Doe”);
  76.         Person p2 = new Person(“Alice”, “Wonderland”);
  78.         System.out.println(comparator.compare(p1, p2)); // > 0
  79.         System.out.println(comparator.reversed().compare(p1, p2)); // < 0
  80.     }
  82.     /**
  83.      * Optional
  84.      *  值容器，用来防止NullPointerException产生
  85.      * @author wenqy
  86.      * @date 2020年1月16日 下午1:58:44
  87.      */
  88.     private static void testOptionals() {
  89.         System.out.println(“——>testOptionals——>”);
  90.         Optional<String> optional = Optional.of(“bam”);
  92.         System.out.println(optional.isPresent()); // true
  93.         System.out.println(optional.get()); // “bam”
  94.         System.out.println(optional.orElse(“fallback”)); // “bam”
  96.         optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // “b”
  97.     }

流Stream

java.util.Stream表示了某一种元素的序列，在这些元素上可以进行各种操作。Stream操作可以是中间操作，也可以是完结操作。完结操作会返回一个某种类型的值，而中间操作会返回流对象本身，并且你可以通过多次调用同一个流操作方法来将操作结果串起来（就像StringBuffer的append方法一样）。Stream是在一个源的基础上创建出来的，例如java.util.Collection中的list或者set（map不能作为Stream的源）。Stream操作往往可以通过顺序或者并行两种方式来执行。Stream并不会改变原有的序列。

  1. List<String> stringCollection = new ArrayList<>();
  3. public StreamsMain() {
  4.     init();
  5. }
  7. private void init() {
  8.     if (stringCollection.isEmpty()) {
  9.         stringCollection.add(“ddd2”);
  10.         stringCollection.add(“aaa2”);
  11.         stringCollection.add(“bbb1”);
  12.         stringCollection.add(“aaa1”);
  13.         stringCollection.add(“bbb3”);
  14.         stringCollection.add(“ccc”);
  15.         stringCollection.add(“bbb2”);
  16.         stringCollection.add(“ddd1”);
  17.     }
  18. }
  20. /**
  21.  * 
  22.  * Filter接受一个predicate接口类型的变量，并将所有流对象中的元素进行过滤。
  23.  * 该操作是一个中间操作，因此它允许我们在返回结果的基础上再进行其他的流操作（forEach）。
  24.  * ForEach接受一个function接口类型的变量，用来执行对每一个元素的操作。
  25.  * ForEach是一个中止操作。它不返回流，所以我们不能再调用其他的流操作。
  26.  * @author wenqy
  27.  * @date 2020年1月16日 下午2:34:58
  28.  */
  29. private void testFilter() {
  30.     System.out.println(“—–>testFilter—–>”);
  31.     stringCollection
  32.         .stream()
  33.         .filter((s) -> s.startsWith(“a”)) // 过滤以“a”开头的集合
  34.         .forEach(System.out::println);
  36. }
  38. /**
  39.  * Sorted是一个中间操作，能够返回一个排过序的流对象的视图。
  40.  * 流对象中的元素会默认按照自然顺序进行排序，除非你自己指定一个Comparator接口来改变排序规则
  41.  * 
  42.  * @author wenqy
  43.  * @date 2020年1月16日 下午2:38:28
  44.  */
  45. private void testSorted() {
  46.     System.out.println(“—–>testSorted—–>”);
  47.     stringCollection
  48.         .stream()
  49.         .sorted() // 自然排序
  50.         .filter((s) -> s.startsWith(“a”)) // 过滤以“a”开头的集合
  51.         .forEach(System.out::println);
  52.     // sorted不会改变原来集合中元素的顺序。原来string集合中的元素顺序是没有改变的。
  53.     System.out.println(stringCollection);
  54. }
  56. /**
  57.  * map是一个对于流对象的中间操作，通过给定的方法，它能够把流对象中的每一个元素对应到另外一个对象上。
  58.  * 下面的例子就演示了如何把每个string都转换成大写的string. 
  59.  * 不但如此，你还可以把每一种对象映射成为其他类型。
  60.  * 对于带泛型结果的流对象，具体的类型还要由传递给map的泛型方法来决定。
  61.  * 
  62.  * @author wenqy
  63.  * @date 2020年1月16日 下午2:43:38
  64.  */
  65. private void testMap() {
  66.     System.out.println(“—–>testMap—–>”);
  67.     stringCollection
  68.         .stream()
  69.         .map(String::toUpperCase) // 每个元素转大写
  70.         .sorted((a, b) -> b.compareTo(a))
  71.         .forEach(System.out::println);
  72.     // sorted不会改变原来集合中元素的顺序。原来string集合中的元素顺序是没有改变的。
  73.     System.out.println(stringCollection);
  74. }
  76. /**
  77.  * 匹配操作有多种不同的类型，都是用来判断某一种规则是否与流对象相互吻合的。
  78.  * 所有的匹配操作都是终结操作，只返回一个boolean类型的结果。
  79.  * 
  80.  * @author wenqy
  81.  * @date 2020年1月16日 下午2:47:48
  82.  */
  83. private void testMatch() {
  84.     System.out.println(“—–>testMatch—–>”);
  85.     boolean anyStartsWithA =
  86.         stringCollection
  87.             .stream()
  88.             .anyMatch((s) -> s.startsWith(“a”));
  90.     System.out.println(anyStartsWithA);      // true
  92.     boolean allStartsWithA =
  93.         stringCollection
  94.             .stream()
  95.             .allMatch((s) -> s.startsWith(“a”));
  97.     System.out.println(allStartsWithA);      // false
  99.     boolean noneStartsWithZ =
  100.         stringCollection
  101.             .stream()
  102.             .noneMatch((s) -> s.startsWith(“z”));
  104.     System.out.println(noneStartsWithZ);      // true
  105. }
  107. /**
  108.  * Count是一个终结操作，它的作用是返回一个数值，用来标识当前流对象中包含的元素数量。
  109.  * 
  110.  * @author wenqy
  111.  * @date 2020年1月16日 下午2:51:40
  112.  */
  113. private void testCount() {
  114.     System.out.println(“—–>testCount—–>”);
  115.     long startsWithB =
  116.         stringCollection
  117.             .stream()
  118.             .filter((s) -> s.startsWith(“b”))
  119.             .count();
  121.     System.out.println(startsWithB);    // 3
  122. }
  124. /**
  125.  * 该操作是一个终结操作，它能够通过某一个方法，对元素进行削减操作。
  126.  * 该操作的结果会放在一个Optional变量里返回。
  127.  * 
  128.  * @author wenqy
  129.  * @date 2020年1月16日 下午2:54:00
  130.  */
  131. private void testReduce() {
  132.     System.out.println(“—–>testReduce—–>”);
  133.     Optional<String> reduced =
  134.         stringCollection
  135.             .stream()
  136.             .sorted()
  137.             .reduce((s1, s2) -> s1 + “#” + s2);
  139.     reduced.ifPresent(System.out::println); // “aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2”
  142. }

并发流Stream

数量量大时，可以使用并行流进行操作来提高运行效率。

  1. //  int max = 1000000; // 大数据量并发才有优势
  2.     int max = 400000;
  3.     List<String> values = new ArrayList<>(max);
  5.     public ParallelStreamsMain() {
  6.         init();
  7.     }
  9.     private void init() {
  10.         for (int i = 0; i < max; i++) {
  11.             UUID uuid = UUID.randomUUID();
  12.             values.add(uuid.toString());
  13.         }
  14.     }
  16.     /**
  17.      * 顺序排序
  18.      * 
  19.      * @author wenqy
  20.      * @date 2020年1月16日 下午3:20:22
  21.      */
  22.     private void sequenceSorted() {
  23.         System.out.println(“——>sequenceSorted—–>”);
  24.         long t0 = System.nanoTime();
  26.         long count = values.stream().sorted().count();
  27.         System.out.println(count);
  29.         long t1 = System.nanoTime();
  31.         long millis = TimeUnit.NANOSECONDS.toMillis(t1 – t0);
  32.         System.out.println(String.format(“sequential sort took: %d ms”, millis));
  33.     }
  35.     /**
  36.      * 并行排序
  37.      * 
  38.      * @author wenqy
  39.      * @date 2020年1月16日 下午3:21:56
  40.      */
  41.     private void parallelSorted() {
  42.         System.out.println(“——>parallelSorted—–>”);
  43.         long t0 = System.nanoTime();
  45.         long count = values.parallelStream().sorted().count();
  46.         System.out.println(count);
  48.         long t1 = System.nanoTime();
  50.         long millis = TimeUnit.NANOSECONDS.toMillis(t1 – t0);
  51.         System.out.println(String.format(“parallel sort took: %d ms”, millis));
  53.     }

Map

map是不支持流操作的。而更新后的map现在则支持多种实用的新方法

  1. Map<Integer, String> map = new HashMap<>();
  3. for (int i = 0; i < 10; i++) {
  4.     map.putIfAbsent(i, “val” + i); // 旧值存在时返回旧值，不进行替换
  5. }
  7. map.forEach((id, val) -> System.out.println(val));
  9. map.computeIfPresent(3, (num, val) -> val + num);
  10. map.get(3);             // val33
  12. map.computeIfPresent(9, (num, val) -> null); // 返回null时，remove(key)
  13. map.containsKey(9);     // false
  15. map.computeIfAbsent(23, num -> “val” + num);
  16. map.containsKey(23);    // true
  18. map.computeIfAbsent(3, num -> “bam”); // 旧值存在时返回旧值，不进行替换
  19. map.get(3);             // val33
  21. map.remove(3, “val3”);  // 校验value删除
  22. map.get(3);             // val33
  24. map.remove(3, “val33”);
  25. map.get(3);             // null
  27. map.getOrDefault(42, “not found”);  // not found 不存在则返回默认值
  29. map.merge(9, “val9”, (value, newValue) -> value.concat(newValue)); // 先前key 9 已经删除了，不存在key，则返回 value
  30. System.out.println(map.get(9));             // val9
  32. map.merge(9, “concat”, (value, newValue) -> value.concat(newValue)); // 存在key,才进行合并
  33. System.out.println(map.get(9));             // val9concat

时间日期API

Java 8 包含了全新的时间日期API，这些功能都放在了java.time包下。新的时间日期API是基于Joda-Time库开发的，但是也不尽相同。

  1. /**
  2.  * Clock提供了对当前时间和日期的访问功能。Clock是对当前时区敏感的
  3.  * 
  4.  * @author wenqy
  5.  * @date 2020年1月16日 下午4:36:49
  6.  */
  7. private static void testClock() {
  8.     System.out.println(“—–>testClock—–>”);
  9.     Clock clock = Clock.systemDefaultZone();
  10.     long millis = clock.millis();
  11.     System.out.println(millis); // 获取当前毫秒时间
  12.     Instant instant = clock.instant();
  13.     Date date = Date.from(instant);   // java.util.Date
  14.     System.out.println(date); // 获取日期 Thu Jan 16 16:38:01 CST 2020
  15. }
  17. /**
  18.  * 时区类可以用一个ZoneId来表示。
  19.  * 时区类还定义了一个偏移量，用来在当前时刻或某时间与目标时区时间之间进行转换。
  20.  * 
  21.  * @author wenqy
  22.  * @date 2020年1月16日 下午4:40:38
  23.  */
  24. private static void testTimezones() {
  25.     System.out.println(“—–>testTimezones—–>”);
  26.     System.out.println(ZoneId.getAvailableZoneIds());
  27.     // prints all available timezone ids
  29.     ZoneId zone1 = ZoneId.of(“Europe/Berlin”);
  30.     ZoneId zone2 = ZoneId.of(“Brazil/East”);
  31.     ZoneId zone3 = ZoneId.of(“Asia/Shanghai”);
  32.     System.out.println(zone1.getRules());
  33.     System.out.println(zone2.getRules());
  34.     System.out.println(zone3.getRules());
  35. }
  37. /**
  38.  * 本地时间类表示一个没有指定时区的时间
  39.  * 
  40.  * @author wenqy
  41.  * @date 2020年1月16日 下午4:49:11
  42.  */
  43. private static void testLocalTime() {
  44.     System.out.println(“—–>testLocalTime—–>”);
  45.     LocalTime now1 = LocalTime.now(ZoneId.of(“Europe/Berlin”));
  46.     LocalTime now2 = LocalTime.now(ZoneId.of(“Asia/Shanghai”));
  47.     // 比较两个时间
  48.     System.out.println(now1.isBefore(now2));  // true
  50.     long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
  51.     long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
  52.     // 柏林时区在东一区，上海时区在东八区   柏林比北京时间慢7小时
  53.     System.out.println(hoursBetween);       // 7
  54.     System.out.println(minutesBetween);     // 420
  55.     // 时间字符串解析操作
  56.     LocalTime late = LocalTime.of(23, 59, 59);
  57.     System.out.println(late);       // 23:59:59
  59.     DateTimeFormatter germanFormatter =
  60.         DateTimeFormatter
  61.             .ofLocalizedTime(FormatStyle.SHORT)
  62.             .withLocale(Locale.GERMAN);
  64.     LocalTime leetTime = LocalTime.parse(“13:37”, germanFormatter);
  65.     System.out.println(leetTime);   // 13:37
  66. }
  68. /**
  69.  * 本地日期
  70.  *  每一次操作都会返回一个新的时间对象
  71.  * 
  72.  * @author wenqy
  73.  * @date 2020年1月16日 下午5:05:52
  74.  */
  75. private static void testLocalDate() {
  76.     System.out.println(“—–>testLocalDate—–>”);
  77.     LocalDate today = LocalDate.now(); // 今天
  78.     LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS); // 明天=今天+1
  79.     LocalDate yesterday = tomorrow.minusDays(2); // 昨天=明天-2
  80.     System.out.println(yesterday);
  81.     LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
  82.     DayOfWeek dayOfWeek = independenceDay.getDayOfWeek(); // 获取周
  83.     System.out.println(dayOfWeek); // FRIDAY
  84. }
  86. /**
  87.  * 日期-时间
  88.  *  final对象
  89.  * @author wenqy
  90.  * @date 2020年1月16日 下午5:12:37
  91.  */
  92. private static void testLocalDateTime() {
  93.     System.out.println(“—–>testLocalDateTime—–>”);
  94.     LocalDateTime sylvester = LocalDateTime.of(2019, Month.DECEMBER, 31, 23, 59, 59);
  96.     DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
  97.     System.out.println(dayOfWeek);      // TUESDAY
  99.     Month month = sylvester.getMonth();
  100.     System.out.println(month);          // DECEMBER
  102.     long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
  103.     System.out.println(minuteOfDay);    // 1439
  105.     // 加上时区，转日期Date
  106.     Instant instant = sylvester
  107.             .atZone(ZoneId.systemDefault())
  108.             .toInstant();
  110.     Date legacyDate = Date.from(instant);
  111.     System.out.println(legacyDate);     // Tue Dec 31 23:59:59 CST 2019
  113.     // 自定义格式对象
  114.     DateTimeFormatter formatter =
  115.         DateTimeFormatter
  116.             .ofPattern(“yyyy-MM-dd HH:mm:ss”);  // 线程安全，不可变
  117.     LocalDateTime parsed = LocalDateTime.parse(“2020-01-16 17:13:00”, formatter);
  118.     String string = formatter.format(parsed);
  119.     System.out.println(string);     // 2020-01-16 17:13:00
  120. }

可重复注解

Java 8中的注解是可重复的

  1. /**
  2.  * @Repeatable，Java 8 允许我们对同一类型使用多重注解
  3.  * 
  4.  * @version V5.0
  5.  * @author wenqy
  6.  * @date   2020年1月16日
  7.  */
  8. @Repeatable(Hints.class)
  9. @Retention(RetentionPolicy.RUNTIME) // 需要指定runtime,否则测试会失败
  10. public @interface Hint {
  11.     String value();
  12. }

在Person类添加注解，尝试获取类注解

  1. /**
  2.  * @Hint 可重复注解（新方法）
  3.  * 使用注解容器（老方法）: @Hints({@Hint(“hint1”), @Hint(“hint2”)})
  4.  * @version V5.0
  5.  * @author wenqy
  6.  * @date   2020年1月16日
  7.  */
  8. @Hint(“hint1”)
  9. @Hint(“hint2”)
  10. //@Hints({@Hint(“hint1”), @Hint(“hint2”)})
  11. public class Person {
  12.     // …
  13. }
  16. Hint hint = Person.class.getAnnotation(Hint.class);
  17. System.out.println(hint);                   // null
  19. Hints hints1 = Person.class.getAnnotation(Hints.class);
  20. System.out.println(hints1.value().length);  // 2
  22. Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
  23. System.out.println(hints2.length);          // 2

String

java8添加了对字符数据流的流式操作

  1. System.out.println(String.join(“:”, “foobar”, “foo”, “bar”)); // foobar:foo:bar
  2.         // 指定分割符，将字符串拼接
  4.         System.out.println(
  5.                 “foobar:foo:bar”
  6.                 .chars() // 字符数据流
  7.                 .distinct()
  8.                 .mapToObj(c -> String.valueOf((char)c))
  9.                 .sorted()
  10.                 .collect(Collectors.joining())
  11.                 ); // :abfor
  13.         System.out.println(
  14.                 Pattern.compile(“:”)
  15.                 .splitAsStream(“foobar:foo:bar”)
  16.                 .filter(s -> s.contains(“bar”))
  17.                 .sorted()
  18.                 .collect(Collectors.joining(“:”))
  19.             ); // bar:foobar
  21.         System.out.println(
  22.                 Stream.of(“bob@gmail.com”, “alice@hotmail.com”)
  23.                     .filter(Pattern.compile(“.*@gmail\\.com”).asPredicate())
  24.                     .count()
  25.             ); // 1

数值处理

Java8添加了对无符号数的额外支持。新增了一些方法来处理数值溢出

  1. System.out.println(Integer.MAX_VALUE);      // 2147483647
  2.         System.out.println(Integer.MAX_VALUE + 1);  // -2147483648
  4.         long maxUnsignedInt = (1l << 32) – 1; // 
  5.         String string = String.valueOf(maxUnsignedInt);
  6.         int unsignedInt = Integer.parseUnsignedInt(string, 10); // 无符号转换
  7.         String string2 = Integer.toUnsignedString(unsignedInt, 10);
  8.         System.out.println(string2);
  9.         try {
  10.             Integer.parseInt(string, 10);
  11.         } catch (NumberFormatException e) {
  12.             System.err.println(“could not parse signed int of “ + maxUnsignedInt);
  13.         }
  15.         try {
  16.             Math.addExact(Integer.MAX_VALUE, 1);
  17.         }
  18.         catch (ArithmeticException e) {
  19.             System.err.println(e.getMessage());
  20.             // => integer overflow
  21.         }
  23.         try {
  24.             Math.toIntExact(Long.MAX_VALUE);
  25.         }
  26.         catch (ArithmeticException e) {
  27.             System.err.println(e.getMessage());
  28.             // => integer overflow
  29.         }

文件处理

java8新增了对文件处理的方法

  1. /**
  2.  * 文件查找
  3.  * @throws IOException
  4.  * @author wenqy
  5.  * @date 2020年1月18日 下午3:02:05
  6.  */
  7. private static void findFiles() throws IOException {
  8.     Path start = Paths.get(“”);
  9.     int maxDepth = 5;
  10.     try (Stream<Path> stream = Files.find(start, maxDepth, (path, attr) ->
  11.             String.valueOf(path).endsWith(“.js”))) {
  12.         String joined = stream
  13.             .sorted()
  14.             .map(String::valueOf)
  15.             .collect(Collectors.joining(“; “));
  16.         System.out.println(“Found: “ + joined);
  17.     }
  18. }
  20. /**
  21.  * 获取文件列表
  22.  * @throws IOException
  23.  * @author wenqy
  24.  * @date 2020年1月18日 下午3:02:26
  25.  */
  26. private static void listFiles() throws IOException {
  27.     try (Stream<Path> stream = Files.list(Paths.get(“”))) {
  28.         String joined = stream
  29.             .map(String::valueOf)
  30.             .filter(path -> !path.startsWith(“.”))
  31.             .sorted()
  32.             .collect(Collectors.joining(“; “));
  33.         System.out.println(“List: “ + joined);
  34.         // 列出了当前工作目录的所有文件，之后将每个路径都映射为它的字符串表示。之后结果被过滤、排序，最后连接为一个字符串
  35.     }
  36. }
  38. /**
  39.  * 文件读写处理
  40.  * @throws IOException
  41.  * @author wenqy
  42.  * @date 2020年1月18日 下午3:02:52
  43.  */
  44. private static void handleFiles() throws IOException {
  45.     List<String> lines = Files.readAllLines(Paths.get(“res/nashorn1.js”)); // 整个文件都会读进内存,不高效。文件越大，所用的堆区也就越大
  46.     lines.add(“print(‘foobar’);”);
  47.     Files.write(Paths.get(“res/nashorn1-modified.js”), lines);
  49.     try (Stream<String> stream = Files.lines(Paths.get(“res/nashorn1.js”))) { // 行读取，高效点
  50.         stream
  51.             .filter(line -> line.contains(“print”))
  52.             .map(String::trim)
  53.             .forEach(System.out::println);
  54.     }
  56.     try (BufferedReader reader = Files.newBufferedReader(Paths.get(“res/nashorn1.js”))) { // BufferedReader 更精细
  57.         System.out.println(reader.readLine());
  58.     }
  60.     Path pathOut = Paths.get(“res/output.js”);
  61.     try (BufferedWriter writer = Files.newBufferedWriter(pathOut)) { // BufferedWriter 写入文件
  62.         writer.write(“print(‘Hello World’);”);
  63.     }
  65.     try (BufferedReader reader = Files.newBufferedReader(Paths.get(“res/nashorn1.js”))) {
  66.         long countPrints = reader
  67.             .lines() // 流式处理
  68.             .filter(line -> line.contains(“print”))
  69.             .count();
  70.         System.out.println(countPrints);
  71.     }
  72. }

避免 Null 检查

java8之前，如果是多层内嵌对象，需要多次判空，引入Optional 类型提高安全性

  1. public static void main(String[] args) {
  2.     Outer outer = new Outer();
  3.     if (outer != null && outer.nested != null && outer.nested.inner != null) {
  4.         System.out.println(outer.nested.inner.foo);
  5.     }
  7.     Optional.of(new Outer())
  8.         .map(Outer::getNested)
  9.         .map(Nested::getInner)
  10.         .map(Inner::getFoo)
  11.         .ifPresent(System.out::println);
  13.     Outer obj = new Outer();
  14.     resolve(() -> obj.getNested().getInner().getFoo())
  15.         .ifPresent(System.out::println);
  16.     // 这两个解决方案可能没有传统 null 检查那么高的性能
  17. }
  19. private static <T> Optional<T> resolve(Supplier<T> resolver) {
  20.     try {
  21.         T result = resolver.get();
  22.         return Optional.ofNullable(result);
  23.     }
  24.     catch (NullPointerException e) {
  25.         return Optional.empty();
  26.     }
  27. }

初识java8新特性，java8语法糖还是挺香的，java8之前方法调用一堆的回调，让人看的眼花缭乱，不整洁。但让人想吐槽的是调试，加难了调试力度，可能是新手错觉。。。

参考

https://github.com/winterbe/java8-tutorial java8教程

https://wizardforcel.gitbooks.io/modern-java/content/ 中文译站

https://github.com/wenqy/java-study

https://github.com/wenqy/java-study

小二，再来一碟

赏

One thought on “品茗Java8新特性”

发表评论

电子邮件地址不会被公开。 必填项已用*标注

7 + 14 = ?