Java新特性

1 Java8新特性
2 Java9新特性
3 Java10新特性
4 Java11新特性

1 Java8新特性

1.1 函数式接口

只包含一个抽象方法的接口：java.lang.Runnable java.util.Comparator

提供@FunctionalInterface注解来定义函数式接口

Java8开始增加了java.util.function包，包含了常用的函数式接口：

接口名称	方法声明	功能介绍
Consumer	void accept(T t)	根据指定的参数执行操作
Supplier	T get()	得到一个返回值
Function<T,R>	R apply(T t)	根据指定的参数执行操作并返回
Predicate	boolean test(T t)	判断指定的参数是否满足条件
Comparator	R compare(T t, S s)	根据指定的两个参数执行操作并返回

1.2 函数式接口的实现

1.2.1 匿名内部类

语法格式：父类/接口类型引用变量名 = new 父类/接口类型(){方法的重写}

/**
 *无参数无返回值的方法==========
 */
Runnable runable = new Runnable() {
    @Override
    public void run() {
        System.out.println("无参数无返回值的方法！")
    }
};
runnable.run();
/**
 *有参数无返回值的方法==========
 */
Consumer consumer = new Consumer() {
    @Override
    public void accept(Object o) {
        System.out.println(o + "有参数无返回值的方法！")
    }
};
consumer.accept("给个提示：");
/**
 *无参数有返回值的方法==========
 */
Supplier supplier = new Supplier() {
    @Override
    public Object get() {
        return "无参数有返回值的方法！";
    }
};
System.out.println(supplier.get());
/**
 *有参数有返回值的方法==========
 */
Function function = new Function() {
    @Override
    public Object apply(Object o) {
        return o;
    }
};
System.out.println(function.apply("有参数有返回值的方法！"));
/**
 *两参数一返回值的方法==========
 */
Comparator comparator = new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }
};
System.out.println(comparator.compare(11,22));
/**
 *根据参数返回布尔值的方法==========
 */
Predicate predicate = new Predicate() {
    @Override
    public boolean test(Object o) {
        return false;
    }
};
System.out.println(predicate.test("hello"));

1.2.2 Lambda表达式

(参数列表)->{方法体;} //其中()、参数类型、{}、return可以省略

/**
 *无参数无返回值的方法==========
 */
Runnable runnable = () -> {System.out.println("无参数无返回值的方法！");};
/**
 *有参数无返回值的方法==========
 */
Consumer consumer = (Object o) -> {System.out.println(o + "有参数无返回值的方法！");};
/**
 *无参数有返回值的方法==========
 */
Supplier supplier = () -> {retrun "无参数有返回值的方法！";};
//等价于
Supplier supplier1 = () -> "无参数有返回值！";
/**
 *有参数有返回值的方法==========
 */
Function function = o -> o;
/**
 *两参数一返回值的方法==========
 */
Comparator comparator = (o1, o2) -> 0;
/**
 *有参数返回布尔值的方法==========
 */
Predicate predicate = o -> false;

1.2.3 方法引用

通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的引用交给函数式接口执行

方式一

对象的非静态方法引用----->对象名::非静态方法名

//Person类中的show方法与Runnable接口中的run方法结构一致，都是无参数无返回值
Runnable runnable = person::show;
//Person类中的getName方法与Supplier接口中的get方法结构一致，都是无参数有返回值
Supplier<String> supplier = person::getName;
//Person类中的setName方法与Consumer接口中的accept方法结构一致，都是有参数无返回值
Consumer<String> consumer = person::setName;

方式二

类的静态方法引用----->类名:: 静态方法名

//Integer类中的parseInt方法为静态方法
Function<String, Integer> function = Integer::parseInt;
System.out.println(function.apply("123456"));
//Integer类中的compare方法为静态方法
Comparator<Integer> comparator = Integer::compare;
System.out.println(comparator.compare(10,20));

方式三

使用匿名内部类的方式通过类名来调用非静态方法

前提：其中一个参数对象作为调用对象来调用方法

类的非静态方法引用----->类名::非静态方法名

Comparator<Integer> comparator = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
};
System.out.println(comparator.compare(10,20));
//等价于----------------------
Comparator<Integer> comparator = (o1, o2) -> o1.compareTo(o2);
//等价于----------------------
Comparator<Integer> comparator = Integer::compareTo;

方式四

构造器的引用----->类名::new

/**
 *无参有返回值==========
 */
Supplier<Person> supplier = Person::new;
/**
 *两参有返回值==========
 */
BiFunction<String, Integer, Person> biFunction = (s, integer) -> new Person(s, integer);
//等价于----------------------
BiFunction<String, Integer, Person> bitFunction = Person::new;

方式五

数组（对象数组）的引用----->数组(对象数组)::new

/**
 *创建对象数组
 */
Function<Integer, Person[]> function = new Function<Integer, Person[]>(){
	@Override
    public Person[] apply(Integer integer) {
    	return new Person[integer];
    }
};
Person[] pArr = function.apply(3);
System.out.println(Arrays.toString(pAddr));
//等价于----------------------
Function<Integer, Person[]> functon = integer -> new Person[Integer];
//等价于----------------------
Function<Integer, Person[]> function = Person[]::new;

1.2.4 Stream接口

java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找过滤筛选等操作。

支持Lambda表达式，提供串行和并行两种模式。

