1. 接口的私有方法
Java 8中规定接口中的方法除了抽象方法之外,还可以定义静态方法和默认的方法。一定程度上,扩展了接口的功能,此时的接口更像是一个抽象类。
在Java 9中,接口更加的灵活和强大,连方法的访问权限修饰符都可以声明为private的了,此时方法将不会成为对外暴露的API的一部分。
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("接口中的私有方法");
}
}
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();
}
}
2. 语法改进:钻石操作符使用升级
将能够与匿名实现类共同使用钻石操作符(diamond operator)在Java 8如下的操作是报错的:
Comparator<Object> com=new Comparator<>(){
@Override
public int compare(Object o1,Object o2){
return 0;
}
};
//java9特性五:钻石操作符的升级
@Test
public void test2(){
//钻石操作符与匿名内部类在java 8中不能共享,在java 9可以
Comparable<Object> com=new Comparable<Object>() {
@Override
public int compareTo(Object o) {
return 0;
}
};
//jdk7中的新特性:类型推断
ArrayList<String> list=new ArrayList<>();
}
3. 语法改进:try语句
Java 8中,可以实现资源的自动关闭,但是要求执行后必须关闭的所有资源必须在try子句中初始化,否则编译不通过。如下例所示:
try(InputStreamReader reader=new InputStreamReader(System.in)){
//读取数据细节省略
}catch(IOException e){
e.printStackTrace();
}
Java 9中,用资源语句编写try将更容易,可以在try自居中使用已经初始化过的资源,此时的资源是final的:
InputStreamReader reader=new InputStreamReader(System.in);
OutputStreamWriter writer=new OutputStreamWriter(System.out);
try(reader,writer){
//reader是final的,不可再被赋值
//reader=null;
//具体读写操作省略
}catch(IOException e){
e.printStackTrace();
}
4. String存储结构变更
结论:String再也不用char[]来存储,改成了byte[]加上编码表及,节约了一些空间。
public final class String
implements java.io.Serializable,Comparable<String>,CharSequence{
@Stable
private final byte[] value;
}
5. StringBuffer和StringBuilder的变更
String-related classes such as AbstractStringBuilder,StringBuilder,
and StringBuffer will be updated to use the same representation, as will the
HotSpot VM' intrinsic(固有的、内置的)string operations.
6. 工厂方法:快速创建只读集合
List<String> namesList=new ArrayList<>();
namesList.add("Joe");
namesList.add("Bob");
namesList.add("Bill");
namesList= Collections.unmodifiableList(namesList);
System.out.println(namesList);
7. InputStream加强:
InputStream终于有了一个非常有用的方法:transferTo,可以用来将数据直接传输到OutputStream,这是在处理原始数据流时非常常见的一种用法,
ClassLoader c1=this.getClass().getClassLoader();
try(InputStream is=c1.getResourceAsStream("hello.txt"));
OutputStream os=new FileOutputStream(""src\\hello1.txt")){
is.transferTo(os);//把输入流中的所有数据直接自动地复制到输出流中
}catch(IOException e){
e.printStackTrace();
}
增强的Stream API:
1)Java的Stream API是java标准库最好的改进之一,让开发者能够快速运算,从而能够有效的利用数据并行计算。Java 8提供的Stream能够利用多核架构实现声明式的数据处理。
2)在Java 9中,Stream API变得更好,Stream接口中添加了4个新的方法:takeWhile,dropWhile,ofNullable,还有个iterate方法的新重载放肆,可以提供一个Predicate(判断条件)来指定什么时候结束迭代。
3)除了对Stream本身的扩展,Optional和Stream之间的结合也得到了改进。现在可以通过Optional的新方法stream()将一个Optional对象转换为一个(可能是空的)stream对象。
8. takeWhile()的使用:
用于从Stream中获取一部分数据,接收一个Predicate来进行选择。在有序的Stream中,takeWhile返回从头开始尽量多的元素
List<Integer> list Arrays.asList(45,43,76,87,42,77,90,73,67,88);
list.stream().takeWhile(x->x<50).forEach(System.out::println);
System.out.println();
list=Arrays.asList(1,2,3,4,5,6,7,8);
list.stream().takeWhile(x->x<5).forEach(System.out::println);
9. dropWhile()的使用
dropWhile的行为与takeWhile相反,返回剩余的元素。
List<Integer> list=Arrays.asList(45,43,76,87,43,77,90,73,67,88);
list.stream().dropWhile(x->x<50).forEach(System.out::println);
System.out.println();
list=Arrays.asList(1,2,3,4,5,6,7,8);
list.stream().dropWhile(x->x<5).forEach(System.out::println);
10. ofNullable()的使用
Java 8中Stream不能完全为null,否则会报空指针异常。而Java 9中的ofNullable方法允许我们创建一个单元素Stream,可以包含一个非空元素,也可以创建一个空Stream。
//报NullPointerException
//Stream<Object> stream1=Stream.of(null);
//System.out.println(stream1.count());
//不报异常,允许通过
Stream<String> stringStream=Stream.of("AA","BB",null);
System.out.println(stringStream.count());//3
//不报异常,允许通过
List<String> list=new ArrayList<>();
list.add("AA");
list.add(null);
System.out.println(list.stream().count());//2
//----------------------------------------------------------------------------------------------------
//ofNullable():允许值为null
Stream<Object> stream1=Stream.ofNullable(null);
System.out.println(stream1.count());//0
Stream<String> strean=Stream.ofNullable("hello world");
System.out.println(stream.count());//1
11. iterate()重载的使用:
这个iterate方法的新重载方法,可以提供一个Predicate(判断条件)来指定什么时候结束迭代。
//原来的控制终止方式
Stream.iterate(1,i->i+1).limite(10).forEach(System.out::println);
//现在的终止方式
Stream.iterate(1,i->i<100,i->i+1).forEach(System.out::println);
12. Optional类中stream()的使用:
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();
stream.flatMap(x->x.stream()).forEach(System.out::println);