JDK13，不如温习下Java8

JDK13于9月17号正式GA，版本新特性可参考： https://www.oschina.net/news/109934/jdk-13-released

虽然JDK更新迅速，但开发者貌似并不买账，据统计，目前仍以JDK8使用最多，预计可能还会延续好长一段时间。虽然JDK版本已至13，但对Java8的新特性，掌握程度如何呢？
本文对Java8的主要特性进行了梳理。供温习参考。

1. 接口默认方法

以前的接口只允许有抽象方法（没有实现体），java8中提供了接口默认方法支持，即可以提供方法的默认实现，实现类可以直接继承，也可以覆盖。默认方法主要解决接口的修改导致现有实现类不兼容的问题。

@RunWith(SpringRunner.class)
@SpringBootTest
public class InterfaceDefaultFunctionTest {

    public interface MyFunction<T> {
        T func(T t);

        //默认方法
        default int func2(T t){
            return t.hashCode();
        }
        //静态方法
        static<T> void print(T t) {
            System.out.println(t);
        }
    }

    @Test
    public void testInterface(){
        MyFunction<String> myFunction = new MyFunction<String>(){
            @Override
            public String func(String s) {
                return s.toUpperCase();
            }
        };
        System.out.println(myFunction.func("abc"));
        System.out.println(myFunction.func2("abc"));
        LambdaTest.MyFunction.print("efg");
    }
}

默认方法通过关键字 default 声明。同时也可以在接口中定义静态方法。

2. 函数式接口

函数式接口就是有且仅有一个抽象方法的接口（可以有其它非抽象方法），如1所示代码中 MyFunction 就是一个函数式接口，只有一个抽象方法 func， 其它非抽象方法如默认方法 func2， 静态方法 print 不影响其函数式接口的特性。

函数式接口可以使用注解 @FunctionalInterface 标注，该注解会去检查接口是否符合函数式接口的规范要求，不符合的话IDE会给出提示。

java中内置了一些函数式接口，

函数式接口	描述
Consumer	包含方法 void accept(T t)， 对类型为T的对象t进行操作
Supplier	包含方法 T get()，返回类型为T的对象
Function<T,R>	包含方法 R apply(T t)，对类型为T的对象进行操作，返回类型R的对象
Predicat	包含方法 boolean test(T t)， 判断类型为T的对象是否满足条件

以及基于这些接口的其它变种或子接口，如BiConsumer<T,U>，BiFunction<T,U,R>等。还有如Runnable，Callable等接口，也属于函数式接口 —— 都只有一个抽象方法。

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);

    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
        Objects.requireNonNull(after);

        return (l, r) -> {
            accept(l, r);
            after.accept(l, r);
        };
    }
}

3. Lambda表达式

lambda表达式实质就是一个匿名函数，在python中很常见，java到了jdk8提供了支持。

lambda表达式的格式形如： (参数) -> {方法体语句}，当参数只有一个时，左边小括号可以省略，当方法体语句只有一条时，右边大括号可以省略。

Java的lambda表达式基本上是对函数式接口实现的一种简化 —— 用lambda表达式直接代替一个函数式接口的具体实现（抽象方法的实现）。当我们使用jdk8在IDE中编写1中代码时，IDE会给出提示，

匿名实现类可以用lambda表达式替换。上述代码使用lambda表达式替换可调整为，

@Test
public void testInterface(){
    MyFunction<String> myFunction = s -> s.toUpperCase();
    System.out.println(myFunction.func("abc"));
    System.out.println(myFunction.func2("abc"));
}

lambda表达式甚至可作为方法参数传入（实质也是作为一个函数式接口的实现类实例）

@FunctionalInterface
public interface MyFunction<T> {
    T func(T t);
}

public void print(MyFunction<String> function, String s){
    System.out.println(function.func(s));
}

@Test
public void testInterface(){
   //将lambda表达式作为方法参数传入
   print((String s) -> s.toUpperCase(), "abc");
}

局部变量在lambda表达式中是只读的，虽可不声明为final，但无法修改。如

