Java7/8/9语法新特性

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/usher_ou/article/details/79904359

Java7/8/9语法新特性

Java7

Java7的新特性是相对于Java6而言的，增加的特性如下：

二进制变量的表示,支持将整数类型用二进制来表示，用0b开头。

    // 所有整数 int， short，long，byte都可以用二进制表示  
    // An 8-bit 'byte' value:  
    byte aByte = (byte) 0b00100001;  

    // A 16-bit 'short' value:  
    short aShort = (short) 0b1010000101000101;  

    // Some 32-bit 'int' values:  
    intanInt1 = 0b10100001010001011010000101000101;  
    intanInt2 = 0b101;  
    intanInt3 = 0B101; // The B can be upper or lower case.  

    // A 64-bit 'long' value. Note the "L" suffix:  
    long aLong = 0b1010000101000101101000010100010110100001010001011010000101000101L;  

    // 二进制在数组等的使用  
    final int[] phases = { 0b00110001, 0b01100010, 0b11000100, 0b10001001,  
    0b00010011, 0b00100110, 0b01001100, 0b10011000 };  

Switch语句支持string类型

switch (dayOfWeekArg) {  
             case "Monday":  
                 typeOfDay = "Start of work week";  
                 break;  
             case "Tuesday":  
             case "Wednesday":  
             case "Thursday":  
                 typeOfDay = "Midweek";  
                 break;  
             case "Friday":  
                 typeOfDay = "End of work week";  
                 break;  
             case "Saturday":  
             case "Sunday":  
                 typeOfDay = "Weekend";  
                 break;  
             default:  
                 throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeekArg);  
         }  

Try-with-resource语句

注意：实现java.lang.AutoCloseable接口的资源都可以放到try中，跟final里面的关闭资源类似； 按照声明逆序关闭资源 ;Try块抛出的异常通过Throwable.getSuppressed获取

try (java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);  
    java.io.BufferedWriter writer = java.nio.file.Files   
    .newBufferedWriter(outputFilePath, charset)) {  
    // Enumerate each entry  
    for (java.util.Enumeration entries = zf.entries(); entries  
    .hasMoreElements();) {  
    // Get the entry name and write it to the output file  
    String newLine = System.getProperty("line.separator");  
    String zipEntryName = ((java.util.zip.ZipEntry) entries  
    .nextElement()).getName() + newLine;  
    writer.write(zipEntryName, 0, zipEntryName.length());  
    }  
    }  

Catch多个异常

public static void main(String[] args) throws Exception {  
    try {  
    testthrows();  
    } catch (IOException | SQLException ex) {  
    throw ex;  
    }  
    }  
    public static void testthrows() throws IOException, SQLException {  
    }  

数字类型的下划线表示

    long creditCardNumber = 1234_5678_9012_3456L;  
    long socialSecurityNumber = 999_99_9999L;  
    float pi = 3.14_15F;  
    long hexBytes = 0xFF_EC_DE_5E;  
    long hexWords = 0xCAFE_BABE;  
    long maxLong = 0x7fff_ffff_ffff_ffffL;  
    byte nybbles = 0b0010_0101;  
    long bytes = 0b11010010_01101001_10010100_10010010;   

泛型实例的创建可以通过类型推断来简化 可以去掉后面new部分的泛型类型，只用<>

 //使用泛型前   
    List strList = new ArrayList();   
    List<String> strList4 = new ArrayList<String>();   
    List<Map<String, List<String>>> strList5 =  new ArrayList<Map<String, List<String>>>();  


    //编译器使用尖括号 (<>) 推断类型   
    List<String> strList0 = new ArrayList<String>();   
    List<Map<String, List<String>>> strList1 =  new ArrayList<Map<String, List<String>>>();   
    List<String> strList2 = new ArrayList<>();   
    List<Map<String, List<String>>> strList3 = new ArrayList<>();  
    List<String> list = new ArrayList<>();  
    list.add("A");  

