zoukankan      html  css  js  c++  java

  • Java 8的新特性还不了解？快进来！

    能坚持别人不能坚持的，才能拥有你想拥有的。
    关注 编程大道，让我们一起成长

    ​

    哈喽，大家好，我是walking，今天我们说说Java 8的新特性。

    Java 8从发布到现在已经6年多了，java 8在Java历史版本中是一个具有“里程碑”意义的重要版本，相信现在很多公司都用上了Java 8这个版本，用了之后你就知道为什么说是“里程碑”了，然后你会觉得“真香”！

    但是事情总不是那么绝对，我相信目前还有很多公司依然在用java 7甚至是java 6，相信也会有很多小伙伴即便是用上了java 8但是却还不知道它到底有哪些新的特性，那么今天就和大家一块看下java 8比起以往的版本到底有哪些新的特性。（文章内容过长，建议收藏）

    Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。

    0、新特性

    Java8 新增了非常多的特性，我们主要讨论以下几个：

    • Lambda 表达式 − Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。

    • 方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

    • 默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。

    • 新工具 − 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。

    • Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。

    • Date Time API − 加强对日期与时间的处理。

    • Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。

    • Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

    新的编码风格

    Java 8 希望有自己的编程风格，并与 Java 7 区别开，以下实例展示了 Java 7 和 Java 8 的编程格式：

    public class NewStyle {
    public static void main(String args[]) {
        List<String> names1 = Arrays.asList("TianMao", "CaiNiao", "TaoBao", "HeMa", "XianYu", "FeiZhu");
        List<String> names2 = Arrays.asList("TianMao", "CaiNiao", "TaoBao", "HeMa", "XianYu", "FeiZhu");
        System.out.println("使用 Java 7 语法: ");
        sortUsingJava7(names1);
        System.out.println(names1);
        System.out.println("使用 Java 8 语法: ");
        sortUsingJava8(names2);
        System.out.println(names2);
    }
    // 使用 java 7 排序
    private static void sortUsingJava7(List<String> names) {
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        });
    }
    // 使用 java 8 排序
    private static void sortUsingJava8(List<String> names) {
        Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
    }
}

    执行以上代码：

    使用 Java 7 语法: 
[CaiNiao, FeiZhu, HeMa, TaoBao, TianMao, XianYu]
使用 Java 8 语法: 
[CaiNiao, FeiZhu, HeMa, TaoBao, TianMao, XianYu]

    1、lambda表达式

    1.1 用法

    什么是lambda表达式，看下面的代码就知道了，首先对比我们之前的代码，创建线程对象时需要传入一个实现 Runnable 接口的对象，以往我们都是 new 一个 Runnable 对象然后实现接口的 run 方法（匿名内部类），那是用java8的lambda表达式就简洁多了，往下看，t2和t3的写法，这就是lambda表达式的写法。

    public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("t1 ==> old");
        }
    });

    Thread t2 = new Thread(()->System.out.println("t2 ==> lambda"));
    Thread t3 = new Thread(()-> {
        System.out.println("t3 ==> lambda");
        System.out.println("more code");
    });
}

    我们来细看一下， Thread t2 = new Thread(()->System.out.println("t2 ==> lambda")); 其中的 ()->System.out.println("t2 ==> lambda") 这句代码，我们来解释一下， () 是你要实现的方法的参数名列表，注意是参数名，不用指定参数类型，如果没有参数就写一个空括号。（可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。）
    对别t2和t3，当实现方法内部只有一行代码时可以直接写，如果多行代码，使用代码块的方式用{}包裹住，这是lambda的语法规定的。（可选的大括号：如果主体包含了一个语句，就不需要使用大括号）
    再看一下下面的代码

    public class Tester{
    public static void main(String[] args) {
        String str = "print content";
        Printer p1 = content -> System.out.println(content);
        p1.doPrint(str);

        Printer p2 = (String content) -> System.out.println(content);
        p2.doPrint(str);
    }
}
interface Printer{
    void doPrint(String content);
}

    其中 content -> System.out.println(content) ，前面的content变量名没有用()包裹，这是因为lambda其中一个特性，即，可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
    当然等价于(String content) -> System.out.println(content)（可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。）
    再看一下下面的代码

    public class Tester{
    public static void main(String[] args) {
        Judge judge = ()->1>2;

        Judge judge2 = ()->{
            System.out.println("judge...");
            return 1>2;
        };
    }
}    
interface Judge{
    boolean doJudge();
}

    我们定义的接口方法 doJudge() 返回参数是 boolean ，我们在实现接口方法是是这样写的， ()->1>2 ，不需要特别写 return 关键字，因为我们的表达式 1>2 的结果和该方法的返回类型一样，编译器会自动返回。（可选的返回关键字：如果主体只有一个表达式返回值，则编译器会自动返回值，否则需要显示返回值。）

    总结一下Lambda的重要特征:
    • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
    • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
    • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
    • 可选的返回关键字：如果主体只有一个表达式返回值，则编译器会自动返回值，否则需要显示返回值。


    使用 Lambda 表达式需要注意以下两点：
    • Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。
    • Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

    1.2 变量作用域

    lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

    ​

    lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义），否则会报错

    ​

    访问成员变量则没有这种限制，不必为final

    ​

    在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量，否则编译不通过

    2、方法引用

    2.1 介绍

    方法引用通过方法的名字来指向一个方法。
    方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
    方法引用使用一对冒号 :: 。

    2.2 用法

    下面，我们在 Sky 类中定义了 4 个方法作为例子来区分 Java 中 4 种不同方法的引用。

    @FunctionalInterface
