Java8 新特性

Java8

Java8是 Java 语言的一个重要版本，该版本于2014年3月发布，是自Java5以来最具革命性的版本，这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。

函数式接口

• 函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator接口等。
• Java8提供@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)	判断指定的参数是否满足条件

实例：

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

// 函数式接口的使用
public class FunctionInterfaceTest {

    public static void main(String[] args) {

        // 无参无返回值
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是无参无返回值！");
            }
        };
        r.run();

        // 有参无返回值
        Consumer c = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println("我是有参无返回值，参数：" + o);
            }
        };
        c.accept("Hello");

        // 无参有返回值
        Supplier s = new Supplier() {
            @Override
            public Object get() {
                return "我是无参有返回值！";
            }
        };
        System.out.println(s.get());

        // 是否满足条件
        Predicate p = new Predicate() {
            @Override
            public boolean test(Object o) {
                return "true".equals(o);
            }
        };
        System.out.println(p.test("true"));
    }
}

Lambda 表达式

• Lambda 表达式是实例化函数式接口的重要方式，使用 Lambda 表达式可以使代码变的更加简洁紧凑。
• Lambda表达式：参数列表、箭头符号->和方法体组成，而方法体中可以是表达式，也可以是语句块。
• 语法格式：(参数列表) -> { 方法体; } - 其中()、参数类型（类型推断实现的省略）、{} 以及return关键字 可以省略。

实例：

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

// Lambda 表达式
public class LambdaTest {

    public static void main(String[] args) {

        Runnable r = () -> System.out.println("我是无参无返回值！");
        r.run();

        Consumer c = (o) -> System.out.println("我是有参无返回值，参数：" + o);
        c.accept("Hello World");

        Supplier s = ()-> "我是无参有返回值！";
        System.out.println(s.get());

        Predicate p =(b)-> "true".equals(b);
        System.out.println(p.test("true"));
    }
}

方法引用

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

• 方法引用是在特定场景下Lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码。

• 方法引用调用的方法的签名需要和函数式接口中方法的签名格式保持一致。

• 方法引用使用一对冒号:: 将类或对象与方法名进行连接，通常使用方式如下：

对象的非静态方法引用

• 格式： ObjectName :: MethodName

// 方法引用语法测试
public class MethodReferenceTest {

    public static void main(String[] args) {

        // 需求：在Runnable接口的run方法内调用 Person对象的show方法

        Person p = new Person("张三", 22);
        // 匿名内部类实现
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                p.show();
            }
        };
        r1.run();

        // Lambda 表达式实现
        Runnable r2 =()->p.show();
        r2.run();

        // 方法引用方式实现
        Runnable r3 = p::show;
        r3.run();
    }
}

类的静态方法引用

格式： ClassName :: StaticMethodName

import java.util.function.Function;

public class MethodReferenceTest {

    // 通过函数式接口Function调用Interge类的paresInt方法
    public static void main(String[] args) {

        // 1. 匿名内部类实现
        Function<String, Integer> f1 = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        System.out.println(f1.apply("1234"));

        // 2. Lambda 表达式实现
        Function<String, Integer> f2 = s -> Integer.parseInt(s);
        System.out.println(f2.apply("2345"));

        // 3. 方法引用实现
        Function<String, Integer> f3 = Integer::parseInt;
        System.out.println(f3.apply("3456"));
    }
}

类的非静态方法引用

• 格式： ClassName :: MethodName
• 当方法的其中一个参数作为调用对象时才可以使用这种语法。

import java.util.Comparator;

public class MethodReferenceTest {

    public static void main(String[] args) {

        // 通过类名调用非静态方法

        // 1. 匿名内部类方式
        Comparator<Integer> c1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(c1.compare(10,20));

        // 2. Lambda 表达式方式
        Comparator<Integer> c2 = (o1,o2)->o1.compareTo(o2);
        System.out.println(c2.compare(10,20));

        // 3. 方法引用方式 当其中一个参数作为调用对象时可以使用这种语法
        Comparator<Integer> c3 = Integer::compareTo;
        System.out.println(c3.compare(10,20));
    }
}

构造器的引用

语法： ClassName :: new

import java.util.function.BiFunction;

public class MethodReferenceTest {

