关于java:JAVA-18-新特性-Lamdba

Java8 劣势：速度快、代码更少（减少了新的语法 Lambda 表达式）、弱小的 Stream API、便于并行、最大化缩小空指针异样 Optional；

一、Lambda 表达式

Lambda 是一个匿名函数，咱们能够把 Lambda 表达式了解为是一段能够传递的代码（将代码像数据一样进行传递）。能够取代大部分的匿名外部类，能够写出更简洁、更灵便的代码。尤其在汇合的遍历和其余汇合操作中，能够极大地优化代码构造。作为一种更紧凑的代码格调，使 Java 的语言表达能力失去晋升。JDK 也提供了大量的内置函数式接口供咱们应用，使得 Lambda 表达式的使用更加不便、高效。
【1】从匿名类到 Lambda 的转换：尽管应用 Lambda 表达式能够对某些接口进行简略的实现，但并不是所有的接口都能够应用 Lambda 表达式来实现。Lambda 规定接口中只能有一个须要被实现的办法，不是规定接口中只能有一个办法。

jdk8 中有另一个新个性：default， 被 default 润饰的办法会有默认实现，不是必须被实现的办法，所以不影响 Lambda 表达式的应用。后续有专门的介绍。

<code class="java">//匿名类
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.printf("Hello World!");
    }
};
/**
 *1.简化参数类型，能够不写参数类型，然而必须所有参数都不写
 *2.简化参数小括号，如果只有一个参数则能够省略参数小括号
 *3.简化办法体大括号，如果办法条只有一条语句，则能够胜率办法体大括号（如下案例）
 *4.如果办法体只有一条语句，并且是 return 语句，则能够省略办法体大括号和rerun关键字：X x= a -> a+3;
 *Lambda 表达式展现：
 */
Runnable runnable2 = ()-> System.out.printf("Lambda 表达式");

【2】原来应用匿名外部类作为参数传递到 Lambda 表达式：

<code class="java">//原来应用匿名外部类作为参数传递
TreeSet ts = new TreeSet<>(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return Integer.compare(o1.length(),o2.length());
    }
});
//Lambda 表达式作为参数传递
TreeSet<String> ts2 = new TreeSet<>((o1,o2)-> Integer.compare(o1.length(),o2.length()));

【3】Lambda 表达式语法：Lambda 表达式在 Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个局部：

■ 左侧：指定了 Lambda 表达式须要的所有参数；
■ 右侧：指定了 Lambda 体，即 Lambda 表达式要执行的性能；

【语法格局一】：无参，无返回值，Lambda 体只须要一条语句；

<code class="java">Runnable runnable2 = ()-> System.out.printf("Lambda 表达式"); 

【语法格局二】：Lambda 须要一个参数；

<code class="java">Consumer<String> fun = (args) -> System.out.printf(args);

【语法格局三】：Lambda 只须要一个参数时，参数的小括号能够省略；

<code class="java">Consumer<String> fun = args -> System.out.printf(args);

【语法格局四】：Lambda 须要两个参数，并且有返回值；

<code class="java">BinaryOperator<Long> bo = (x,y)->{    System.out.printf("实现函数接口办法");    return x+y;};

【语法格局五】：当 Lambda 体只有一条语句时，return 与大括号能够省略；

<code class="java">BinaryOperator<Long> bo = (x,y) -> x+y;

【语法格局六】：数据类型能够省略，因为可由编译器推断得出，称为“类型推断”：依据上下文环境推断参数类型；

<code class="java">BinaryOperator<Long> bo = (Long x,Long y)->{    
    System.out.printf("实现函数接口办法");    
    return x+y;
};

【4】遍历汇合： 能够调用汇合的 forEach(Consumer<? super E> action) 办法，通过 lambda 表达式的形式遍历汇合中的元素。Consumer 接口是 jdk 为咱们提供的一个函数式接口。

