Java 9 的新特性
Java 9 中有哪些不得不说的新特性?
二、JDK 和 JRE 目录结构的改变
JDK 8 的目录结构
JDK 9 的目录结构
三、模块化系统: Jigsaw → Modularity
四、Java的REPL工具: jShell命令
调出jShell
获取帮助
基本使用
五、语法改进:接口的私有方法
Java 8中规定接口中的方法除了抽象方法之外,还可以定义静态方法和默认的方法。一定程度上,扩展了接口的功能,此时的接口更像是一个抽象类。
在Java 9中,接口更加的灵活和强大,连方法的访问权限修饰符都可以声明为private的了,此时方法将不会成为你对外暴露的API的一部分。
interface MyInterface {
void normalInterfaceMethod();
default void methodDefault1() {
init();
}
public default void methodDefault2() {
init();//在接口内部调用私有方法
}
// This method is not part of the public API exposed by MyInterface
private void init() {
System.out.println("默认方法中的通用操作");
}
}
class MyInterfaceImpl implements MyInterface {
@Override
public void normalInterfaceMethod() {
System.out.println("实现接口的方法");
}
}
public class MyInterfaceTest {
public static void main(String[] args) {
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.methodDefault1();
// impl.init();//不能调用
}
}
语法改进:钻石操作符使用升级
我们将能够与匿名实现类共同使用钻石操作符(diamond operator)在Java 8
中如下的操作是会报错的,Java 9中如下操作可以正常执行通过:
Comparator<Object> com = new Comparator<>(){
@Override
public int compare(Object o1, Object o2) {
return 0;
}
};
编译报错信息:Cannot use “<>” with anonymous inner classes
六、语法改进:try语句
java8之前:
public static void main(String[] args) {
InputStreamReader reader = null;
try {
reader = new InputStreamReader(System.in);
char[] cbuf = new char[20];
int len;
if ((len = reader.read(cbuf)) != -1) {
String str = new String(cbuf, 0, len);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (reader != null)
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Java 8 中,可以实现资源的自动关闭,但是要求执行后必须关闭的所有资源必须在try子句中初始化,否则编译不通过。如下例所示:
public static void main(String[] args) {
try (InputStreamReader reader = new InputStreamReader(System.in)) {
char[] cbuf = new char[20];
int len;
if ((len = reader.read(cbuf)) != -1) {
String str = new String(cbuf, 0, len);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
ava 9 中,用资源语句编写try将更容易,我们可以在try子句中使用已经初始化过的资源,此时的资源是final的:
public static void main(String[] args) {
InputStreamReader reader = new InputStreamReader(System.in);
try(reader) {
char[] cbuf = new char[20];
int len;
if ((len = reader.read(cbuf)) != -1) {
String str = new String(cbuf, 0, len);
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
七、String存储结构变更
八、集合工厂方法:快速创建只读集合
//java8中的写法:
@Test
public void test1() {
List<String> namesList = new ArrayList<>();
namesList.add("Joe");
namesList.add("Bob");
namesList.add("Bill");
//返回的namesList是一个只读的集合
namesList = Collections.unmodifiableList(namesList);
namesList.add("Tom");
System.out.println(namesList);
}
@Test
public void test2() {
List<String> list = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));
Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));
// 如下操作不适用于jdk 8 及之前版本,适用于jdk 9
Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() {
{
put("a", 1);
put("b", 2);
put("c", 3);
}
});
map.forEach((k, v) -> System.out.println(k + ":" + v));
}
@Test
public void test3() {
//此时得到的集合list也是一个只读集合。
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
//报异常
list.add(6);
}
//java9新特性八:集合工厂方法:创建只读集合
@Test
public void test4() {
List<Integer> list1 = List.of(1, 2, 3, 4, 5);
//不能添加
// list1.add(6);
System.out.println(list1);
Set<Integer> set1 = Set.of(23, 3, 54, 65, 43, 76, 87, 34, 46);
//不能添加
// set1.add(4);
System.out.println(set1);
Map<String, Integer> map1 = Map.of("Tom", 23, "Jerry", 54, "HanMeimei", 12);
//不能添加
//map1.put("Lilei",34);
System.out.println(map1);
Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 34), Map.entry("Jerry", 21));
// map2.put("Lilei",34);
System.out.println(map2);
}
九、InputStream 加强
//java9新特性九:InputStream的新方法:tranferTo()
@Test
public void test5() {
ClassLoader cl = this.getClass().getClassLoader();
try (InputStream is = cl.getResourceAsStream("hello.txt");
OutputStream os = new FileOutputStream("src\\hello1.txt")) {
is.transferTo(os); // 把输入流中的所有数据直接自动地复制到输出流中
} catch (IOException e) {
e.printStackTrace();
}
}
十、增强的 Stream API
takeWhile() 与dropWhile()
@Test
public void test1(){
List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);
//takeWhile 返回从开头开始的按照指定规则尽量多的元素
// list.stream().takeWhile(x -> x < 60).forEach(System.out::println);//23 43 45 55
//dropWhile():与 takeWhile 相反,返回剩余的元素。
list.stream().dropWhile(x -> x < 60).forEach(System.out::println);//61 54 32 2 45 89 7
}
ofNullable()的使用
Java 8 中 Stream 不能完全为null,否则会报空指针异常。而 Java 9 中的 ofNullable 方法允许我们创建一个单元素 Stream,可以包含一个非空元素,也可以创建一个空Stream。
@Test
public void test2(){
//of()参数中的多个元素,可以包含null值
Stream<Integer> stream1 = Stream.of(1, 2, 3,null);
stream1.forEach(System.out::println);//1 2 3 null
//of()参数不能存储单个null值。否则,报异常
// Stream<Object> stream2 = Stream.of(null);
// stream2.forEach(System.out::println);
//这种被允许
//Stream<Object> stream2 = Stream.of(null,null);
Integer i = 10;
i = null;
//ofNullable():形参变量是可以为null值的单个元素
Stream<Integer> stream3 = Stream.ofNullable(i);
long count = stream3.count();
System.out.println(count);//0
}
iterate()重载的使用
这个 iterate 方法的新重载方法,可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。
@Test
public void test3(){
Stream.iterate(0,x -> x + 1).limit(10).forEach(System.out::println);
//java9中新增的重载的方法:可以加具体非限制条件这里是小于100
Stream.iterate(0,x -> x < 100,x -> x + 1).forEach(System.out::println);
}
十一、Optional获取Stream的方法
Optional类中stream()的使用
@Test
public void test4(){
List<String> list = new ArrayList<>();
list.add("Tom");
list.add("Jerry");
list.add("Tim");
Optional<List<String>> optional = Optional.ofNullable(list);
Stream<List<String>> stream = optional.stream();
// long count = stream.count();
// System.out.println(count);//1 list作为一个元素
stream.flatMap(x -> x.stream()).forEach(System.out::println);
}
十二、Javascript引擎升级:Nashorn
Java 10 新特性
局部变量类型推断
/*
java10新特性一:局部变量的类型推断
*/
@Test
public void test1() {
//1.声明变量时,根据所附的值,推断变量的类型
var num = 10;
var list = new ArrayList<Integer>();
list.add(123);
//2.遍历操作
for (var i : list) {
System.out.println(i);
System.out.println(i.getClass());
}
//3.普通的遍历操作
for (var i = 0; i < 100; i++) {
System.out.println(i);
}
}
@Test
public void test2() {
//1.局部变量不赋值,就不能实现类型推断
// var num ;
//2.lambda表示式中,左边的函数式接口不能声明为var
// Supplier<Double> sup = () -> Math.random();
// var sup = () -> Math.random();
//3.方法引用中,左边的函数式接口不能声明为var
// Consumer<String> con = System.out::println;
// var con = System.out::println;
//4.数组的静态初始化中,注意如下的情况也不可以
int[] arr = {1, 2, 3, 4};
// var arr = {1,2,3,4};
}
@Test
public void test3() {
// 情况1:没有初始化的局部变量声明
// var s = null;
// 情况6:catch块
// try{
//
// }catch(var e){
// e.printStackTrace();
// }
}
//情况2:方法的返回类型
// public var method1(){
//
return 0;
// }
// 情况3:方法的参数类型
// public void method2(var num){
//
// }
//情况4:构造器的参数类型
// public Java10Test(var i){
//
// }
//情况5:属性
// var num;
@Test
public void test4() {
try {
var url = new URL("http://www.atguigu.com");
var connection = url.openConnection();
var reader = new BufferedReader(
new InputStreamReader(connection.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
}
集合新增创建不可变集合的方法
//java10的新特性二:集合中新增的copyOf(),用于创建一个只读的集合
@Test
public void test5(){
//示例1:
var list1 = List.of("Java", "Python", "C");
var copy1 = List.copyOf(list1);
System.out.println(list1 == copy1); // true
//示例2:
var list2 = new ArrayList<String>();
list2.add("aaa");
var copy2 = List.copyOf(list2);
System.out.println(list2 == copy2); // false
示例1和2代码基本一致,为什么一个为true,一个为false?
结论:copyOf(Xxx coll):如果参数coll本身就是一个只读集合,则copyOf()返回值即为当前的coll
如果参数coll不是一个只读集合,则copyOf()返回一个新的集合,这个集合是只读的。
源码:
// make a copy, short-circuiting based on implementation class
@SuppressWarnings("unchecked")
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 11 新特性
一、新增了一系列字符串处理方法
//java 11新特性一:String中新增的方法
@Test
public void test1(){
// isBlank():判断字符串是否为空白
System.out.println(" \t \t \n ".isBlank());
// strip():去除首尾空白
System.out.println("-----" + " \t abc \t \n ".strip() + "-------");
System.out.println("-----" + " \t abc \t \n ".trim() + "-------");
// stripTrailing():去除尾部空格
System.out.println("-----" + " \t abc \t \n ".stripTrailing() + "-------");
// stripLeading():去除首部空格
System.out.println("-----" + " \t abc \t \n ".stripLeading() + "-------");
// repeat(int count):复制字符串
String str1 = "abc";
String str2 = str1.repeat(5);
System.out.println(str2);
// lines().count():行数统计
String str3 = "abc\ndef\ng";
System.out.println(str3.lines().count());
}
二、Optional 加强
//java11新特性二:Optional新增的方法
@Test
public void test6(){
var op = Optional.empty();
System.out.println(op.isPresent());//false //判断内部的value是否存在
System.out.println(op.isEmpty());//true //判断内部的value是否存在
op = Optional.of("abc");
//orElseThrow():value非空,返回value;否则抛异常NoSuchElmentException
var obj = op.orElseThrow();
System.out.println(obj);//abc
Optional<String> op1 = Optional.of("hello");
//or:value非空,返回对应的Optional;value为空,返回形参封装的Optional
//这里op调用or 如果op的value不为空 就直接返回op,为空就返回op1
Optional<Object> op2 = op.or(() -> op1);
System.out.println(op2);//Optional[abc]
}
跟jdk8中orElse的区别:
这里返回的是容器,而orElse返回的是value.
三、局部变量类型推断升级
在var上添加注解的语法格式,在jdk10中是不能实现的。在JDK11中加入了这样的语法。
//错误的形式: 必须要有类型, 可以加上var
//Consumer<String> con1 = (@Deprecated t) -> System.out.println(t.toUpperCase());
//正确的形式:
//使用var的好处是在使用lambda表达式时给参数加上注解。
Consumer<String> con2 = (@Deprecated var t) -> System.out.println(t.toUpperCase());
四、全新的HTTP 客户端API
五、更简化的编译运行程序
六、废弃Nashorn引擎
废除Nashorn javascript引擎,在后续版本准备移除掉,有需要的
可以考虑使用GraalVM
七、ZGC