在可变参数方法中传递非具体化参数,改进编译警告和错误

    List l = new ArrayList<Number>();  
    List<String> ls = l;       // unchecked warning  
    l.add(0, new Integer(42)); // another unchecked warning  
    String s = ls.get(0);      // ClassCastException is thrown  
    Jdk7:  
    public static <T> void addToList (List<T> listArg, T... elements) {  
    for (T x : elements) {  
    listArg.add(x);  
    }  
    }  
    /*
    你会得到一个warning  
    warning: [varargs] Possible heap pollution from parameterized vararg type  
    有三种方式消除警告
    1.加 annotation @SafeVarargs   
    2.加 annotation @SuppressWarnings({"unchecked", "varargs"})  
    3.使用编译器参数 –Xlint:varargs;  
    */

Java8

接口的默认方法

Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法

interface Formula {
    double calculate(int a);
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Lambda 表达式

Collections.sort(names, (String a, String b) -> b.compareTo(a));

函数式接口

每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。
们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

方法与构造函数引用

//指向静态方法的方法引用
public static void main(String[] args) {  
        String num="122";  
        int parse = parse(Integer::parseInt,num);  
        System.out.println(parse);  
    }  
    public static int parse(ToIntFunction<String> f,String num){  
        return f.applyAsInt(num);  
    }  

//指向任意类型实例方法的方法引用(这个实例长为方法的参数)

public static void main(String[] args) {  
        List<String> list = Arrays.asList("av","asdf","sad","324","43");  
        List<String> collect = list.stream().map(String::toUpperCase).collect(Collectors.toList());  
        System.out.println(collect);  
    }  

//指向现有对象的实例方法的方法引用(这个实例为外部对象)  
public static void main(String[] args) {  
        List<String> list = Arrays.asList("av","asdf","sad","324","43");  
        String a="avasdf";  
        List<String> collect = list.stream().filter(a::contains).collect(Collectors.toList());  
        System.out.println(collect);  
    } 

//构造引用
 private String color;  
private int weight;  
public Apple() {  
}  

public Apple(String color) {  
    super();  
    this.color = color;  
}  

public Apple(int weight) {  
    super();  
    this.weight = weight;  
}  

public Apple(String color, int weight) {  
    super();  
    this.color = color;  
    this.weight = weight;  
}  

@Override  
public String toString() {  
    return "Apple [color=" + color + ", weight=" + weight + "]";  
}

public static void main(String[] args) {  
        Apple instance1 = instance(11,Apple::new);  
    }  
    public static Apple instance(int a,IntFunction<Apple> ifu){  
        return ifu.apply(a);  
    }  

Stream

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

List<Integer> transactionsIds = 
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum(); 

Optional 类

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

//java.util.Optional<T> 类的声明
public final class Optional<T>
extends Object
//实例
import java.util.Optional;

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;
   }
}

Base64

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;

public class Java8Tester {
   public static void main(String args[]){
      try {

         // 使用基本编码
         String base64encodedString = Base64.getEncoder().encodeToString("runoob?java8".getBytes("utf-8"));
         System.out.println("Base64 比那么字符串 (基本) :" + base64encodedString);

         // 解码
         byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);

         System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));
         base64encodedString = Base64.getUrlEncoder().encodeToString("TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);

         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);

      }catch(UnsupportedEncodingException e){
         System.out.println("Error :" + e.getMessage());
      }
   }
}

Java9

Java 平台级模块系统

模块化的 JAR 文件都包含一个额外的模块描述器。在这个模块描述器中, 对其它模块的依赖是通过 “requires” 来表示的。另外, “exports” 语句控制着哪些包是可以被其它模块访问到的。所有不被导出的包默认都封装在模块的里面。如下是一个模块描述器的示例，存在于 “module-info.java” 文件中:

module blog {
 exports com.pluralsight.blog;

 requires cms;
}

当启动一个模块化应用时， JVM 会验证是否所有的模块都能使用

Linking