<code class="java">ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 1,2,3,4,5);
//lambda表达式 办法援用
list.forEach(System.out::println);
list.forEach(element -> {
    if (element % 2 == 0) {
      System.out.println(element);
    }
});

【5】删除汇合：通过 removeIf(Predicate<? super E> filter) 办法来删除汇合中的某个元素，Predicate 也是 jdk 为咱们提供的一个函数式接口，能够简化程序的编写。

<code class="java">ArrayList<Item> items = new ArrayList<>();
Collections.addAll(list, 1,2,3,4,5);
items.removeIf(ele -> ele.getId() == 3);

【6】汇合内元素的排序：若要为汇合内的元素排序，就必须调用 sort 办法，传入比拟器匿名外部类重写 compare 办法，咱们当初能够应用 lambda 表达式来简化代码。

<code class="java">ArrayList<Item> list= new ArrayList<>();
Collections.addAll(list, 6,27,7,4,2);
list.sort((o1,o2) -> o1.getId() - o2.getId());

二、函数式接口

【1】只蕴含一个形象办法的接口，称为函数式接口；
【2】你能够通过 Lambda 表达式来创立该接口的对象。（若 Lambda 表达式抛出一个受检异样，那么该异样须要在指标接口的形象办法上进行申明）。
【3】咱们能够在任意函数式接口上应用 @FunctionalInterface 注解，这样做能够查看它是否是一个函数式接口，阐明这个接口是一个函数式接口。

<code class="java">@FunctionalInterface
public interface MyLambda<T> {
    public T getValue(T t);
}
public String toUpperString(MyLambda<String> mf, String str){
    return mf.getValue(str);
}
//为了将 Lambda 表达式作为参数传递，接管 Lambda 表达式的参数类型必须是与 Lambda 表达式兼容的函数式接口的类型
String newStr = toUpperString((str)-> str.toUpperCase(),"abcde");

【4】Java 内置四大外围函数式接口 ：

<code class="java">public class Java8Tester {
   public static void main(String args[]){
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n 是一个参数传递到 Predicate 接口的 test 办法
      // 如果 n%2 为 0 test 办法返回 true
      System.out.println("输入所有偶数:");
      eval(list, n-> n%2 == 0 );
   }
   public static void eval(List<Integer> list, Predicate<Integer> predicate) {
      for(Integer n: list) {
         if(predicate.test(n)) {
            System.out.println(n + " ");
         }
      }
   }
}

三、办法援用与结构器援用

【1】办法援用：当要传递给 Lambda 体的操作，曾经有实现的办法了，能够应用办法援用！（实现形象办法的参数列表，必须与办法援用中办法的参数列表保持一致！）办法援用：应用操作符 “::**” 将办法名和对象或类的名字分隔开来。如下三种次要应用状况：应用办法援用的时候须要保障援用办法的参数列表和返回值类型与咱们以后所要实现的函数式接口办法的参数列表和返回值类型保持一致
①、对象::实例办法；②、类::静态方法；③、类::实例办法**；

<code class="java">(x) -> System.out.println(x);
//等同于
System.out::println
BinaryOperator<Double> bo = (x,y) -> Math.pow(x,y);
//等同于
BinaryOperator<Double> bo = Math::pow;
compare((x,y) -> x.equals(y),"abcd","abcd");
//等同于
compare(String::equals,"abc","abc");(x) -> System.out.println(x);//等同于System.out::printlnBinaryOperator<Double> bo = (x,y) -> Math.pow(x,y);//等同于BinaryOperator<Double> bo = Math::pow;compare((x,y) -> x.equals(y),"abcd","abcd");//等同于compare(String::equals,"abc","abc");

留神：当须要援用办法的第一个参数是调用对象，并且第二个参数是须要援用办法的第二个参数(或无参数)时：

<code class="java">ClassName::methodName

【2】结构器援用： 格局： ClassName::new 与函数式接口相结合，主动与函数式接口中办法兼容。能够把结构器援用赋值给定义的办法，与结构器参数列表要与接口中形象办法的参数列表统一！调用哪个结构器取决于函数式接口中的办法形参的定义。咱们通过两种形式创建对象（无参和有参），具体如下：