public interface Supplier<T> {
    T get();
}
class Sky {
    private String color;
    //Supplier是jdk1.8的接口，这里和lambda一起使用了
    public static Sky create(final Supplier<Sky> supplier) {
        return supplier.get();
    }
    //静态方法，有参
    public static void collide(final Sky car) {
        System.out.println("Collided " + car.toString());
    }
    //成员方法，有参
    public void follow(final Sky another) {
        System.out.println("Following the " + another.toString());
    }
    //成员方法，无参
    public void repair() {
        System.out.println("Repaired " + this.toString());
    }
    //getter and setter
    //toString
}

    我们来看一下怎么用的

    public static void main(String[] args) {
    //构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
    final Sky sky = Sky.create( Sky::new );
    sky.setColor("red");
    final List<Sky> skys = Arrays.asList(sky);
    //静态方法引用：它的语法是Class::static_method，实例如下：
    skys.forEach(Sky::collide);
    //特定类的任意对象的方法引用：它的语法是Class::method实例如下：
    skys.forEach(Sky::repair);
    //特定对象的方法引用：它的语法是instance::method实例如下：
    final Sky sky2 = Sky.create(Sky::new);
    skys.forEach(sky2::follow);
}

    final Sky sky= Sky.create(Sky::new)等价于final Sky sky1= Sky.create(()->new Sky());

    ​

    3、函数式接口

    3.1 介绍

    函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
    函数式接口可以被隐式转换为 lambda 表达式。
    Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。
    如定义了一个函数式接口如下：

    @FunctionalInterface