当你使用具有显式依赖关系的模块和模块化的 JDK 时，新的可能性出现了。你的应用程序模块现在将声明其对其他应用程序模块的依赖以及对其所使用的 JDK 模块的依赖。为什么不使用这些信息创建一个最小的运行时环境，其中只包含运行应用程序所需的那些模块呢？ 这可以通过 Java 9 中的新的 jlink 工具实现。你可以创建针对应用程序进行优化的最小运行时映像而不需要使用完全加载 JDK 安装版本。

JShell: 交互式 Java REPL

许多语言已经具有交互式编程环境，Java 现在加入了这个俱乐部。您可以从控制台启动 jshell ，并直接启动输入和执行 Java 代码。 jshell 的即时反馈使它成为探索 API 和尝试语言特性的好工具。

改进的 Javadoc

Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 HTML5 标准。此外，你会注意到，每个 Javadoc 页面都包含有关 JDK 模块类或接口来源的信息。

扫描二维码关注公众号，回复： 2894744 查看本文章

集合工厂方法

　Set ints = Set.of(1, 2, 3);
ist strings = List.of(“first”, “second”);
了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。 事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException” 。

改进的 Stream API

　Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable。还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代：

　IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println);
　第二个参数是一个 Lambda，它会在当前 IntStream 中的元素到达 100 的时候返回 true。因此这个简单的示例是向控制台打印 1 到 99。

　除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 stram 将一个 Optional 对象转换为一个(可能是空的) Stream 对象：

　Stream s = Optional.of(1).stream();
　在组合复杂的 Stream 管道时，将 Optional 转换为 Stream 非常有用。

私有接口方法

　Java 8 为我们带来了接口的默认方法。 接口现在也可以包含行为，而不仅仅是方法签名。 但是，如果在接口上有几个默认方法，代码几乎相同，会发生什么情况？ 通常，您将重构这些方法，调用一个可复用的私有方法。 但默认方法不能是私有的。 将复用代码创建为一个默认方法不是一个解决方案，因为该辅助方法会成为公共API的一部分。 使用 Java 9，您可以向接口添加私有辅助方法来解决此问题：

public interface MyInterface {

  void normalInterfaceMethod();

  default void interfaceMethodWithDefault() { init(); }

  default void anotherDefaultMethod() { init(); }

  // This method is not part of the public API exposed by MyInterface
  private void init() { System.out.println("Initializing"); }
}

HTTP/2

　Java 9 中有新的方式来处理 HTTP 调用。这个迟到的特性用于代替老旧的 HttpURLConnection API，并提供对 WebSocket 和 HTTP/2 的支持。注意：新的 HttpClient API 在 Java 9 中以所谓的孵化器模块交付。也就是说，这套 API 不能保证 100% 完成。不过你可以在 Java 9 中开始使用这套 API：

HttpClient client = HttpClient.newHttpClient();

HttpRequest req =
  HttpRequest.newBuilder(URI.create("http://www.google.com"))
       .header("User-Agent","Java")
       .GET()
       .build();

HttpResponse resp = client.send(req, HttpResponse.BodyHandler.asString());
除了这个简单的请求/响应模型之外，HttpClient 还提供了新的 API 来处理 HTTP/2 的特性，比如流和服务端推送。

多版本兼容 JAR

　多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本：

multirelease.jar
├── META-INF
│  └── versions
│    └── 9
│      └── multirelease
│        └── Helper.class
├── multirelease
  ├── Helper.class
  └── Main.class

　在上述场景中， multirelease.jar 可以在 Java 9 中使用, 不过 Helper 这个类使用的不是顶层的 multirelease.Helper 这个 class, 而是处在“META-INF/versions/9”下面的这个。这是特别为 Java 9 准备的 class 版本，可以运用 Java 9 所提供的特性和库。同时，在早期的 Java 诸版本中使用这个 JAR 也是能运行的，因为较老版本的 Java 只会看到顶层的这个 Helper 类