JDK9
新特性概述
JDK和JRE目录结构的改变:
JDK1.8
JDK1.9 及以后
模块化系统
JShell命令
背景:
命令:
语法改进
接口的私有方法:
JDK8
JDK9
如下的三个方法的权限修饰符都是public
1.抽象方法
2.静态方法
3.默认方法
jdk 9中允许接口中定义私有的方法
public interface MyInterface {
//如下的三个方法的权限修饰符都是public
void methodAbstract();
static void methodStatic(){
System.out.println("我是接口中的静态方法");
}
default void methodDefault(){
System.out.println("我是接口中的默认方法");
methodPrivate();
}
//jdk 9中允许接口中定义私有的方法
private void methodPrivate(){
System.out.println("我是接口中的私有方法");
}
}
1. 接口中的静态方法只能由接口自己调用
2. 接口的实现类不能调用接口的静态方法
3. 接口的私有方法，不能在接口外部调用
public class MyInterfaceImpl implements MyInterface {
@Override
public void methodAbstract() {
}
// @Override
public void methodDefault() {
System.out.println("实现类重写了接口中的默认方法");
}
public static void main(String[] args) {
//接口中的静态方法只能由接口自己调用
MyInterface.methodStatic();
//接口的实现类不能调用接口的静态方法
// MyInterfaceImpl.methodStatic();
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.methodDefault();
//接口的私有方法，不能在接口外部调用
// impl.methodPrivate();
}
}
钻石操作符:
try操作的升级
JDK8
public static void main(String[] args) {
//java 8之前的资源关闭的操作
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 {
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
或者
public static void main(String[] args) {
//java 8中资源关闭操作: Java 8 中，可以实现资源的自动关闭
//要求自动关闭的资源的实例化必须放在try的一对小括号中
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();
}
}
JDK9
//java9 特性六：try操作的升级
public static void main(String[] args) {
//java9中资源关闭操作：需要自动关闭的资源的实例化可以放在try的一对小括号外。
//此时的资源属性是常量，声明为final的，不可修改
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存储结构变更
byte[ ]
快速创建只读集合
java8中的写法：
//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);
}
Collections工具类
@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")));
Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<String, Integer>() {
{
put("a",1);
put("b",2);
put("c",3);
}
});
map.forEach((k,v) -> System.out.println(k+":"+v));
}
注意: Arrays.asList()也是一个只读集合
@Test
public void test3() {
//此时得到的集合list也是一个只读集合。
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.add(6);... 报异常
}
java9中的写法：
//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()
---------返回从开头开始的按照指定规则尽量多的元素
@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);
}
注意; 不是全局过滤,是从开头开始的按照规则返回尽量多的元素
dropWhile()
---------与 takeWhile 相反，返回剩余的元素。
//java9新特性十：Stream API的加强
@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);
//dropWhile():与 takeWhile 相反，返回剩余的元素。
list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
}
ofNullable()
@Test
public void test2(){
//of()参数中的多个元素，可以包含null值
Stream<Integer> stream1 = Stream.of(1, 2, 3,null);
stream1.forEach(System.out::println);
//of()参数不能存储单个null值。否则，报异常
// Stream<Object> stream2 = Stream.of(null);
// stream2.forEach(System.out::println);
Integer i = 10;
i = null;
//ofNullable()：形参变量是可以为null值的单个元素
Stream<Integer> stream3 = Stream.ofNullable(i);
long count = stream3.count();
System.out.println(count);
}
iterate()
@Test
public void test3(){
Stream.iterate(0,x -> x + 1).limit(10).forEach(System.out::println);
//java9中新增的重载的方法
Stream.iterate(0,x -> x < 100,x -> x + 1).forEach(System.out::println);
}
Optional提供了新的方法stream()
//java9新特性十一：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);
stream.flatMap(x -> x.stream()).forEach(System.out::println);
}