interface Animal{
    void barks();
}

    那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：
    Animal cat= ()-> System.out.println("miao miao~");
    函数式接口可以对现有的函数友好地支持 lambda。
    JDK 1.8 之前已有的函数式接口:
    • java.lang.Runnable
    • java.util.concurrent.Callable
    • java.security.PrivilegedAction
    • java.util.Comparator
    • java.io.FileFilter
    • java.nio.file.PathMatcher
    • java.lang.reflect.InvocationHandler
    • java.beans.PropertyChangeListener
    • java.awt.event.ActionListener
    • javax.swing.event.ChangeListener
    JDK 1.8 新增加了很多函数接口，主要在 java.util.function 包下，用来支持 Java的 函数式编程，该包中的函数式接口有：

    序号 接口 & 描述
    1 BiConsumer<T,U>

    代表了一个接受两个输入参数的操作，并且不返回任何结果
    2 BiFunction<T,U,R>

    代表了一个接受两个输入参数的方法，并且返回一个结果
    3 BinaryOperator<T>

    代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
    4 BiPredicate<T,U>

    代表了一个两个参数的boolean值方法
    5 BooleanSupplier

    代表了boolean值结果的提供方
    6 Consumer<T>

    代表了接受一个输入参数并且无返回的操作
    7 DoubleBinaryOperator

    代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
    8 DoubleConsumer

    代表一个接受double值参数的操作，并且不返回结果。
    9 DoubleFunction<R>

    代表接受一个double值参数的方法，并且返回结果
    10 DoublePredicate

    代表一个拥有double值参数的boolean值方法
    11 DoubleSupplier

    代表一个double值结构的提供方
    12 DoubleToIntFunction

    接受一个double类型输入，返回一个int类型结果。
    13 DoubleToLongFunction

    接受一个double类型输入，返回一个long类型结果
    14 DoubleUnaryOperator

    接受一个参数同为类型double,返回值类型也为double 。
    15 Function<T,R>

    接受一个输入参数，返回一个结果。
    16 IntBinaryOperator

    接受两个参数同为类型int,返回值类型也为int 。
    17 IntConsumer

    接受一个int类型的输入参数，无返回值 。
    18 IntFunction<R>

    接受一个int类型输入参数，返回一个结果 。
    19 IntPredicate

    ：接受一个int输入参数，返回一个布尔值的结果。
    20 IntSupplier

    无参数，返回一个int类型结果。
    21 IntToDoubleFunction

    接受一个int类型输入，返回一个double类型结果 。
    22 IntToLongFunction

    接受一个int类型输入，返回一个long类型结果。
    23 IntUnaryOperator

    接受一个参数同为类型int,返回值类型也为int 。
    24 LongBinaryOperator

    接受两个参数同为类型long,返回值类型也为long。
    25 LongConsumer

    接受一个long类型的输入参数，无返回值。
    26 LongFunction<R>

    接受一个long类型输入参数，返回一个结果。
    27 LongPredicate

    R接受一个long输入参数，返回一个布尔值类型结果。
    28 LongSupplier

    无参数，返回一个结果long类型的值。
    29 LongToDoubleFunction

    接受一个long类型输入，返回一个double类型结果。
    30 LongToIntFunction

    接受一个long类型输入，返回一个int类型结果。
    31 LongUnaryOperator

    接受一个参数同为类型long,返回值类型也为long。
    32 ObjDoubleConsumer<T>

    接受一个object类型和一个double类型的输入参数，无返回值。
    33 ObjIntConsumer<T>

    接受一个object类型和一个int类型的输入参数，无返回值。
    34 ObjLongConsumer<T>

    接受一个object类型和一个long类型的输入参数，无返回值。
    35 Predicate<T>

    接受一个输入参数，返回一个布尔值结果。
    36 Supplier<T>

    无参数，返回一个结果。
    37 ToDoubleBiFunction<T,U>

    接受两个输入参数，返回一个double类型结果
    38 ToDoubleFunction<T>

    接受一个输入参数，返回一个double类型结果
    39 ToIntBiFunction<T,U>

    接受两个输入参数，返回一个int类型结果。
    40 ToIntFunction<T>

    接受一个输入参数，返回一个int类型结果。
    41 ToLongBiFunction<T,U>

    接受两个输入参数，返回一个long类型结果。
    42 ToLongFunction<T>

    接受一个输入参数，返回一个long类型结果。
    43 UnaryOperator<T>

    接受一个参数为类型T,返回值类型也为T。

    3.2 用法

    Predicate接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。
    该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。
    该接口用于测试对象是 true 或 false。
    我们可以通过以下实例（Java8Tester.java）来了解函数式接口 Predicate的使用：

    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> predicate = n -> true
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // n 如果存在则 test 方法返回 true
        System.out.println("输出所有数据:");
        eval(list, n -> true);
        // Predicate<Integer> predicate1 = n -> n%2 == 0
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // 如果 n%2 为 0 test 方法返回 true
        System.out.println("输出所有偶数:");
        eval(list, n -> n % 2 == 0);
        // Predicate<Integer> predicate2 = n -> n > 3
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // 如果 n 大于 3 test 方法返回 true
        System.out.println("输出大于 3 的所有数字:");
        eval(list, n -> n > 3);
    }
    public static void eval(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer n : list) {
            if (predicate.test(n)) {
                System.out.print(n + " ");
            }
        }
        System.out.println();
    }
}

    输出

    输出所有数据:
