Java8新特性

杀神lwz

已于 2023-11-20 23:52:48 修改

阅读量397

点赞数 2

文章标签： java lambda stream

于 2021-08-10 22:37:08 首次发布

本文链接：https://blog.csdn.net/weixin_42472027/article/details/119580997

版权

Java 8新特性简介

速度更快

代码更少(增加了新的语法：Lambda 表达式)

强大的 Stream API

便于并行

最大化减少空指针异常：Optional

Nashorn引擎，允许在JVM上运行JS应用

1、Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

例子：

语法各式一：无参，无返回值
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World!");
    }
};

↓

Runnable r2 = () -> System.out.println("Hello World!");

Comparator<Integer> com1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1,o2);
    }
};

int compare1 = com1.compare(12,21);
System.out.println(compare1);

↓

//Lambda表达式的写法
Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

int compare2 = com2.compare(32,21);
System.out.println(compare2);

↓

//方法引用
Comparator<Integer> com3 = Integer :: compare;

int compare3 = com3.compare(32,21);
System.out.println(compare3);

语法：

举例： (o1,o2) -> Integer.compare(o1,o2);
格式：
-> :lambda操作符 或 箭头操作符
->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
->右边：lambda体 （其实就是重写的抽象方法的方法体）

总结：
->左边：lambda形参列表的参数类型可以省略(类型推断)；
        如果lambda形参列表只有一个参数，其一对()也可以省略
->右边：lambda体应该使用一对{}包裹；
        如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字

Lambda表达式的本质：作为函数式接口的实例

语法格式二：Lambda 需要一个参数，但是没有返回值。

Consumer<String> con = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
con.accept("谎言和誓言的区别是什么？");

Consumer<String> con1 = (String s) -> {
    System.out.println(s);
};
con1.accept("一个是听得人当真了，一个是说的人当真了");

//语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
Consumer<String> con2 = (s) -> {System.out.println(s);};

//语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
Consumer<String> con2 = s -> {System.out.println(s);};

//语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
Comparator<Integer> com2 = (o1,o2) -> {
    System.out.println(o1);
    System.out.println(o2);
    return o1.compareTo(o2);
};

//语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);

类型推断：javac 根据程序的上下文，在后台推断出了参数的类型。

2、函数式(Functional)接口

只包含一个抽象方法的接口，称为函数式接口。

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。

在java.util.function包下定义了Java 8 的丰富的函数式接口

在Java8中，Lambda表达式就是一个函数式接口的实例。这就是 Lambda表达式和函数式接口的关系。

举例：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

JAVA内置四大核心函数式接口

3、方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法.

要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

格式：使用操作符 “::” 将类(或对象) 与方法名分隔开来。

如下三种主要使用情况：

对象::实例方法名

类::静态方法名

类::实例方法名

构造器引用

格式： ClassName::new

数组引用

格式： type[] :: new

4、强大的Stream API

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

