JDK9 新特性
最重要的就是支持模块化编程，和接口私有方法
例子中提供服务的 module-info.java 文件 项目A
/**
*
* 1 一个项目，或者说一个jar包只能被属于一个模块，
* 2 如果没有配置模块就是全部使用(没有配置包含2种，引用方和被引用方)
* 3 使用模块相当于值暴露一部分需要对外提供服务的类，没有暴露的类不可见（我有两个包，A,B，但是值暴露A，那么引用方如果也使用模块化管理，就只能看到A，看不到B）
* 4 jdk9 以后 所有的 java jar包前面都爆了一层 moduleName
* 5 可以认为模块是 一个jar包下面，一组对外暴露服务的包 的别名
* 6 一般模块的命名就是 这些包的公共前缀，或者公共前缀+能代表这些包的一个名字
*
* @author ZHANGYUKUN
* @date 2022/6/16
*/
module com.lomi.jdkOne {
exports com.lomi.jdk9One1;
}
例子中引用上面服务（项目A ） jar的另外一个服务（项目B）的module-info.java 文件（maven 中已经导入 项目A的 jar包）
/**
*
* 1 如果一个项目引用了一个jar，但是自身没有配置module-info.java，那么相当于使用了这个jar 的全部类
* 2 如果一个项目引用了一个jar，但是自身配置module-info.java，那么必须在导入了这个 jar的 模块名才能使用里面的 暴露服务类
*
* @author ZHANGYUKUN
* @date 2022/6/16
*/
module com.lomi.jdkTwo {
requires com.lomi.jdkOne;
}
项目结构如下：
测试代码如下：
package com.lomi.jdkTwo1;
import com.lomi.jdk9One1.Goods;
import com.lomi.jdk9One2.Book;
import org.junit.Test;
import java.io.*;
import java.util.*;
import java.util.stream.Stream;
/**
* @author ZHANGYUKUN
* @date 2022/6/16
*/
public class JDK9NewTest1 {
/**
* 使用模块,相当于在package 上面 多了一层，如果在classpath 根目录有了 module-info.java 文件，那么引用的jar包就不是全部使用，而需要在 module-info.java 里面声明使用
*/
@Test
public void test1(){
//Goods的包被暴露出来可以倍使用（如果不导入模块，就使用，是不能编译通过，除非当前工程不使用模块化管理）
//模块化管理是相互的，需要 引用方和被引用方都 使用模块化管理才有效
ShoppingCart shoppingCart = new ShoppingCart();
shoppingCart.getGoodsList().add( new Goods() );
//Book的包没有被暴露出来，不能使用（但是目前版本的编译并不会保存，估计后面版本会优化），下面的代码允许会抛出异常
//Book book = new Book();
System.out.println( shoppingCart );
}
/**
* 匿名内部类前面使用<>不会报错，之前java8会报错
*/
@Test
public void test2(){
//java8 只能这样写
Comparator<Object> comparator2 = new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
};
//java8 这样写会报错
Comparator<Object> comparator = new Comparator<>() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
};
}
/**
* 对try 自动关闭资源的优化，可以使用try外部定义的AutoCloseable资源
*/
@Test
public void test3() throws IOException {
//jdk8以前
FileWriter fw = null;
try{
fw = new FileWriter("C:\\Users\\ZHANGYUKUN\\Desktop\\a.txt");
fw.write("aaaa");
}catch (Exception e){
e.printStackTrace();
}finally {
if( fw != null ){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//jdk8,要求资源的申明和赋值都必须在 try的括号内
try (
FileWriter fw2 = new FileWriter("C:\\Users\\ZHANGYUKUN\\Desktop\\b.txt");
FileWriter fw3 = new FileWriter("C:\\Users\\ZHANGYUKUN\\Desktop\\b.txt");
){
fw2.write("bbbb");
fw3.write("cccc");
}catch (Exception e){
e.printStackTrace();
}
//jdk9,允许关闭的资源在外面申明并且赋值（不允许在外面申明，try（）内赋值）
FileWriter fw5 = new FileWriter("C:\\Users\\ZHANGYUKUN\\Desktop\\b.txt");
try (
FileWriter fw4 = new FileWriter("C:\\Users\\ZHANGYUKUN\\Desktop\\b.txt");
fw5
){
fw4.write("eeee");
fw5.write("ffff");
}catch (Exception e){
e.printStackTrace();
}
//不管那种try()的优化实际上在 try 方法体内部都使用的一个静态指针（这个资源在 try{} 里面是不能修改的，相当于一个常量），并且这个静态指针作用范围只有 try 结束就自动释放了
//自动关闭的资源需要实现 AutoCloseable 接口
System.out.println("end---------");
}
/**
* String 类型 以前使用char 数组，现在用的 byte数组（可以省空间）（StringBuilder ，StringBuffer 也是换成byte数组了，正常我们应该用StringBuilder，而不是StringBuffer）
*/
@Test
public void test4() throws IOException {
//char 是2 个字节，byte 是一个字节，jvm 内部的 编码是 UTF-16或者是定长2字节的UES2，现在才是动长的 UTF-16(短的用1个字节，长的用2个字节，2个字节转不下的用4个字节)
//这样做的原因是大多数时候程序的字符串都是 ASCII 编码可以表示的(一个字节就够了)，全都用2个字节太浪费内存
}
/**
* 只读集合的工厂方法
* 三大集合 提供了of方法，没有jdk8 允许了接口的静态方法，所以现在 of的工厂方法都由 三大集合接口提供，而不是 Collections 提供
*/
@Test
public void test5() throws IOException {
//这个方式创建的定长集合，依旧可以修改
List<Integer> readOnlyList = Arrays.asList(1, 2, 3,null);
readOnlyList.set(0,100);
System.out.println( readOnlyList.get(0) );
//以前创建只读集合
Map<String, String> readOnlyMap = Collections.unmodifiableMap(new HashMap<String, String>());
//jdk9写法（List.Set,Map都有类似的方法），为啥作者要把同样的方法写10 次？
Set<Integer> set = Set.of(1, 2);
Map.ofEntries( Map.entry("key","value") );
}
/**
* 直接把 输入流 对接到输出流（自带8K缓冲区），怎么获取路径？
* 输入流，提供 transferTo 方法
*/
@Test
public void test6() throws IOException {
try(
InputStream inputStream = JDK9NewTest1.class.getClassLoader().getResourceAsStream("a.txt");
FileOutputStream outputStream = new FileOutputStream( "b.txt" );
){
inputStream.transferTo(outputStream);
}catch (Exception e){
}
}
/**
* stream api 新增了4个方法takeWhile,dropWhile,ofNullable,自带退出条件的iterate
*/
@Test
public void test7() throws IOException {
//takeWhile（第一个不满足条件一户的都会删除）
System.out.println( Stream.of(1, 2, 3, 4, 5, 6, 7, 8).takeWhile(item -> (item < 3)).toArray().length );
System.out.println("---------------------------------------------------------------");
//dropWhile（第一个不满足条件之前的都会删除）
System.out.println( Stream.of(1, 2, 3, 4, 5, 6, 7, 8).dropWhile(item -> (item < 3)).toArray().length );
System.out.println("---------------------------------------------------------------");
//以前的Stream.of(null)，是不允许的。jdk9 Stream.ofNullable(null) 允许空
Stream.ofNullable(null);
Stream.of(null,null);
//Stream.of(null);
//iterate 自带退出条件
Stream.iterate( 0,item->item<100,item->item+1 ).forEach(System.out::println);
}
/**
* Optional 的一些新方法 ifPresentOrElse()，or()，stream()
*/
@Test
public void test8() throws IOException {
//Optional.or 空值的时候返回 一个默认的 Optional
String value = null;
Optional optional = Optional.ofNullable( value );
optional = optional.or( ()-> Optional.of("默认值") );
// System.out.println("结果：" + optional.get() );
//不为空调用方法A，为空调用方法2（ 和 optional.orElseThrow() 类似 ）
optional.ifPresentOrElse(System.out::println,()->{
System.out.println("是空");
});
//jdk8有的方法，和 orElse 的加强版
optional.orElseGet( ()->"默认值" );
//平铺的optional（其实也没有平铺，重点在map Optional ）
List<String> list = null;
Optional<String> s = Optional.ofNullable(list).flatMap(item -> Optional.of(item.get(0)));
}
/**
* 私有方法
*/
@Test
public void test9(){
Impl1 impl1 = new Impl1();
Impl2 impl2 = new Impl2();
impl1.methodDefault();
impl1.methodNotmal();
//接口的静态方法只能通过接口名字调用，不能通过实例对象调用
Interface1.methodStatic();
//私有方法只能自己调用
//impl1.methodProvide();
}
/**
* nashorn 引擎
*/
@Test
public void test10() throws IOException {
//后面的jdk版本删除了，没继续了解
}
}