1 2 3 4 5 6 7 8 9 
输出所有偶数:
2 4 6 8
输出大于 3 的所有数字:
4 5 6 7 8 9

    4、默认方法

    4.1 介绍

    Java 8 新增了接口的默认方法。简单来说，默认方法就是接口定义的方法可以有一个默认的实现，而且不需要实现类去实现其方法。我们只需在方法名前面加个 default 关键字即可实现默认方法。

    为什么要有这个特性？
    首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

    4.2 用法

    默认方法语法格式如下：

    public interface Car {
   default void print(){
      System.out.println("我是一辆汽车!");
   }
}

    多个默认方法

    一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法：

    public interface Car {
   default void print(){
      System.out.println("我是一辆汽车!");
   }
}
public interface ElectricallyDriven {
   default void print(){
      System.out.println("我需要电力驱动!");
   }
}

    第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：

    public class ElectricallyDrivenCar implements Car, ElectricallyDriven {
   default void print(){
      System.out.println("我是一辆电动汽车!");
   }
}

    第二种解决方案可以使用 super 来调用指定接口的默认方法：

    public class ElectricallyDrivenCar implements Car, ElectricallyDriven {
   public void print(){
      ElectricallyDriven.super.print();
   }
}

    静态默认方法

    Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：

    public interface Car {
   default void print(){
      System.out.println("我是一辆汽车!");
   }
   // 静态方法
   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}

    默认方法实例

    我们可以通过以下代码来了解关于默认方法的使用，可以将代码放入 DefaultMethodTest.java 文件中：

    public class DefaultMethodTest {
   public static void main(String args[]){
        Car electricallyDrivenCar = new ElectricallyDrivenCar();
        electricallyDrivenCar.print();
        System.out.println("=================");
        Car.blowHorn();
   }
}

interface Car {
   default void print(){
      System.out.println("我是一辆汽车!");
   }

   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}

interface ElectricallyDriven {
   default void print(){
      System.out.println("我需要电力驱动!");
   }
}

class ElectricallyDrivenCar implements Car, ElectricallyDriven {
   public void print(){
      Car.super.print();
      ElectricallyDriven.super.print();
      Car.blowHorn();
      System.out.println("我是一辆电力驱动的汽车!");
   }
}

    执行以上脚本，输出结果为：

    我是一辆汽车!
我需要电力驱动!
按喇叭!!!
我是一辆电力驱动的汽车!
=================
按喇叭!!!

    5、Optional

    5.1 介绍

    Optio是一种容器对象，它内部可以认为只有一个字段，那就是你传入的值，这个值可以为空也可以不为空，这个类可以理解为是一个包装类，内部提供了很多判断和操作目标对象的方法。

    ​

    例如，isPresent()方法，如果值存在则该方法会返回true，调用get()方法会返回该对象。
    Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，帮我们很好的解决空指针异常，这样我们就不用显式进行空值检测。

    5.2 类方法

    以下是Optional的方法：

    序号 方法 & 描述
    1 static <T> Optional<T> empty()

    返回空的 Optional 实例。
    2 boolean equals(Object obj)

    判断其他对象是否等于 Optional。
    3 Optional<T> filter(Predicate<? super <T> predicate)

    如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
    4 <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)

    如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional
    5 T get()

    如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException
    6 int hashCode()

    返回存在值的哈希码，如果值不存在 返回 0。
    7 void ifPresent(Consumer<? super T> consumer)

    如果值存在则使用该值调用 consumer , 否则不做任何事情。
    8 boolean isPresent()

    如果值存在则方法会返回true，否则返回 false。
    9 <U>Optional<U> map(Function<? super T,? extends U> mapper)

    如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。
    10 static <T> Optional<T> of(T value)

    返回一个指定非null值的Optional。
    11 static <T> Optional<T> ofNullable(T value)

    如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。
    12 T orElse(T other)

    如果存在该值，返回值， 否则返回 other。
    13 T orElseGet(Supplier<? extends T> other)

    如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。
    14 <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)

    如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
    15 String toString()

    返回一个Optional的非空字符串，用来调试

    5.3 用法

    public class User{
    String name;
    int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //equals and toString
}

    我们先来看一下of() 、ofNullable() 、equals() 、toString()方法

    public static void main(String args[]) {
    User walking = new User("walking", 18);
    User walking2 = new User("walking", 18);
    //of 返回一个指定非null值的Optional。如果传递的参数是 null，抛出异常 NullPointerException
    Optional<User> walkingOp = Optional.of(walking);

    //ofNullable 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。允许传递为 null 参数
    Optional<User> walking2Op = Optional.ofNullable(walking2);
    //equals 判断其他对象是否等于 Optional
    boolean equals = walkingOp.equals(walking2Op);
    System.out.println("两个optional的值是否一样：" + equals);
    //toString 返回一个Optional的非空字符串，用来调试
    System.out.println("Optional的toString:" + walkingOp.toString());
}

    控制台输出：

    两个optional的值是否一样：true