@Test
public void testInterface(){
    int i = 1;
    //lambda表达式中无法修改局部变量i，将报编译错误
    print((String s) -> {i = i+10; return s.toUpperCase();}, "abc");
}

4. 方法引用

当需要使用lambda表达式时，如果已经有了相同的实现方法，则可以使用方法引用来替代lambda表达式，几种场景示例如下。

@RunWith(SpringRunner.class)
@SpringBootTest
public class FunctionReferenceTest {

    @Test
    public void testFunctionReference() {
        // 实例::实例方法
        Consumer<String> consumer = s -> System.out.println(s); //lambda表达式
        Consumer<String> consumer2 = System.out::println; //方法引用
        consumer.accept("abc");
        consumer2.accept("abc");

        //类::静态方法
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y); //lambda表达式
        Comparator<Integer> comparator2 = Integer::compare; //方法引用
        System.out.println(comparator.compare(10, 8));
        System.out.println(comparator2.compare(10, 8));

        //类::实例方法， 当引用方法是形如 a.func(b)时，用类::实例方法的形式
        BiPredicate<String, String> biPredicate = (a, b) -> a.equals(b); //lambda表达式
        BiPredicate<String, String> biPredicate2 = String::equals; //方法引用
        System.out.println(biPredicate.test("abc", "abb"));
        System.out.println(biPredicate2.test("abc","abb"));

        //type[]::new 数组引用
        Function<Integer,Integer[]> fun= n-> new Integer[n]; //lambda表达式
        Function<Integer,Integer[]> fun2=Integer[]::new; //方法引用
        System.out.println(fun.apply(10));
        System.out.println(fun2.apply(10));

        //构造器引用
        Function<String,String> func = n-> new String(n); //lambda表达式
        Function<String,String> func2 = String::new; //方法引用
        System.out.println(func.apply("aaa"));
        System.out.println(func2.apply("aaa"));
    }
}

5. Stream API

Stream与lambda应该是java8最重要的两大特性。Stream 对集合的处理进行了抽象，可以对集合进行非常复杂的查找、过滤和映射等操作。提供了一种高效的且易于使用的处理数据的方式。
Stream的三个特性：

• Stream本身不会存储元素
• Stream不会改变操作对象（即集合），会返回一个新的Stream
• Stream的中间操作不会立刻执行，而是会等到需要结果的时候才执行

Java8 的Collection接口包含了两个方法 stream(), parallelStream()， 分别返回一个顺序流与一个并行流，所有Collection类型（如List， ）的对象可以调用这两个方法生成流。
Java8 的Arrays类也提供了 stream(T[] array)等方法用以生成流。也可以使用静态方法 Stream.iterate() 和 Stream.generate() 来创建无限流。

Stream的中间操作包括

操作	描述
filter(Predicate p)	接收 Lambda ， 从流中过滤出满足条件的元素
distinct()	通过hashCode() 和 equals() 去除重复元素
limit(long maxSize)	截断流，使元素的个数不超过给定数量
skip(long n)	跳过前面的n个元素，若流中元素不足n个，则返回一个空流
map(Function f)	将每个元素使用函数f执行，将其映射成一个新的元素
mapToDouble(ToDoubleFunction f)	将每个元素使用f执行，产生一个新的DoubleStream流
mapToInt(ToIntFunction f)	将每个元素使用f执行，产生一个新的IntStream流
mapToLong(ToLongFunction f)	将每个元素使用f执行，产生一个新的LongStream流
flatMap(Function f)	将流中的每个值都通过f转换成另一个流，然后把所有流连接成一个流
sorted()	按自然顺序排序，产生一个新流
sorted(Comparator comp)	根据比较器排序，产生一个新流
allMatch(Predicate p)	判断是否匹配所有元素
anyMatch(Predicate p)	判断是否匹配至少一个元素
noneMatch(Predicate p)	判断是否没有匹配任意元素
findFirst()	返回第一个元素
findAny()	返回任意一个元素
reduce(T iden, BinaryOperator b)	对流中的元素进行reduce操作，返回T类型对象
reduce(BinaryOperator b)	对流中的元素进行reduce操作，返回Optional对象