<code class="java">//【案例一】无参结构器创建对象  应用Employee的无参结构器.
//应用 Supplier函数接口  因为 Supplier接口的形象办法没有入参 能够参考二中的函数式编程.
Supplier<Employee> sup = Employee::new;
//【案例二】有参结构器创建对象  应用Employee的有参结构器.
//应用 Function函数接口  因为 Function接口的形象办法有入参 能够参考二中的函数式编程.
Function<Integer,Employee> fun = (n) -> new MyClass(n);
//结构器利用革新后：
Function<Integer,Employee> fun = MyClass::new;

【3】数组援用： 同结构器援用，格局为 type[] :: new

<code class="java">Function<Integer,Integer[]> fun = (n) -> new Integer[n];
Function<Integer,Integer[]> fun = Integer[]::new;

四、Stream API

Java8 中有两大最为重要的扭转。第一个是 Lambda 表达式；另外一个则是 Stream API（java.util.stream.）。Stream 是 Java8 中解决汇合的要害抽象概念，它能够指定你心愿对汇合进行的操作，能够执行非常复杂的查找、过滤和映射数据等操作。应用Stream API 对汇合数据进行操作，就相似于应用 SQL 执行的数据库查问。也能够应用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于应用的解决数据的形式。
【1】Stream 到底是什么：**是数据渠道，用于操作数据源（汇合、数组等）所生成的元素序列。汇合讲的是数据，流讲的是计算！
【2】留神：①、Stream 本人不会存储数据。②、Stream 不会扭转源对象。相同，他们会返回一个持有后果的新 Stream。③、Stream 操作是提早执行的。这意味着他们会等到须要后果的时候才执行。
【3】**Stream 的操作三个步骤：①、创立 Stream 一个数据源（如：汇合、数组），获取一个流。 ②、两头操作：一个两头操作链，对数据源的数据进行解决。③、终止操作（终端操作）：一个终止操作，执行两头操作链，并产生后果：

<code class="java">default Stream<E> stream()//返回一个程序流；
default Stream<E> parallelStream()//返回一个并行流；
//举例
Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96};
numbers.stream().forEach(System.out::println);
});

【5】由数组创立流：Java8 中的 Arrays 的静态方法 stream() 能够获取数组流：static <T> Stream<T> stream(T[] array)：返回一个流；重载模式，可能解决对应根本类型的数组：

<code class="java">public static IntStream stream(int[] array) ；
public static LongStream stream(long[] array) ；
public static DoubleStream stream(double[] array)；
//举例
Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96};
long count = Arrays.stream(array).filter(i->i>20).count();

【6】由值创立流：能够应用静态方法 Stream.of()，通过显示值创立一个流。它能够接管任意数量的参数。

<code class="java">public static<T> Stream<T> of(T... values) : 返回一个流
//举例
Integer[] array = new Integer[]{3,4,8,16,19,27,23,99,76,232,33,96};
long count = Stream.of(array).filter(i->i>20).count();
long sum = Stream.of(12,77,59,3,654).filter(i->i>20).mapToInt(Integer::intValue).sum();

【7】由函数创立流：创立有限流，能够应用静态方法 Stream.iterate() 和 Stream.generate()，创立有限流。

<code class="java">public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f); //迭代
public static<T> Stream<T> generate(Supplier<T> s); //生成
//举例 iterate
Stream<BigInteger> bigIntStream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.TEN)).limit(10);
BigInteger[] bigIntArr = bigIntStream.toArray(BigInteger[]::new);
//输入：[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
System.out.println(Arrays.toString(bigIntArr));
//举例 generate
Stream<String> stream = Stream.generate(() -> "test").limit(10);
String[] strArr = stream.toArray(String[]::new);
//输入 [test, test, test, test, test, test, test, test, test, test]
System.out.println(Arrays.toString(strArr));

