Java8常用新特性

一. Lambda表达式

Lambda 表达式,也可称为闭包.它是推动 Java 8 发布的最重要新特性,它允许把函数作为一个方法的参数(函数作为参数传递进方法中,相当于直接对函数式接口中的方法进行重写),使用 Lambda 表达式可以使代码变的更加简洁紧凑.

1. lambda语法

( object str,....)[参数列表]   ->[箭头符号]     代码块或表达式

• 可选类型声明: 不需要声明参数类型,编译器可以统一识别参数值
• 可选的参数圆括号: 一个参数无需定义圆括号,但多个参数需要定义圆括号
• 可选的大括号: 如果主体包含了一个语句,就不需要使用大括号
• 可选的返回关键字: 如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值

举例:

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

//1.使用lambda表达式实现Runnable
new Thread(() -> System.out.println("开启了一条线程")).start();

//2.使用lambda表达式实现Comparator
List<Integer> list = Arrays.asList(3, 2, 7, 9, 1, 5);
System.out.println(list);
Collections.sort(list, (x, y) -> x > y ? -1 : 1);
System.out.println(list);

2. 自定义lambda表达式

从Java8开始,官方提供了@FunctionalInterface注解来方便我们自定义函数式接口,同时也提供了一系列的函数式接口,基本上可以满足所以需求,如果需要自定义可以照葫芦画瓢.如下:

/**
 * 函数型接口
 */
@FunctionalInterface
interface Function<T, R> {
    R apply(T t);
}


/**
 * 供给型接口
 *
 * @param <T>
 */
@FunctionalInterface
interface Supplier<T> {
    T get();
}

/**
 * 消费型接口
 *
 * @param <T>
 */
@FunctionalInterface
interface Consumer<T> {
    void accept(T t);
}

/**
 * 判断型接口
 *
 * @param <T>
 */
@FunctionalInterface
interface Predicate<T> {
    Boolean test(T t);
}

举例:

//函数型接口:有进有出
Function<String, Integer> str2int = s -> Integer.parseInt(s);
Function<Integer, String> int2str = s -> "转字符串后" + s;

System.out.println(str2int.apply("21"));
System.out.println(int2str.apply(21));

//供给型接口:只出不进
Supplier<Integer> supplier = () -> (int) (Math.random() * 100) + 1;
System.out.println("获取随机数:" + supplier.get());

//消费型接口:只进不出
Consumer<String> consumer = s -> System.out.println("你好," + s);
consumer.accept("tom");

//判断型接口:必须返回一个布尔值
Predicate<String> predicate = s -> null != s && s.trim().length() != 0;
System.out.println("字符串是否不为空:" + predicate.test(" abc"));

 注意:

• 当一个接口中有且仅有一个抽象方法时,默认会当作函数式接口,当加了@FunctionalInterface注解就会按照规范检查,建议永远不要省略.
• lambda表达式单独使用没有意义,主要用来当作参数传递到方法中,提高代码的灵活性.

二. 方法引用(::)

方法引用通过方法的名字来指向一个方法,可以使语言的构造更紧凑简洁,减少冗余代码

方法引用使用一对冒号 :: 

• 构造器引用: 格式 类名::new
• 静态方法引用: 格式 类名::静态方法名
• 类的方法引用: 格式 类名::实例方法名
• 实例对象的引用: 格式 实例名::实例方法名
• 数组引用:格式: Type::new

三. Stream

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

Stream（流）是一个来自数据源的元素队列并支持聚合操作

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
• 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

1. forEach 方法来迭代流中的每个数据

以下代码片段使用forEach 输出了10个随机数

        Random random = new Random();
        random.ints(1,10).limit(10).forEach(System.out::println);

2. map 方法用于映射每个元素到对应的结果

以下代码片段使用 map 输出了元素对应的平方数

        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        List<Integer> squaresList = numbers.stream().map(i -> i * i).distinct().collect(Collectors.toList());

3. filter 方法用于通过设置条件过滤出元素

以下代码片段使用filter 方法过滤出空字符串

        List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        int count = (int) strings.stream().filter(string -> string.isEmpty()).count();

4. limit 方法用于获取指定数量的流

以下代码片段使用 limit 方法打印出 10 条数据

        Random random = new Random();
        random.ints().limit(10).forEach(System.out::println);

5. sorted 方法用于对流进行排序