Optional的toString:Optional[User{name='walking', age=18}]

    我们再来看一下filter()，isPresent()，ifPresent(Consumer<? super T> consumer)方法

    public static void main(String args[]) {
    Optional<User> walkingOp = Optional.of(new User("walking", 18));
    //filter 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
    Optional<User> userOptional = walkingOp.filter(user -> user.age == 30);
    System.out.println("filter后:" + userOptional.toString());

    //isPresent 如果值存在则方法会返回true，否则返回 false。
    System.out.println("是否匹配:" + userOptional.isPresent());

    //ifPresent 如果值存在则使用该值调用 consumer , 否则不做任何事情。
    userOptional.ifPresent(user -> System.out.println("user==>" + user));
}

    控制台输出：

    filter后:Optional.empty
是否匹配:false

    以上代码可以判断Optional中的值是否满足我们filter的条件，很显然isPresent()返回false即不满足filter中的条件，所以ifPresent(Consumer<? super T> consumer)中传入的函数也就不会执行。
    然后再看一下map()方法

    public static void main(String args[]) {
    Optional<User> walkingOp = Optional.of(new User("walking", 18));
    //map 如果walkingOp有值，则对其执行调用传入的函数得到返回值。
    // 如果返回值不为 null(现在我们返回的是new User("new walking-20", 20))，则创建包含该返回值的Optional作为map方法返回值，否则返回空Optional。
    Optional<User> userOptional1 = walkingOp.map(user -> new User("new walking-20", 20));
    //walkingOP不为空，执行了函数，那么返回一个包含该值的Optional
    System.out.println("包含返回值的Optional：" + userOptional1);

    //现在函数返回值是null，则返回空Optional
    Optional<User> userOptional2 = walkingOp.map(user -> null);
    //walkingOP不为空，执行了函数，但函数返回值为空，那么返回一个空Optional
    System.out.println("空Optional：" + userOptional2.toString());

    Optional<User> nilOptional = Optional.ofNullable(null);
    Optional<User> userOptional3 = nilOptional.map(user -> new User("原optional为空", 22));
    //原optional为空，不会执行函数，返回的Optional为空
    System.out.println("原optional为空:" + userOptional3.toString());
}

    控制台：

    包含返回值的Optional：Optional[User{name='new walking-20', age=20}]
空Optional：Optional.empty
原optional为空:Optional.empty

    然后再来看一下orElse()、orElseGet()、orElseThrow()方法

    public static void main(String args[]) {
    Optional<User> nilOptional = Optional.ofNullable(null);
    //orElse 如果存在该值，返回值， 否则返回 other。
    User u = nilOptional.orElse(new User("new walking-20", 20));
    System.out.println("nilOptional无值，返回传入的对象：" + u);
    Optional<User> userOptional4 = Optional.of(new User("new walking-90", 90));
    User user = userOptional4.orElse(new User("new walking-91", 91));
    System.out.println("userOptional4有值，返回其值：" + user);
    //orElseGet 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。
    User ss = nilOptional.orElseGet(() -> new User("new walking-99", 99));
    System.out.println("nilOptional无值，返回函数的返回值:" + ss);
    //orElseThrow 如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
    User user1 = nilOptional.orElseThrow(() -> new NullPointerException("nilOptional为空 执行函数返回的异常"));
    System.out.println("nilOptional为空，返回值为空:" + user1);
}

    控制台：

    nilOptional无值，返回传入的对象：User{name='new walking-20', age=20}
