Java新特性

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 方法引用

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

1. 方式一

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

   //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;
   

2. 方式二

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

   //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));
   

3. 方式三

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

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

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

   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;
   

4. 方式四

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

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

5. 方式五

   数组（对象数组）的引用----->数组(对象数组)::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.创建方式

1. 方式一：通过调用集合的默认方式来获取流：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);
   

2. 方式二：通过数组工具类中的静态方法来获取流：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);
   

3. 方式三：通过Stream接口的静态方法来获取流：static <T> Stream<T> of(values)

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

3.常用方法

1. 中间操作

   • 筛选与切片方法

     方法声明	功能介绍
     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)	返回经过比较器排序后的元素组成的流

2. 终止操作

   • 匹配与查找方法

     方法声明	功能介绍
     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)	使用收集器对元素进行处理

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 模块化概念及使用

1. 不同模块中的类不能直接调用
   如上图所示，在JavaModule1和JavaModule2两个模块中分别新建Person类和PersonTest类，但在PersonTest类中无法直接调用Person类新建对象。

2. 需要将被调用模块中的类暴露出去，在调用模块中添加请求文件：
   
   

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