Stream 的两头操作：多个两头操作能够连接起来造成一个流水线，除非流水线上触发终止操作，否则两头操作不会执行任何的解决！而在终止操作时一次性全副解决，称为“惰性求值”。

【1】筛选与切片：

<code class="java">List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
for(Integer i:numbers){
    if(i>20){
        count++;
    }
}
//当应用 Stream 操作时  如下：
list.stream().filter(num -> num > 4).count();
//limit 应用：输入 [1, 2, 3, 4] 办法会返回一个蕴含n个元素的新的流（若总长小于n则返回原始流）
List<Integer> afterLimit = list .stream().limit(4).collect(Collectors.toList());
//skip(n) 应用：输入 [5, 6, 7, 8, 9] 与limit 正好相同，它会抛弃掉后面的n个元素。
List<Integer> afterSkip = list .stream().skip(4).collect(Collectors.toList());
//用limit和skip办法一起应用就能够实现日常的分页性能
List<Integer> pageList = myList.stream().skip(pageNumber*pageSize)
　　　　　　　　　　　　　　　　　　.limit(pageSize).collect(Collectors.toList());

【2】 映射：

<code class="java">List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
//将Integer类型转换成String类型
List<String> afterString = integerList.stream().map(i->String.valueOf(i)).collect(Collectors.toList());

【3】 排序：下面介绍的流的转换方法都是无状态的。即从一个曾经转换的流中取某个元素时，后果并不依赖于之前的元素。除此之外还有两个办法在转换流时是须要依赖于之前流中的元素的。一个是 distinct办法一个是 sorted办法。distinct办法会依据原始流中的元素返回一个具备雷同程序、去除了反复元素的流，这个操作显然是须要记住之前读取的元素。

<code class="java">//distinct
List<Integer> list = Arrays.asList(70, 25, 38, 64, 25, 46, 7, 18, 9);
List<Integer> distinctList = list.stream().distinct().collect(Collectors.toList());
//sorted 
List<Integer> sortList = myTestList.stream()
　　　　　　　　　　　　　　　　.sorted(Integer::compareTo).collect(Collectors.toList());

Stream 的聚合操作：终端操作会从流的流水线生成后果。其后果能够是任何不是流的值，例如：List、Integer，甚至是 void 。
【1】查找与匹配：

<code class="java">List<Integer> list = Arrays.asList(70, 125, 38, 64, 25, 46, 7, 18, 9);
//max 与 min 案例
Integer maxItem = list.stream().max(Integer::compareTo).get();
Integer minItem = list.stream().min(Integer::compareTo).get();
//findFirst:办法返回非空集合中的第一个值，它通常与filter办法联合起来应用。
Integer first = list.stream().filter(i->i>100).findFirst().get();
//findAny:能够在汇合中只有找到任何一个所匹配的元素，就返回，此办法在对流并行执行时非常无效（任何片段中发现第一个匹配元素都会完结计算，串行流中和findFirst返回一样)。
Integer anyItem = list.parallelStream().filter(i->i>100).findAny().get();
//anyMatch:能够断定汇合中是否还有匹配的元素。返回后果是一个boolean类型值。noneMatch 相同。
boolean isHas = list.parallelStream().anyMatch(i->i>100);
boolean noHas = hearList.parallelStream().noneMatch(i->i>100);

【2】 归约：

<code class="java">List<Integer> list = Arrays.asList(70, 125, 38, 64, 25, 46, 7, 18, 9);
//简化一下，对元素长度进行求和。
sum = list.stream().map(Objects::toString).mapToInt(String::length).sum();

备注：map 和 reduce 的连贯通常称为 map-reduce 模式，因 Google 用它来进行网络搜寻而出名。

【3】收集：当解决完流之后，通常是想查看一下后果，而不是将他们聚合为一个值。Collectorts 类为咱们提供了罕用的收集类的各个工厂办法。