package java.util.stream;
...
public interface Stream<T> extends BaseStream<T, Stream<T>> {

boolean allMatch(Predicate<? super T> predicate):返回此流的所有元素是否与提供的谓词匹配。  
boolean anyMatch(Predicate<? super T> predicate):返回此流的任何元素是否与提供的谓词匹配。  
static <T> Stream.Builder<T> builder():返回一个 Stream的构建器。  
<R,A> R collect(Collector<? super T,A,R> collector):使用 Collector对此流的元素执行 mutable reduction Collector 。  
<R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner):对此流的元素执行 mutable reduction操作。  
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b):创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。  
long count() :返回此流中的元素数。  
Stream<T> distinct() :返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。  
static <T> Stream<T> empty() :返回一个空的顺序 Stream 。  
Stream<T> filter(Predicate<? super T> predicate) :返回由与此给定谓词匹配的此流的元素组成的流。  
Optional<T> findAny() :返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。  
Optional<T> findFirst() :返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。  
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 
返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。  
DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper) 
返回一个 DoubleStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。  
IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper) 
返回一个 IntStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。  
LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper) 
返回一个 LongStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。  
void forEach(Consumer<? super T> action) :对此流的每个元素执行操作。  
void forEachOrdered(Consumer<? super T> action) 
如果流具有定义的遇到顺序，则以流的遇到顺序对该流的每个元素执行操作。  
static <T> Stream<T> generate(Supplier<T> s) :返回无限顺序无序流，其中每个元素由提供的 Supplier 。  
static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) 
返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ，产生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等  
Stream<T> limit(long maxSize) 
返回由此流的元素组成的流，截短长度不能超过 maxSize 。  
<R> Stream<R> map(Function<? super T,? extends R> mapper) 
返回由给定函数应用于此流的元素的结果组成的流。  
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) 
返回一个 DoubleStream ，其中包含将给定函数应用于此流的元素的结果。  
IntStream mapToInt(ToIntFunction<? super T> mapper) :返回一个 IntStream ，其中包含将给定函数应用于此流的元素的结果。  
LongStream mapToLong(ToLongFunction<? super T> mapper) :返回一个 LongStream ，其中包含将给定函数应用于此流的元素的结果。  
Optional<T> max(Comparator<? super T> comparator) :根据提供的 Comparator返回此流的最大元素。  
Optional<T> min(Comparator<? super T> comparator) :根据提供的 Comparator返回此流的最小元素。  
boolean noneMatch(Predicate<? super T> predicate) :返回此流的元素是否与提供的谓词匹配。  
static <T> Stream<T> of(T... values) :返回其元素是指定值的顺序排序流。  
static <T> Stream<T> of(T t) :返回包含单个元素的顺序 Stream 。  
Stream<T> peek(Consumer<? super T> action) :返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。  
Optional<T> reduce(BinaryOperator<T> accumulator) :使用 associative累积函数对此流的元素执行 reduction ，并返回描述减小值的 Optional （如果有）。  
T reduce(T identity, BinaryOperator<T> accumulator) :使用提供的身份值和 associative累积功能对此流的元素执行 reduction ，并返回减小的值。  
<U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner) :执行 reduction在此流中的元素，使用所提供的身份，积累和组合功能。  
Stream<T> skip(long n) :在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。  
Stream<T> sorted() :返回由此流的元素组成的流，根据自然顺序排序。  
Stream<T> sorted(Comparator<? super T> comparator) :返回由该流的元素组成的流，根据提供的 Comparator进行排序。  
Object[] toArray():返回一个包含此流的元素的数组。  
<A> A[] toArray(IntFunction<A[]> generator) 
使用提供的 generator函数返回一个包含此流的元素的数组，以分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。

5、Optional类

package java.util;
...
public final class Optional<T> 

可能包含或不包含非空值的容器对象。 如果一个值存在， isPresent()将返回true和get()将返回值。 
提供依赖于存在或不存在包含值的其他方法,例如orElse()（如果值不存在则返回默认值）和
ifPresent() （如果值存在则执行代码块）。 

static <T> Optional<T> empty() :返回一个空的 Optional实例。  
boolean equals(Object obj) :指示某个其他对象是否等于此可选项。  
Optional<T> filter(Predicate<? super T> predicate) :如果一个值存在，并且该值给定的谓词相匹配时，返回一个 Optional描述的值，否则返回一个空的 Optional 。  
<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper) :如果一个值存在，应用提供的 Optional映射函数给它，返回该结果，否则返回一个空的 Optional 。  
T get() :如果 Optional中有一个值，返回值，否则抛出 NoSuchElementException 。  
int hashCode() :返回当前值的哈希码值（如果有的话），如果没有值，则返回0（零）。  
void ifPresent(Consumer<? super T> consumer) :如果存在值，则使用该值调用指定的消费者，否则不执行任何操作。  
boolean isPresent() :返回 true如果存在值，否则为 false 。  
<U> Optional<U> map(Function<? super T,? extends U> mapper) :如果存在一个值，则应用提供的映射函数，如果结果不为空，则返回一个 Optional结果的 Optional 。  
static <T> Optional<T> of(T value) :返回具有 Optional的当前非空值的Optional。  
static <T> Optional<T> ofNullable(T value) :返回一个 Optional指定值的Optional，如果非空，则返回一个空的 Optional 。  
T orElse(T other) :返回值如果存在，否则返回 other 。  
T orElseGet(Supplier<? extends T> other) :返回值（如果存在），否则调用 other并返回该调用的结果。  
<X extends Throwable>
T orElseThrow(Supplier<? extends X> exceptionSupplier) :返回包含的值（如果存在），否则抛出由提供的供应商创建的异常。  
String toString() :返回此可选的非空字符串表示，适用于调试。

Java9新特性

一个程序员最重要的能力是：写出高质量的代码！！
有道无术，术尚可求也，有术无道，止于术。
无论你是年轻还是年长，所有程序员都需要记住：时刻努力学习新技术，否则就会被时代抛弃！