1.使用步骤

2.创建方式

方式一：通过调用集合的默认方式来获取流：default Stream<E> stream()

//1.创建list集合，放入Person类型的对象
List<Person> list = new LinkedList<>();
//2.使用Stream接口实现
list.stream().filter(person -> person.getAge() >= 18).forEach(System.out::println);

方式二：通过数组工具类中的静态方法来获取流：static IntStream stream(int array[])

//1.创建list集合，放入Person类型的对象
List<Person> list = new LinkedList<>();
//2.使用Stream接口实现
list.stream().skip(2).limit(3).forEach(System.out::println);

//打印person对象的age值
list.stream().map(new Function<Person, Integer>() {
    @Override
    public Integer apply(Person person) {
        return person.getAge();
    }
}).forEach(System.out::println);
//等价于----------------------
list.stream().map(Person::getAge).forEach(System.out::println);

方式三：通过Stream接口的静态方法来获取流：static <T> Stream<T> of(values)
方式四：通过Stream接口的静态方法来获取流：static <T> Stream<T> generate(Supplier<? extends T> s)

3.常用方法

中间操作

筛选与切片方法

方法声明	功能介绍
Stream filter(Predicate<? super T> predicate)	返回一个包含匹配元素的流
Stream distinct()	返回不包含重复元素的流
Stream limit(long maxSize)	返回不超过给定元素数量的流
Stream skip(long n)	返回丢弃前n个元素后的流

映射方法

方法声明	功能介绍
Stream map(Function<? super T,? extends R> mapper)	返回每个处理过的元素组成的流
Stream flatMap(Function<? super T,? extends Stream<? extends R>> mapper)	返回每个被替换过的元素组成的流，并将所有流合成一个流

排序方法

方法声明功能介绍
Stream sorted() 返回经过自然排序后元素经过的流
Stream sorted(Comparator<? super T> comparator) 返回经过比较器排序后的元素组成的流

方法声明	功能介绍
Stream sorted()	返回经过自然排序后元素经过的流
Stream sorted(Comparator<? super T> comparator)	返回经过比较器排序后的元素组成的流

终止操作

匹配与查找方法

方法声明	功能介绍
Optional findFirst()	返回该流的第一个元素
boolean allMatch(Predicate<? super T> predicate)	返回所有元素是否匹配
boolean noneMatch(Predicate<? super T> predicate)	返回任何元素是否匹配
Optional max(Comparator<? super T> comparator)	根据比较器返回最大元素
Optional min(Comparator<? super T> comparator)	根据比较器返回最小元素
long count()	返回元素的个数
void forEach(Consumer<? super T> action)	对流中每个元素执行操作

规约方法

方法声明功能介绍
Optional reduce(BinaryOperator accumulator) 返回结合后的元素值
收集方法

方法声明功能介绍
<R,A> R collect(Collector<? super T,A,R> collector) 使用收集器对元素进行处理

方法声明	功能介绍
Optional reduce(BinaryOperator accumulator)	返回结合后的元素值

方法声明	功能介绍
<R,A> R collect(Collector<? super T,A,R> collector)	使用收集器对元素进行处理

1.2.5 Optional类

java.util.Optional类可以理解为一个简单的容器，其值可能是null或者不是null，代表一个值存在或不存在。

该类的引入很好地解决了空指针异常，不用显式进行空值检测。

/**
 * Java8中使用Optional处理空值
 */
//1.将数据str1装到Optional对象代表的容器中
Optional<String> optional = Optional.ofNullable(str1);
//2.建立映射关系，使用字符串的长度与字符串建立映射关系
Optional<Integer> integer = optional.map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        return s.length();
    }
});
//等价于--------------------------
Optional<Integer> integer = optional.map(String::length);

2 Java9新特性

2.1 模块化概念及使用

不同模块中的类不能直接调用
如上图所示，在JavaModule1和JavaModule2两个模块中分别新建Person类和PersonTest类，但在PersonTest类中无法直接调用Person类新建对象。
需要将被调用模块中的类暴露出去，在调用模块中添加请求文件：

2.2 钻石操作符

匿名内部类中可省略钻石操作符中的内容
例：Comparator<Integer> comparator = new Comparator<>() {};

2.3 集合工厂方法

Java9中的List、Set和Map集合中增加了静态工厂方法of实现不可变实例
不可变实例无法增删改查元素
不允许添加null元素

2.4 InputStream的增强

添加了transferTo方法直接将数据传入OutStream中
transferTo方法底层是read和write方法的调用

3 Java10新特性

var保留字————只是一个保留的类型名称

由初始值可以推断出变量的类型，则可以用var替代

不可用于类或接口的声明

//1.声明变量
int num = 1;
var num = 1;
//2.声明泛型
List<Integer> List = new LinkedList();
var list = new LinkedList<Integer>();
//3.for循环
for (var v: list) {
    System.out.println(v);
}

4 Java11新特性

简化编译运行
执行源文件中的第一个类必须包含主方法
不可以使用其他源文件中自定义类

String类新增方法

方法声明	功能介绍
boolean isBlank()	判断字符串是否为空或只包含空白代码点
Optional map(Function<? super T,? extends U> mapper)	根据参数指定规则的结果来得到Optional类型的对象
T orElse(T other)	该值存在就返回，否则返回false