Stream的终止操作包括

操作	描述
count()	返回元素总数
max(Comparator c)	返回最大值
min(Comparator c)	返回最小值
forEach(Consumer c)	内部迭代调用Consumer操作
collect(Collector c)	将流转换为其他形式，一般通过Collectors来实现

Stream使用示例

@Test
public void testStream() {
    List<User> list = new ArrayList<>();
    //转换为List，这里没啥意义，仅做示范
    List<User> users = list.stream().collect(Collectors.toList());
    //转换为Set
    Set<User> users1 = list.stream().collect(Collectors.toSet());
    //转换为Collection
    Collection<User> users2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
    //计数
    long count = list.stream().collect(Collectors.counting());
    //求和
    int total = list.stream().collect(Collectors.summingInt(User::getAge));
    //求平均值
    double avg= list.stream().collect(Collectors.averagingInt(User::getAge));
    //获取统计对象，通过该统计对象可获取最大值，最小值之类的数据
    IntSummaryStatistics iss= list.stream().collect(Collectors.summarizingInt(User::getAge));
    //将值通过","拼接
    String str= list.stream().map(User::getName).collect(Collectors.joining(","));
    //最大值
    Optional<User> max= list.stream().collect(Collectors.maxBy(Comparator.comparingInt(User::getAge)));
    //最小值
    Optional<User> min = list.stream().collect(Collectors.minBy(Comparator.comparingInt(User::getAge)));
    //从累加器开始，对指定的值，这里是年龄，进行sum的reduce操作
    int t =list.stream().collect(Collectors.reducing(0, User::getAge, Integer::sum));
    //对转换的结果再进行处理
    int how = list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
    //分组
    Map<String, List<User>> map= list.stream().collect(Collectors.groupingBy(User::getName));
    //根据条件进行分区
    Map<Boolean,List<User>> vd= list.stream().collect(Collectors.partitioningBy(u -> u.getName().startsWith("W")));

}

6. Optional类

Optional是一个容器类，可以避免显式的null判断，基本使用示例如下

@RunWith(SpringRunner.class)
@SpringBootTest
public class OptionalTest {

    @Test
    public void testOptional(){
        // of 不允许传入null值，否则抛出NPE
        Optional<Integer> optional = Optional.of(new Integer(10));
        System.out.println(optional.get());

        // ofNullable 允许传入null，但是直接调用get会抛出NoSuchElementException异常，
        // 可通过isPresent判断是否存在值
        Optional<Integer> optional1 = Optional.ofNullable(null);
        if(optional1.isPresent()) {
            System.out.println(optional1.get());
        }else{
            System.out.println("optional1 is empty");
        }
        // orElse 判断是否存在值，存在则返回，不存在则返回参数里的值
        Integer value = optional1.orElse(new Integer(0));

        // map方法，如果optional有值，则对值进行处理返回新的Optional，
        // 如果没有值则返回Optional.empty()
        optional = optional.map(x -> x*x);
        System.out.println(optional.get());

        // 与map类似，只是要求返回值必须是Optional，进一步避免空指针
        optional = optional.flatMap(x ->Optional.of(x*x));
        System.out.println(optional.get());

    }
}

7. Base64

在java8中，Base64成为了java类库的标准，可直接使用

import java.util.Base64;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Base64Test {

    @Test
    public void testBase64(){
        //base64编码
        String encode = Base64.getEncoder().encodeToString("abc".getBytes());
        System.out.println(encode);
        //base64解码
        System.out.println(new String(Base64.getDecoder().decode(encode)));
    }
}

8. 日期时间类

以前的Date类是非线程安全的，并且一些常用的日期时间运算需要自己编写util工具类。java8推出了java.time包，里面包含了如 LocalDate, LocalTime, LocalDateTime等类，可方便地进行日期时间的运算，如日期间隔、时间间隔，日期时间的加减，格式化等等。

—————————————————————————————
作者：空山新雨
欢迎关注我的微信公众号：jboost-ksxy