userOptional4有值，返回其值：User{name='new walking-90', age=90}
nilOptional无值，返回函数的返回值:User{name='new walking-99', age=99}
Exception in thread "main" java.lang.NullPointerException: nilOptional为空 执行函数返回的异常
    at com.walking.java8.OptionalTest.lambda$main$1(OptionalTest.java:27)
    at java.util.Optional.orElseThrow(Optional.java:290)
    at com.walking.java8.OptionalTest.main(OptionalTest.java:27)

    6、日期时间 API

    Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。
    在旧版的 Java 中，日期时间 API 存在诸多问题，其中有：

    • 非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。

    • 设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。

    • 时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。

    Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：

    • Local(本地) − 简化了日期时间的处理，没有时区的问题。

    • Zoned(时区) − 通过制定的时区处理日期时间。
      新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。

    6.1 本地化日期时间 API

    LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况。代码如下：

    public static void main(String[] args) {
    // 获取当前的日期时间
    LocalDateTime currentTime = LocalDateTime.now();
    System.out.println("当前时间: " + currentTime);
    //获取当前日期
    LocalDate date1 = currentTime.toLocalDate();
    System.out.println("date1: " + date1);
    //获取当前时间
    LocalTime localTime = currentTime.toLocalTime();
    System.out.println("time1: "+localTime);
    int year = currentTime.getYear();
    Month month = currentTime.getMonth();
    int day = currentTime.getDayOfMonth();
    int hour = currentTime.getHour();
    int minute = currentTime.getMinute();
    int seconds = currentTime.getSecond();
    System.out.println("年:"+year+", 月: " + month.getValue() +", 日: " + day +",时:"+hour+",分: "+minute+", 秒: " + seconds);
    //修改天，修改年
    LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2018);
    System.out.println("date2: " + date2);
    // 2017 5 1
    LocalDate date3 = LocalDate.of(2017, Month.MAY, 1);
    System.out.println("date3: " + date3);
    // 18 小时 20 分钟
    LocalTime time2 = LocalTime.of(18, 20);
    System.out.println("time2: " + time2);
    // 解析字符串
    LocalTime time3 = LocalTime.parse("19:50:40");
    System.out.println("time3: " + time3);
}

    输出：

    当前时间: 2020-08-15T18:28:27.273
date1: 2020-08-15
time1: 18:28:27.273
年:2020, 月: 8, 日: 15,时:18,分: 28, 秒: 27
date2: 2018-08-10T18:28:27.273
date3: 2017-05-01
time2: 18:20
time3: 19:50:40

    6.2 使用时区的日期时间API

    如果我们需要考虑到时区，就可以使用时区的日期时间API：

    public static void main(String[] args) {
    // 获取当前的时间日期
    ZonedDateTime now = ZonedDateTime.now();
    System.out.println("当前时间日期: "+now.toString());
    // 获取指定的时间日期
    ZonedDateTime date1 = ZonedDateTime.parse("2020-08-15T18:15:30+05:30[Asia/Shanghai]");
    System.out.println("指定时间日期: " + date1);
    ZoneId id = ZoneId.of("Asia/Tokyo");
    System.out.println("ZoneId: " + id);
    ZoneId currentZone = ZoneId.systemDefault();
    System.out.println("当期时区: " + currentZone);
}

    控制台：

    当前时间日期: 2020-08-15T18:42:47.706+08:00[Asia/Shanghai]
