http://www.ox-holdings.com

不少使用 Java,2、字符串加强Java 11

摘要美国时间2018年 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本。概述美国时间2018年09 月 25 日,Oralce 正式发布了 Java 11,这是 Java 8 发布以后支持的首个长期版本。为什么说是长期版本,看下面的官方发布的支持路线图表:可以看出 Java 8 扩展支持到 2025 年,而 Java 11 扩展支持到 2026 年。现在大部分都在用 Java 8,Java 9 和 10 目前很少有人在用,至少我没有发现有公司在生产环境应用的,那就是找死。现在 Java 11 长期支持,也已经包含了 9 和 10 的全部功能,9 和 10 自然就活到头了。。那么我们来看下 从 Java 9 - 11 都有哪些重要的新特性呢?1、本地变量类型推断这个博主已经写过一篇文章,详细的介绍了 Java 10 带来的这个新特性。什么是局部变量类型推断?varjavastack="javastack";System.out.println(javastack);大家看出来了,局部变量类型推断就是左边的类型直接使用 var 定义,而不用写具体的类型,编译器能根据右边的表达式自动推断类型,如上面的 String 。varjavastack="javastack";就等于:Stringjavastack="javastack";更多使用详情请参考这篇文章《Java 10 实战第 1 篇:局部变量类型推断》,这里不再重复了。2、字符串加强Java 11 增加了一系列的字符串处理方法,如以下所示。//判断字符串是否为空白"".isBlank(); //true//去除首尾空格"Javastack".strip(); //"Javastack"//去除尾部空格"Javastack".stripTrailing(); //"Javastack"//去除首部空格"Javastack".stripLeading(); //"Javastack"//复制字符串"Java".repeat(3);//"JavaJavaJava"//行数统计"AnBnC".lines().count();//33、集合加强自 Java 9 开始,Jdk 里面为集合(List/ Set/ Map)都添加了 of 和 copyOf 方法,它们两个都用来创建不可变的集合,来看下它们的使用和区别。示例1:varlist=List.of("Java","Python","C");varcopy=List.copyOf(list);System.out.println(list==copy);//true示例2:varlist=newArrayList<String>();varcopy=List.copyOf(list);System.out.println(list==copy);//false来看下它们的源码:static<E>List<E>of(E...elements){switch(elements.length){//implicitnullcheckofelementscase0:returnImmutableCollections.emptyList();case1:returnnewImmutableCollections.List12<>(elements[0]);case2:returnnewImmutableCollections.List12<>(elements[0],elements[1]);default:returnnewImmutableCollections.ListN<>(elements);}}static<E>List<E>copyOf(Collection<?extendsE>coll){returnImmutableCollections.listCopy(coll);}static<E>List<E>listCopy(Collection<?extendsE>coll){if(collinstanceofAbstractImmutableList&&coll.getClass()!=SubList.class){return(List<E>)coll;}else{return(List<E>)List.of(coll.toArray());}}可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的,如果是,就直接返回,如果不是,则调用 of 创建一个新的集合。示例2因为用的 new 创建的集合,不属于不可变 AbstractImmutableList 类的子类,所以 copyOf 方法又创建了一个新的实例,所以为false.注意:使用 of 和 copyOf 创建的集合为不可变集合,不能进行添加、删除、替换、排序等操作,不然会报 java.lang.UnsupportedOperationException 异常。上面演示了 List 的 of 和 copyOf 方法,Set 和 Map 接口都有。4、Stream 加强Stream 是 Java 8 中的新特性,Java 9 开始对 Stream 增加了以下 4 个新方法。1) 增加单个参数构造方法,可为nullStream.ofNullable(null).count();//02) 增加 takeWhile 和 dropWhile 方法Stream.of(1,2,3,2,1).takeWhile(n->n<3).collect(Collectors.toList());//[1,2]从开始计算,当 n < 3 时就截止。Stream.of(1,2,3,2,1).dropWhile(n->n<3).collect(Collectors.toList());//[3,2,1]这个和上面的相反,一旦 n < 3 不成立就开始计算。3)iterate重载这个 iterate 方法的新重载方法,可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。如果你对 JDK 8 中的 Stream 还不熟悉,可以看之前分享的这一系列教程。5、Optional 加强Opthonal 也增加了几个非常酷的方法,现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。Optional.of("javastack").orElseThrow();//javastackOptional.of("javastack").stream().count();//1Optional.ofNullable(null).or(()->Optional.of("javastack")).get();//javastack6、InputStream 加强InputStream 终于有了一个非常有用的方法:transferTo,可以用来将数据直接传输到 OutputStream,这是在处理原始数据流时非常常见的一种用法,如下示例。varclassLoader=ClassLoader.getSystemClassLoader();varinputStream=classLoader.getResourceAsStream("javastack.txt");varjavastack=File.createTempFile("javastack2","txt");try(varoutputStream=newFileOutputStream(javastack)){inputStream.transferTo(outputStream);}7、HTTP Client API这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API,该 API 支持同步和异步,而在 Java 11 中已经为正式可用状态,你可以在 java.net 包中找到这个 API。