Collector 接口中办法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。然而 Collectors 应用类提供了很多静态方法，能够不便地创立常见收集器实例，具体方法与实例如下表：

<code class="java">//例如后面的例子用的要将一个流收集到一个List中，只须要这样写就能够。
List<Integer> thereList = hereList.stream().collect(Collectors.toList());
//收集到Set中能够这样用
Set<Integer> thereSet = hereList.stream().collect(Collectors.toSet());
//将字流中的字符串连贯并收集起来。
String resultString = stringList.stream().collect(Collectors.joining());
//在将流中的字符串连贯并收集起来时，想在元素中介增加分隔符，传递个joining办法即可。
String resultString = stringList.stream().collect(Collectors.joining(","));
//总和、平均值，最大值，最小值
int sum = hereList.stream().collect(Collectors.summingInt(Integer::intValue));
Double ave = hereList.stream().collect(Collectors.averagingInt(Integer::intValue));
Integer max = hereList.stream().collect(Collectors.maxBy(Integer::compare)).get();
Integer min = hereList.stream().collect(Collectors.minBy(Integer::compare)).get();

【常见面试题】：将后果集收集到 Map；当咱们心愿将汇合中的元素收集到 Map中时，能够应用 Collectors.toMap办法。这个办法有两个参数，用来生成 Map的 key和 value。例如将一个 Form 对象的 high作为键 width作为值：每个 toMap办法，都会有一个对应的 toConCurrentMap办法，用来生成一个并发Map。

<code class="java">//筹备工作
List<Form> formList = Lists.newArrayList(
    new Form (3,4,5),
    new Form (6,5,3),
    new Form (77,43,55);
)
//Form对象的 high作为键 width作为值
Map<Integer,Integer> hwMap = formList.stream().collect(Collectors.toMap(Form::getHigh, Form::getWidth));
//然而通常还是以具体元素作为值的状况多，能够应用Function.identity()来获取理论元素。
Map<Integer,Form> FormMap = formList.stream().collect(Collectors.toMap(Form::getHigh, Function.identity()));
//如果多个元素领有雷同的键，在收集后果时会抛出java.lang.IllegalStateException异样。
//能够应用第三个参数来解决，第三个参数用来确定当呈现键抵触时，该如何处理结果，如果当呈现键抵触时只保留一个并且是保留曾经存在的值时，就是如下形式。
Map<Integer,Form> rMap = formList.stream().collect(Collectors.toMap(Form::getHigh, Function.identity(),(nowValue,newValue)->nowValue));
//如果想指定生成的 Map类型，则还须要第三个参数。
TreeMap<Integer,Form> FormTreeMap = FormList.stream().collect(Collectors.toMap(Form::getHigh,
　　　　　　　　　　　　Function.identity(),(nowValue,newValue)->newValue,TreeMap::new));
//******在一个汇合中，对具备雷同个性的值进行分组是一个很常见的性能，在Stream的API中也提供了相应的办法。
//依据 high 将 Form 进行分组
Map<Integer,List<Form>> groupMap = list .stream().collect(Collectors.groupingBy(Form::getHigh));
//当分类函数是一个返回布尔值的函数时，流元素会被分为两组列表：一组是返回true的元素汇合，另一组是返回false的元素汇合。这种状况实用 partitoningBy办法会比groupingBy更有效率。
Map<Boolean,List<Form>> partitionMap = list.stream().collect(Collectors.partitioningBy(form->form.getHigh()==22));
//例如咱们将房间汇合分为两组，一组是高度为22的房间，另一组是其余房间。
//mapping办法会将后果利用到另一个收集器上。如下取出分组中宽度最大的宽度。
Map<Integer, Optional<Integer>> collect = list.stream().collect(Collectors.groupingBy(Form::getHigh,
                Collectors.mapping(Form::getWidth,Collectors.maxBy(Comparator.comparing(Integer::valueOf)))));