指定时间日期: 2020-08-15T18:15:30+08:00[Asia/Shanghai]
ZoneId: Asia/Tokyo
当期时区: Asia/Shanghai

    6.3 日期格式化

    public class DateTimeUtil{
    public static void main(String[] args) {
        //不带时间的日期
        String output1 = formattedDate("2019年07月15日", "yyyy年MM月dd日", "yyyy-MM-dd");
        String output2 = formattedDate("2019/07/16", "yyyy/MM/dd", "yyyy-MM-dd");
        String output3 = formattedDate("2019-07-16", "yyyy-MM-dd", "yyyy/MM/dd");
        System.out.println(output1);
        System.out.println(output2);
        System.out.println(output3);
        //带时间的日期
        String output4 = formattedDateTime("20190713000000", "yyyyMMddHHmmss", "yyyy-MM-dd");
        String output5 = formattedDateTime("20190713000000", "yyyyMMddHHmmss", "yyyy-MM-dd HH:mm:ss");
        String output6 = formattedDateTime("2019年07月14日00时00分00秒", "yyyy年MM月dd日HH时mm分ss秒",
                "yyyy/MM/dd");
        String output7 = formattedDateTime("2019年07月14日00时00分00秒", "yyyy年MM月dd日HH时mm分ss秒",
                "yyyyMMddHHmmss");
        String output8 = formattedDateTime("2019-07-15 00:00:00", "yyyy-MM-dd HH:mm:ss", "yyyyMMdd");
        String output9 = formattedDateTime("2019-07-15 00:00:00", "yyyy-MM-dd HH:mm:ss",
                "yyyy年MM月dd日HH时mm分ss");
        System.out.println(output4);
        System.out.println(output5);
        System.out.println(output6);
        System.out.println(output7);
        System.out.println(output8);
        System.out.println(output9);
    }
    /**
     * 不带时分秒的日期字符串转化
     *
     * @param input 输入的日期
     * @param inputFormat 输入日期的格式
     * @param outputFormat 输出日期的格式
     * @return 输出的日期，不带时分秒
     */
    public static String formattedDate(String input, String inputFormat, String outputFormat) {
        DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern(inputFormat);
        LocalDate localDate = LocalDate.parse(input, inputFormatter);
        DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern(outputFormat);
        return localDate.format(outputFormatter);
    }
    /**
     * 带时分秒的日期字符串转换
     *
     * @param input 输入的日期
     * @param inputFormat 输入日期的格式
     * @param outputFormat 输出日期的格式
     * @return 输出指定格式的日期，可以带时分秒，也可以不带
     */
    public static String formattedDateTime(String input, String inputFormat, String outputFormat) {
        DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern(inputFormat);
        LocalDateTime localDateTime = LocalDateTime.parse(input, inputFormatter);
        DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern(outputFormat);
        return localDateTime.format(outputFormatter);
    }
}

    6.4 Date和LocalDateTime互转

    /**
 * LocalDateTime -> Date
 */
public static Date toDate(LocalDateTime localDateTime) {
    ZoneId zoneId = ZoneId.systemDefault();
    ZonedDateTime zdt = localDateTime.atZone(zoneId);
    return Date.from(zdt.toInstant());
}
/**
 * Date -> LocalDateTime
 */
public static LocalDateTime toLocalDateTime(Date date) {
    Instant instant = date.toInstant();
    ZoneId zoneId = ZoneId.systemDefault();
    return instant.atZone(zoneId).toLocalDateTime();
}

    7、Base64

    7.1 介绍

    在Java 8中，Base64编码已经成为Java类库的标准。
    Java 8 内置了 Base64 编码的编码器和解码器。
    Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

    • 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。

    • URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。

    • MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用' '并跟随' '作为分割。编码输出最后没有行分割。

    7.2 用法

    public static void main(String args[]){
    try {
        // 使用基本编码
        String base64encodedString = Base64.getEncoder().encodeToString("walking@2020".getBytes("utf-8"));
        System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);
        // 解码
        byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
        System.out.println("Base64 编码字符串 (基本) : " + new String(base64decodedBytes, "utf-8"));
        base64encodedString = Base64.getUrlEncoder().encodeToString("walking@2020".getBytes("utf-8"));
        System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);
        byte[] decode = Base64.getUrlDecoder().decode(base64encodedString.getBytes("utf-8"));
        System.out.println("Base64 解码字符串 (URL) :"+new String(decode,"utf-8"));
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 10; ++i) {
            stringBuilder.append(UUID.randomUUID().toString());
        }
        byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
        String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
        System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);
        byte[] decode1 = Base64.getMimeDecoder().decode(mimeEncodedString.getBytes("utf-8"));
        System.out.println("Base64 解码字符串 (MIME) :"+new String(decode1,"utf-8"));
    }catch(UnsupportedEncodingException e){
        System.out.println("Error :" + e.getMessage());
    }
}

    控制台输出：

    Base64 编码字符串 (基本) :d2Fsa2luZ0AyMDIw