    public static void main(String[] args) {

        // 使用BiFunction函数式接口使用有参构造创建Person对象并返回

        // 1. 匿名内部类方式
        BiFunction<String, Integer, Person> biFunction1 = new BiFunction<String, Integer, Person>() {
            @Override
            public Person apply(String s, Integer integer) {
                return new Person(s, integer);
            }
        };
        System.out.println(biFunction1.apply("张三", 22));

        // 2. Lambda 表达式方式
        BiFunction<String, Integer, Person> biFunction2 = (s, i) -> new Person(s, i);
        System.out.println(biFunction2.apply("张三", 22));

        // 3. 方法引用方式
        BiFunction<String, Integer, Person> biFunction3 = Person::new;
        System.out.println(biFunction3.apply("张三", 22));
    }
}

数组的引用

语法： TypeName[] :: new

import java.util.Arrays;
import java.util.function.Function;

public class MethodReferenceTest {

    public static void main(String[] args) {

        // 使用Function函数式接口创建指定数量的Person对象数组

        // 1. 匿名内部类方式
        Function<Integer, Person[]> f1 = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer integer) {
                return new Person[integer];
            }
        };
        System.out.println(Arrays.toString(f1.apply(3)));

        // 2. Lambda 表达式方式
        Function<Integer,Person[]> f2= i->new Person[i];
        System.out.println(Arrays.toString(f2.apply(3)));

        // 3. 方法引用方式
        Function<Integer,Person[]> f3 = Person[]::new;
        System.out.println(Arrays.toString(f3.apply(3)));

    }
}

Stream 接口

• java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选等操作。
• Stream接口借助于Lambda 表达式极大的提高编程效率和程序可读性，同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势。
• 使用步骤：
  1. 创建Stream，通过一个数据源来获取一个流。
  2. 转换Stream，每次转换返回一个新的Stream对象。
  3. 对Stream进行聚合操作并产生结果。
• 创建方式:
  1. 通过调用集合的默认方法来获取流，如：default Stream stream()。
  2. 通过数组工具类中的静态方法来获取流，如：static IntStream stream(int[] array)。
  3. 通过Stream接口的静态方法来获取流，如：static Stream of(T... values)。
  4. 通过Stream接口的静态方法来获取流，static Stream generate(Supplier<? extends T>s)。

中间操作常用方法

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

终止操作常用方法

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

实例

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ListPersonTest {

    public static void main(String[] args) {

        // 使用 Stream 过滤集合中小于18岁的人
        List<Person> ls = new ArrayList();
        ls.add(new Person("张三", 16));
        ls.add(new Person("李四", 17));
        ls.add(new Person("王五", 18));
        ls.add(new Person("赵六", 19));
        ls.add(new Person("钱七", 20));

        // 匿名内部类实现
        ls.stream().filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() >= 18;
            }
        }).forEach(new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println(person);
            }
        });

        // Lambda 实现
        ls.stream().filter(p -> p.getAge() >= 18).forEach(p -> System.out.println(p));

        // 方法引用实现
        ls.stream().filter(p -> p.getAge() >= 18).forEach(System.out::println);

        // 将集合中所有元素年龄然后累加打印出来 规约
        ls.stream().map(Person::getAge).reduce(Integer::sum).stream().forEach(System.out::println);

        // 手机集合中所有人的姓名并打印出来 收集
        ls.stream().map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);
    }
}

Optional 类

• java.util.Optional类可以理解为一个简单的容器，其值可能是null或者不是null，代表一个值存在或不存在。
• 该类的引入很好的解决空指针异常，不用显式进行空值检测。

方法声明	功能介绍
static Optional ofNullable(T value)	根据参数指定数值来得到Optional类型的对象
Optional map(Function<? super T,? extends U> mapper)	根据参数指定规则的结果来得到Optional类型的对象
T orElse(T other)	若该值存在就返回，否则返回other的数值。

实例：

import java.util.Optional;

public class OptionalTest {

    public static void main(String[] args) {

        // 打印字符串长度  为空时打印0
        String str = null;
        // 获取Optional对象
        Optional<String> optionalS = Optional.ofNullable(str);
        // 指定数据映射方式
        Optional<Integer> optional = optionalS.map(s -> s.length());
        // 为空时输出指定值
        System.out.println(optional.orElse(0));
    }
}