//*****groupingBy是反对多级分组的。例如第一级咱们将依照高度分组，第二级依照宽度分组。
Map<Integer,Map<Integer,List<Form>>> multistageMap = list.stream().
        collect(Collectors.groupingBy(Form::getHigh,Collectors.groupingBy(Form::getWidth)));

并行流与串行流：并行流就是把一个内容分成多个数据块，并用不同的线程别离解决每个数据块的流。Java8 中将并行进行了优化，咱们能够很容易的对数据进行并行操作。Stream API 能够申明性地通过 parallel() 与 sequential() 在并行流与程序流之间进行切换。然而并行流在应用的时候也是须要留神的。首先，必须是一个并行流，只有在终止办法执行时，流处于并行模式，那么所有的流操作就都会并行执行。

<code class="java">Stream.of(roomList).parallel();

parallel 办法能够将任意的串行流转换为一个并行流。其次要确保传递给并行流操作的函数是线程平安的。

<code class="java">//上面这个例子中的代码就是谬误的，传递给并行流的操作并不是线程平安的。能够改为AtomicInteger的对象数组来作为计数器。
int[] words = new int[23];
Stream.of(roomList).parallel().forEach(s->{
     if(s.size()<10){
           words[s.size()]++;
     }
});

咱们使在解决汇合数据量较大的时候能力体现出并行流的劣势，并且目标是为了在保障线程平安的状况下，晋升效率，利用多核 CPU的资源。应用 Stream 的 API时，在遍历或解决流的过程中当援用内部变量的时候会默认的将变量当成 fianl变量来解决。所以有些同学就会感觉在遍历的过程中取不进去汇合的索引。其实能够换一种思维能够只遍历汇合索引，而后在遍历中取值。

<code class="java">IntStream.range(0,roomList.size()).forEach(i->{       System.out.println(roomList.get(i));});

Fork/Join 框架：就是在必要的状况下，将一个大工作，进行拆分(fork)成若干个小工作（拆到不可再拆时），再将一个个的小工作运算的后果进行 join 汇总。

Fork/Join 框架与传统线程池的区别：采纳 “工作窃取”模式（work-stealing）：当执行新的工作时它能够将其拆分分成更小的工作执行，并将小工作加到线程队列中，而后再从一个随机线程的队列中偷一个并把它放在本人的队列中。绝对于个别的线程池实现，fork/join 框架的劣势体现在对其中蕴含的工作的解决形式上.在个别的线程池中，如果一个线程正在执行的工作因为某些起因
无奈持续运行，那么该线程会处于期待状态。而在 fork/join 框架实现中，如果某个子问题因为期待另外一个子问题的实现而无奈持续运行。那么解决该子问题的线程会被动寻找其余尚未运行的子问题来执行。这种形式缩小了线程的等待时间，进步了性能。

五、接口中的默认办法与静态方法

Java8 中容许接口中蕴含具备具体实现的办法，该办法称为“默认办法”，默认办法应用 default 关键字润饰。例如：

<code class="java">interface MyFunc<T>{
    T func(int a);
    default String getName(){
        return "Hello Java8!";
    }
}

接口默认办法的 ”类优先” 准则：若一个接口中定义了一个默认办法，而另外一个父类或接口中又定义了一个同名的办法时。
【1】抉择父类中的办法。如果一个父类提供了具体的实现，那么接口中具备雷同名称和参数的默认办法会被疏忽。
【2】接口抵触。如果一个父接口提供一个默认办法，而另一个接口也提供了一个具备雷同名称和参数列表的办法（不论办法
是否是默认办法），那么必须笼罩该办法来解决抵触 。
【接口默认办法的”类优先”准则】：

<code class="java">interface MyFunc{
    default String getName(){
        return "Hello Java8!";
    }
}
interface Named(){
    default String getName(){
        return "Hello atguigu!";
    }
}
class MyClass implements MyFunc,Named{
    public String getName(){
        return Named.super.getName();
    }
}

【接口中的静态方法】：Java8 中，接口中容许增加静态方法；

