生产都用jdk11了，我的知识还停留在jdk8(jdk9新特性分析)

2023-11-15 13:09:16

文章目录

背景

目前生产和开发中使用的jdk版本已经是11了，而自己对虽然对jdk8之后的版本看过一些博客，对新特性有一些了解，但没有全面学习过，所以今天就借这个时间系统性了解下，jdk8之后到11的新特性，咸鱼

JDK9新特性

授人以鱼不如授人以渔，这里给出官网的地址

官网全面介绍地址
 几个常用api的变动

这里我对常用api变动内容作一些翻译总结吧

1. Factory Methods for Collections (JEP 269)

添加了集合工厂方法

jdk8创建一个不可变集合代码

List<Point> myList = new ArrayList<>);
myList.add(new Point(1, 1));
myList.add(new Point(2, 2));
myList.add(new Point(3, 3));
myList.add(new Point(4, 4));
myList = Collections.unmodifiableList(myList);

可以看到还是挺麻烦的，比较方便我们可以使用Guava中的

  Lists.newArrayList();

需要引入额外的jar，现在jdk9原生的api也支持这些操作

	List<Point> list = List.of(new Point(1, 1), new Point(2, 2), 
    new Point(3, 3), new Point(4, 4));

2. Optional Class Enhancements

Optional 类的增强
在jdk9 中Optional 中增加了四个新方法

ifPresent(Consumer action): 如果存在一个值，使用该值执行操作

public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

ifPresentOrElse(Consumer action, Runnable emptyAction):但如果没有值，则执行emptyAction

public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

or(Supplier supplier):如果值存在，返回 Optional 指定的值，否则返回一个预设的值。

public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            @SuppressWarnings("unchecked")
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

stream(): 根据是否存在值，返回一个零元素或一个元素的流

public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

有java8基础看这些方法还是很清晰知道这些方法是干嘛的，所以这里就不作过多解释，具体的不懂的可以在使用的时候直接查看源码上的注释，都挺详细的

3.Stream API Enhancements

stream api的增强，新增了四个方法。

首先看看

takeWhile(Predicate) 和 dropWhile(Predicate)

default Stream<T> takeWhile(Predicate<? super T> predicate) {// ...}

default Stream<T> dropWhile(Predicate<? super T> predicate) {//...}

这两个方法limit ()和 skip ()方法的补充。不同的是他们的参数很灵活使用的一个Predicate函数

takeWhile 和 java8 中的filter很像，不同的是filter是匹配满足所有的，而takeWhile是只要后面的有一个不满足，就不继续匹配了，可以看看下面的例子

Stream.of("a","b","c","","e","f").takeWhile(s->!s.isEmpty())
         .forEach(System.out::print); 
         //输出 abc

dropWhile 与 takeWhile 相反

Stream.of("a","b","c","","e","f").dropWhile(s-> !s.isEmpty())
         .forEach(System.out::print);
         // 输出 ef

看样子有点鸡肋哈哈，目前来说没有看到适合的业务场景

ofNullable(T t)

如果指定元素为非 null，则获取一个元素并生成单个元素流，元素为 null 则返回一个空流。

show code

long count = Stream.ofNullable(100).count();
	  // 1
      System.out.println(count);
 
      count = Stream.ofNullable(null).count();
      // 0
      System.out.println(count);

iterate 方法

static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

构建一个无限流，第二个参数是终止条件，第三个参数是递归到下一层的参数