Java11又出新版本了,我还在Java8上停着。不过这也挡不住我对他的热爱,忍不住查看了一下他的新性能,由于自己知识有限,只总结了以下八个特性;

美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本。

去年,Java 开发工具包11刚刚到来,JDK 12 就在紧密敲锣筹备中,随着消息接连不断地爆出,不少使用 Java 的开发者开始有种一年一万个更新版本的错觉,而当面对厚厚的一堆堆 Java 8/9/10/11 的入门书籍和教程时,就问你怕不怕?不仅如此,就在 Java 早已在移动 App、服务器应用、Web 开发、J2EE 企业级应用和嵌入式等领域根深蒂固时,Oracle 于近日最新发布的一纸 Java 用户使用协议轰动了整个业界,因为 Java 将收费了!

1、本地变量类型推断

为什么说是长期版本,看下面的官方发布的支持路线图表。

1.JDK 11 不容错过的那些新特性

什么是局部变量类型推断?

图片 1image

JDK 11 作为 Oracle 以六个月为更新周期之后公开发布的第一个长期支持版本,其中还是有许多实用的功能特性。

    var javastack = "javastack";    System.out.println(javastack);

可以看出 Java 8 扩展支持到 2025 年,而 Java 11 扩展支持到 2026 年。

局部变量推断

大家看出来了,局部变量类型推断就是左边的类型直接使用 var 定义,而不用写具体的类型,编译器能根据右边的表达式自动推断类型,如上面的 String 。

现在大部分都在用 Java 8,Java 9 和 10 目前很少有人在用,至少我没有发现有公司在生产环境应用的,那就是找死。

Java 10 引入了新的关键字 var,可以在定义局部变量时代替类型信息(局部指的是在方法体内部的变量定义)。

    var javastack = "javastack";    就等于:    String javastack = "javastack";

现在 Java 11 长期支持,也已经包含了 9 和 10 的全部功能,9 和 10 自然就活到头了。。

在 Java 10 之前,局部变量必须这样定义:

2、字符串加强

那么我们来看下 从 Java 9 - 11 都有哪些重要的新特性呢?

String text = "Hello Java 9";

Java 11 增加了一系列的字符串处理方法,如以下所示。

这个博主已经写过一篇文章,详细的介绍了 Java 10 带来的这个新特性。

而现在可以用 var 代替 String。编译器会根据变量的赋值推断出正确的类型。因此,text 的类型是 String:

    // 判断字符串是否为空白    " ".isBlank(); // true    // 去除首尾空格    " Javastack ".strip(); // "Javastack"    // 去除尾部空格    " Javastack ".stripTrailing(); // " Javastack"    // 去除首部空格    " Javastack ".stripLeading(); // "Javastack "    // 复制字符串    "Java".repeat;// "JavaJavaJava"    // 行数统计    "AnBnC".lines; // 3

什么是局部变量类型推断?

var text = "Hello Java 10";

3、集合加强
自 Java 9 开始,Jdk 里面为集合(List/ Set/ Map)都添加了 of 和 copyOf 方法,它们两个都用来创建不可变的集合,来看下它们的使用和区别。
示例1:

var javastack = "javastack";System.out.println(javastack);

使用 var 定义的变量依然是静态类型。这种变量不能重新用不兼容的类型赋值。比如,下面的代码无法通过编译:

    var list = List.of("Java", "Python", "C");    var copy = List.copyOf;    System.out.println(list == copy); // true

大家看出来了,局部变量类型推断就是左边的类型直接使用 var 定义,而不用写具体的类型,编译器能根据右边的表达式自动推断类型,如上面的 String

var text = "Hello Java 11";

text = 23; // Incompatible types

示例2:

var javastack = "javastack";

还可以通过同时使用 var 和 final 来禁止变量的重新赋值:

    var list = new ArrayList<String>();    var copy = List.copyOf;    System.out.println(list == copy); // false

就等于:

final var text = "Banana";

text = "Joe"; // Cannot assign a value to final variable 'text'

示例1和2代码差不多,为什么一个为true,一个为false?
来看下它们的源码:

String javastack = "javastack";