<code class="java">interface Named{
    public Integer myFunc();
    default String getName(){
        return "Hello atguigu!";
    }
    static void show(){
        System.out.println("Hello Lambda!");
    }
}

六、新工夫日期 API

【1】LocalDate、LocalTime、LocalDateTime：的实例是不可变的对象，别离示意应用 ISO-8601 日期零碎的日期、工夫、日期和工夫。它提供了简略的日期或工夫，并不蕴含以后的工夫信息。也不蕴含与时区相干的信息。

【2】Instant 工夫戳：**用于 “工夫戳” 的运算。它是以 Unix 元年(传统的设定为UTC时区1970年1月1日午夜时候)开始所经验的形容进行运算；
【3】**Duration 和 Period：Duration：用于计算两个“工夫”距离；Period：用于计算两个“日期”距离；

<code class="java">Instant instant_1 = Instant.now();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
Instant instant_2 = Instant.now();
Duration duration = Duration.between(instant_1, instant_2);
System.out.println(duration.toMillis());
// 运行后果：1000
LocalTime localTime_1 = LocalTime.now();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
LocalTime localTime_2 = LocalTime.now();
System.out.println(Duration.between(localTime_1, localTime_2).toMillis());
// 运行后果：1000
LocalDate localDate_1 = LocalDate.of(2018,9, 9);
LocalDate localDate_2 = LocalDate.now();
Period period = Period.between(localDate_1, localDate_2);
System.out.println(period.getYears());      // 运行后果：1
System.out.println(period.getMonths());     // 运行后果：1
System.out.println(period.getDays());       // 运行后果：18

【4】日期的操纵： TemporalAdjuster：工夫校正器。有时咱们可能须要获取例如：将日期调整到“下个周日”等操作。TemporalAdjusters：该类通过静态方法提供了大量的罕用 TemporalAdjuster 的实现。例如获取下个周日：

<code class="java">LocalDate nextSunday = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.SUNDAY));//获取下个周日
LocalDateTime localDateTime1 = LocalDateTime.now();
System.out.println(localDateTime1);     // 2019-10-27T14:19:56.884
// 获取这个第一天的日期
System.out.println(localDateTime1.with(TemporalAdjusters.firstDayOfMonth()));            // 2019-10-01T14:22:58.574
// 获取下个周末的日期
System.out.println(localDateTime1.with(TemporalAdjusters.next(DayOfWeek.SUNDAY)));   

【5】解析与格式化：java.time.format.DateTimeFormatter 类：该类提供了三种格式化办法：
● 预约义的规范格局；
● 语言环境相干的格局；
● 自定义的格局；

<code class="java">DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ISO_DATE;
LocalDateTime localDateTime = LocalDateTime.now();
String strDate1 = localDateTime.format(dateTimeFormatter1);
System.out.println(strDate1);
// 运行后果：2019-10-27
// Date -> String
DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd  HH:mm:ss");
String strDate2 = dateTimeFormatter2.format(localDateTime);
System.out.println(strDate2);
// 运行后果：2019-10-27  14:36:11
// String -> Date
LocalDateTime localDateTime1 = localDateTime.parse(strDate2, dateTimeFormatter2);
System.out.println(localDateTime1);
// 运行后果：2019-10-27T14:37:39

【6】时区的解决：Java8 中退出了对时区的反对，带时区的工夫为别离为：ZonedDate、ZonedTime、ZonedDateTime 其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格局；例如 ：Asia/Shanghai 等；
● ZoneId：该类中蕴含了所有的时区信息；
● getAvailableZoneIds()：能够获取所有时区时区信息；
● of(id)：用指定的时区信息获取 ZoneId 对象；