以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序

        Random random = new Random();
        random.ints(1,10).limit(10).sorted().forEach(System.out::println);

6. parallelStream 是流并行处理程序的代替方法

以下实例我们使用parallelStream 来输出空字符串的数量

        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        int count = (int) strings.parallelStream().filter(string -> string.isEmpty()).count();

7. Collectors 类实现了很多归约操作

例如将流转换成集合和聚合元素.Collectors可用于返回列表或字符串

        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
        System.out.println("筛选列表: " + filtered);
        String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
        System.out.println("合并字符串: " + mergedString);

8. 一些产生统计结果的收集器也非常有用

它们主要用于int、double、long等基本类型上,它们可以用来产生类似如下的统计结果

        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
        System.out.println("列表中最大的数 : " + stats.getMax());
        System.out.println("列表中最小的数 : " + stats.getMin());
        System.out.println("所有数之和 : " + stats.getSum());
        System.out.println("平均数 : " + stats.getAverage());

四. Optional 类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。Optional 类的引入很好的解决空指针异常。

五. 日期时间 API

Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：

• Local(本地) − 简化了日期时间的处理，没有时区的问题。
• Zoned(时区) − 通过制定的时区处理日期时间。

新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。

        LocalDateTime now = LocalDateTime.now();
        System.out.println("当前的日期时间: "+now);
        System.out.println("当前的日期: "+now.toLocalDate());
        System.out.println("当前的时间: "+now.toLocalTime());
        System.out.println(now.getYear() + " 年 " + now.getMonth() + " 月 " + now.getDayOfMonth()+ " 日 " + now.getHour()+ " 时 " + now.getMinute() + " 分 " + now.getSecond()+" 秒 "  );
        System.out.println("给当前日期时间自定义日期: " + now.withDayOfMonth(10).withYear(2012));
        System.out.println("自定义日期: "+LocalDate.of(2014, Month.DECEMBER, 12));
        System.out.println("自定义时间: "+LocalTime.of(22, 15));
        System.out.println("解析时间: " + LocalTime.parse("20:15:30"));

执行结果 

当前的日期时间: 2021-02-26T23:06:43.794
当前的日期: 2021-02-26
当前的时间: 23:06:43.794
2021 年 FEBRUARY 月 26 日 23 时 6 分 43 秒 
给当前日期时间自定义日期: 2012-02-10T23:06:43.794
自定义日期: 2014-12-12
自定义时间: 22:15
解析时间: 20:15:30

        ZonedDateTime date1 = ZonedDateTime.parse("2012-12-03T10:15:30+05:30[Asia/Shanghai]");
        System.out.println("有时区的日期时间: " + date1);
        ZoneId id = ZoneId.of("Europe/Paris");
        System.out.println("自定义时区: " + id);
        ZoneId currentZone = ZoneId.systemDefault();
        System.out.println("当前系统时区: " + currentZone);

执行结果 

有时区的日期时间: 2012-12-03T10:15:30+08:00[Asia/Shanghai]
自定义时区: Europe/Paris
当前系统时区: GMT+08:00

六. Base64

在Java 8中，Base64编码已经成为Java类库的标准。

Java 8 内置了 Base64 编码的编码器和解码器。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

• 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
• URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
• MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分割。

        //base64解码器
        Base64.Decoder decoder = Base64.getDecoder();
        //base64编码器
        Base64.Encoder encoder = Base64.getEncoder();
        String str = "hello java8";
        System.out.println("原始字符串: " + str);
        String encodeStr = encoder.encodeToString(str.getBytes("utf-8"));
        System.out.println("编码后字符串: " + encodeStr);
        byte[] decode = decoder.decode(encodeStr);
        String decodeStr = new String(decode, "utf-8");
        System.out.println("解码后字符串: " + decodeStr);

原始字符串: hello java8
编码后字符串: aGVsbG8gamF2YTg=
解码后字符串: hello java8

七.默认方法和静态方法

• Java 8 新增了接口的默认方法,简单说,默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法.我们只需在方法名前面加个 default 关键字即可实现默认方法.
• Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法

public class Demo implements Test {

    public static void main(String[] args) {
        Test.print();
        new Demo().hello("tom");
    }

}

interface Test {
    static void print() {
        System.out.println("我是接口中的静态方法");
    }

    default void hello(String name) {
        System.out.println("你好," + name + "! 我是接口中的默认方法");
    }
}