而且,当编译器无法推断出正确类型时也不允许使用 var:

    static <E> List<E> of(E... elements) {      switch (elements.length) { // implicit null check of elements        case 0:            return ImmutableCollections.emptyList();        case 1:            return new ImmutableCollections.List12<>(elements[0]);        case 2:            return new ImmutableCollections.List12<>(elements[0], elements[1]);        default:            return new ImmutableCollections.ListN<>;      }    }    static <E> List<E> copyOf(Collection<? extends E> coll) {        return ImmutableCollections.listCopy;    }    static <E> List<E> listCopy(Collection<? extends E> coll) {        if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {            return (List<E>)coll;        } else {            return (List<E>)List.of(coll.toArray;        }    }

更多使用详情请参考这篇文章《Java 10 实战第 1 篇:局部变量类型推断》,这里不再重复了。

// Cannot infer type:

var a;

var nothing = null;

var lambda = () -> System.out.println;

var method = this::someMethod;

可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的,如果是,就直接返回,如果不是,则调用 of 创建一个新的集合。
示例2因为用的 new 创建的集合,不属于不可变 AbstractImmutableList 类的子类,所以 copyOf 方法又创建了一个新的实例,所以为false.
注意:使用of和copyOf创建的集合为不可变集合,不能进行添加、删除、替换、排序等操作,不然会报 java.lang.UnsupportedOperationException 异常。
上面演示了 List 的 of 和 copyOf 方法,Set 和 Map 接口都有。

Java 11 增加了一系列的字符串处理方法,如以下所示。

局部变量类型的推断在泛型中非常有用。下面的例子中,current 有个非常复杂的类型 Map<String, List<Integer>>,而这个类型可以简化成一个 var 关键字,节省了很多敲代码的时间:

4、Stream 加强

// 判断字符串是否为空白" ".isBlank(); // true// 去除首尾空格" Javastack ".strip(); // "Javastack"// 去除尾部空格 " Javastack ".stripTrailing(); // " Javastack"// 去除首部空格 " Javastack ".stripLeading(); // "Javastack "// 复制字符串"Java".repeat; // "JavaJavaJava"// 行数统计"AnBnC".lines; // 3

var myList = new ArrayList>>();

for (var current : myList) {

// current is infered to type: Map>

System.out.println;

}

Stream 是 Java 8 中的新特性,Java 9 开始对 Stream 增加了以下 4 个新方法。
1) 增加单个参数构造方法,可为null

自 Java 9 开始,Jdk 里面为集合(List/ Set/ Map)都添加了 ofcopyOf 方法,它们两个都用来创建不可变的集合,来看下它们的使用和区别。

由于 Java 11 的 var 关键字也可以在 lambda 的参数上使用,因此可以给参数加注解:

Stream.ofNullable(null).count(); // 0

示例1:

Predicate predicate = (@Nullable var a) -> true;

2) 增加 takeWhile 和 dropWhile 方法

var list = List.of("Java", "Python", "C");var copy = List.copyOf;System.out.println(list == copy); // true

小提示:Intellij IDEA 中可以按住 CMD/CTRL 键并将鼠标悬停在变量上来查看推断出的类型(键盘快捷键为Ctrl+J)。

    Stream.of(1, 2, 3, 2, 1)    .takeWhile(n -> n < 3)    .collect(Collectors.toList; // [1, 2]

示例2:

HTTP 客户端

从开始计算,当 n < 3 时就截止。

var list = new ArrayList<String>();var copy = List.copyOf;System.out.println(list == copy); // false

Java 9 引入了新的 HttpClient API 来处理 HTTP 请求。在 Java 11 中,这个 API 已稳定,可以通过 java.net 包使用。我们来看看这个 API 能干什么。

Stream.of(1, 2, 3, 2, 1).dropWhile(n -> n < 3).collect(Collectors.toList; // [3, 2, 1]

示例1和2代码差不多,为什么一个为true,一个为false?

新的 HttpClient 支持同步和异步方式。同步请求会阻塞当前线程直到响应返回。BodyHandlers 定义了期待的响应体的类型(如字符串、字节数组或文件):

这个和上面的相反,一旦 n < 3 不成立就开始计算。

来看下它们的源码:

var request = HttpRequest.newBuilder()

.uri(URI.create(""))

.GET()

.build();

var client = HttpClient.newHttpClient();

HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString;

System.out.println(response.body;

郑重声明:本文版权归新匍京a奥门-最全网站手机版app官方下载所有,转载文章仅为传播更多信息之目的,如作者信息标记有误,请第一时间联系我们修改或删除,多谢。