<code class="java">// 获取所有的时区
Set<String> set = ZoneId.getAvailableZoneIds();
// 通过时区构建LocalDateTime
LocalDateTime localDateTime1 = LocalDateTime.now(ZoneId.of("America/El_Salvador"));
System.out.println(localDateTime1);
// 2019-10-27T00:46:21.268
// 以时区格局显示工夫
LocalDateTime localDateTime2 = LocalDateTime.now();
ZonedDateTime zonedDateTime1 = localDateTime2.atZone(ZoneId.of("Africa/Nairobi"));
System.out.println(zonedDateTime1);
// 2019-10-27T14:46:21.273+03:00[Africa/Nairobi]

【7】与传统日期解决的转换：

七、其余新个性

【1】Optional类：Optional<T> 类（java.util.Optional） 是一个容器类，代表一个值存在或不存在，原来用 null 示意一个值不存在，当初 Optional 能够更好的表白这个概念。并且能够防止空指针异样。罕用办法：
● Optional.of(T t)：创立一个 Optional 实例；
● Optional.empty()：创立一个空的 Optional 实例；
● Optional.ofNullable(T t)：若 t 不为 null,创立 Optional 实例,否则创立空实例；
● isPresent()：判断是否蕴含值；
● orElse(T t)：如果调用对象蕴含值，返回该值，否则返回t；
● orElseGet(Supplier s)：如果调用对象蕴含值，返回该值，否则返回 s 获取的值；
● map(Function f)：如果有值对其解决，并返回解决后的 Optional，否则返回 Optional.empty()；
● flatMap(Function mapper)：与 map 相似，要求返回值必须是Optional；

<code class="java">public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
      // Optional.ofNullable - 容许传递为 null 参数
      Optional<Integer> a = Optional.ofNullable(value1);
      // Optional.of - 如果传递的参数是 null，抛出异样 NullPointerException
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
   public Integer sum(Optional<Integer> a, Optional<Integer> b){
      // Optional.isPresent - 判断值是否存在
      System.out.println("第一个参数值存在: " + a.isPresent());
      System.out.println("第二个参数值存在: " + b.isPresent());
      // Optional.orElse - 如果值存在，返回它，否则返回默认值
      Integer value1 = a.orElse(new Integer(0));
      //Optional.get - 获取值，值须要存在
      Integer value2 = b.get();
      return value1 + value2;
   }
}
//输入后果:
第一个参数值存在: false
第二个参数值存在: true
10

【2】反复注解与类型注解：Java8 对注解解决提供了两点改良，可反复的注解及可用于类型的注解。如下自定义可反复注解：应用 @Repeatable 元注解，参数为可反复注解的容器。

<code class="java">@Repeatable(MyAnnotations.class)
@Target({ ElementType.TYPE, ElementType.FIELD, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "java8";
}
/**
 * 容器类
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RepetitionAnnotations {
    RepetitionAnnotation[] value();
}

【测试方法】

<code class="java">public class AnnotationTest {
    @Test
    public void t1() throws Exception {
        Class<AnnotationTest> clazz = AnnotationTest.class;
        Method method = clazz.getMethod("show");
        // 获取办法上的注解
        RepetitionAnnotation[] ras = method.getAnnotationsByType(RepetitionAnnotation.class);
        for (RepetitionAnnotation repetitionAnnotation : ras) {
            System.out.println(repetitionAnnotation.value());
        }
    }
    @RepetitionAnnotation("Hello")
    @RepetitionAnnotation("World")
    public void show() {
    }
}

【类型注解】

<code class="java">//就是向 @Target 增加一种类型 TYPE_PARAMETER
@Repeatable(RepetitionAnnotations.class)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface RepetitionAnnotation {
    String value() default "ling";
}
//应用
@RepetitionAnnotation("Hello")
@RepetitionAnnotation("World")
public void show(@RepetitionAnnotation String str) {}

文章起源：https://javajgs.com/archives/…

看到这里明天的分享就完结了，如果感觉这篇文章还不错，来个分享、点赞、在看三连吧，让更多的人也看到～

欢送关注集体公众号 「JavaClub」，定期为你分享一些技术干货。

喜欢 (0)赏

[搞代码]

分享 (0)