Base64 编码字符串 (基本) : walking@2020
Base64 编码字符串 (URL) :d2Fsa2luZ0AyMDIw
Base64 解码字符串 (URL) :walking@2020
Base64 编码字符串 (MIME) :N2NlZWQ2MzAtYTZiYy00NWIwLWE1OGItNzE5NzcxYTcxOGUxYzU3ODY2ZDItMTY4OC00YjczLWE5
YTEtNTFkZTViMTJlOWY4YTM2NjBkY2YtOGFjZC00M2EyLWJkNTEtMDY5Y2I3NjI2OTVjY2Q0MGI5
MzYtNjEyMC00MDBhLWIzMGEtMjU1MGQzNGQ2ODAxMDk1NzAxYTAtYjk3Yy00NTE5LTk3ZDItYzdj
MDYyM2EzZDNkNDk4MWFiYjMtZDg4Yi00NTk2LWI4MzYtMjQ5Y2RkODg5NDQ5ZWNlMDY5ZjctMzdh
Mi00ZTc3LTgxNmQtZjI2MzliMGJhMGYwM2M5OWI4NWUtMzZjOS00NjgxLWE5ZTktYjdjNTAwOTlm
YWMwZjQzOTI3YTctY2Y3ZS00ZDFhLWIxYzQtOWY1ODFkMzliY2Y1ZjYyMjM3YTUtOGI2Zi00N2Iw
LWJmNzctYjJiODJiOGM3ZDQx
Base64 解码字符串 (MIME) :7ceed630-a6bc-45b0-a58b-719771a718e1c57866d2-1688-4b73-a9a1-51de5b12e9f8a3660dcf-8acd-43a2-bd51-069cb762695ccd40b936-6120-400a-b30a-2550d34d6801095701a0-b97c-4519-97d2-c7c0623a3d3d4981abb3-d88b-4596-b836-249cdd889449ece069f7-37a2-4e77-816d-f2639b0ba0f03c99b85e-36c9-4681-a9e9-b7c50099fac0f43927a7-cf7e-4d1a-b1c4-9f581d39bcf5f62237a5-8b6f-47b0-bf77-b2b82b8c7d41

    8、Nashorn JavaScript引擎

    8.1 介绍

    Nashorn是一个 javascript 引擎。
    从JDK 1.8开始，Nashorn取代Rhino(JDK 1.6, JDK1.7)成为Java的嵌入式JavaScript引擎。Nashorn完全支持ECMAScript 5.1规范以及一些扩展。它使用基于JSR 292的新语言特性，其中包含在JDK 7中引入的 invokedynamic，将JavaScript编译成Java字节码。与先前的Rhino实现相比，这带来了2到10倍的性能提升。
    jjs是个基于Nashorn引擎的命令行工具。它接受一些JavaScript源代码为参数，并且执行这些源代码

    8.2 用法

    交互式编程： 打开CMD命令窗口，输入jjs回车即可进入jjs环境，然后输入print("hello world!!")，回车

    ​

    传递参数： 输入 jjs -- a b c 回车，然后输入 print("连接："+arguments.jion(", ")) 回车

    ​

    执行javascript文件：我们在E盘新建test.js文件，打开文件键入： print("walking is a dashuaibi") ，打开CMD窗口进入到同目录下，输入 jjs test.js 回车

    ​

    Java调用JavaScript
    示例代码

    public static void main(String args[]){
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
    String name = "walking";
    try {
        nashorn.eval("print('" + name + "')");
        Integer result = (Integer) nashorn.eval("1 + 1");
        System.out.println(result);
        boolean re = (boolean) nashorn.eval("1 > 2");
        System.out.println(re);
    }catch(ScriptException e){
        e.printStackTrace();
    }
}

    输出

    walking
2
false

    JavaScript 中调用 Java

    以下实例演示了如何在 JavaScript 中引用 Java 类，创建JSCallJava.js文件，内容如下：

    var HashMap = Java.type('java.util.HashMap');
function getHashMap(name, age) {
   var result = new HashMap();
   result.put("name",name);
   result.put("age",age);

   return result;
}
var result = getHashMap("编程大道",18);
print(result);

    然后我们执行 jjs JSCallJava.js 回车

    ​

    往期热文：

    ​

    觉得好看，请点赞哦~

    觉得好看，请 点赞、关注、转发 哦~
    关注公众号 编程大道 ，第一时间获文章推送。
  • 相关阅读:
    mssql 2008 数据库可疑
    sss
    css 浏览器兼容 重置代码
    .net 接口与 foreach必要条件
    .net获取ip
    flash与js的通信
    WebService传输文件的几个知识点
    【前端】深入浅出Javascript中的数值转换
    ［前端］代理知识入门介绍
    Hello 博客园！ ---致我人生中的第一篇随笔
  • 原文地址：https://www.cnblogs.com/ibigboy/p/13536378.html
Copyright © 2011-2022 走看看