jdk9新特性--卷？

集合工厂方法 of

package jdk9;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 集合工厂方法
 * 在 Java 9 中为集合的创建增加了静态工厂创建方式，也就是 of 方法，
 * 通过静态工厂 of 方法创建的集合是只读集合，里面的对象不可改变。
 * 并在不能存在 null 值，对于 set 和 map 集合，也不能存在 key 值重复。
 * 这样不仅线程安全，而且消耗的内存也更小
 */
public class Of {
    public static void main(String[] args) {
        List<String> stringList = List.of("a", "b", "c", "d");
        Set<String> stringSet = Set.of("a", "b", "c", "d");
        Map<String, Integer> stringIntegerMap = Map.of("key1", 1, "key2", 2, "key3", 3);
        Map<String, Integer> stringIntegerMap2 = Map.ofEntries(Map.entry("key1", 1), Map.entry("key2", 2));

        System.out.println(stringList);
        System.out.println(stringSet);
        System.out.println(stringIntegerMap);
        System.out.println(stringIntegerMap2);

        /*
         *  通过 of 方法创建的 set 和 map 集合在遍历时，在每个 JVM 周期遍历顺序是随机的
         * [a, b, c, d]
         * [a, d, c, b]
         * {key1=1, key3=3, key2=2}
         * {key2=2, key1=1}
         */

        // 工厂可以自由创建新的实例或者复用现有实例，
        // 使用 of 创建的集合， 避免 == 或者 hashCode 判断操作
        List<String> stringList2 = List.of("a", "b", "c", "d");
        System.out.println(stringList.hashCode()); //3910595
        System.out.println(stringList2.hashCode()); //3910595
    }
}

Stream增强

package jdk9;

import org.junit.Test;

import java.util.List;
import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

/**
 * 在 Java 9 中，主要增加了 4 个新的操作方法：dropWhile，takeWhile，ofNullable，iterate
 */
public class StreamDemo {

    // 从头开始筛选，遇到不满足的就结束了
    @Test
    public void takeWhile() {
        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
        List<Integer> listResult = list1.stream().takeWhile(x -> x < 3).collect(toList());
        System.out.println(listResult); //[1, 2]
        List<Integer> list2 = List.of(1, 2, 3, 4, 3, 0);
        List<Integer> listResult2 = list2.stream().takeWhile(x -> x < 3).collect(toList());
        System.out.println(listResult2); //[1, 2]
    }

    // 从头开始删除，遇到不满足的就结束了
    @Test
    public void dropWhile() {
        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
        List<Integer> listResult = list1.stream().dropWhile(x -> x < 3).collect(toList());
        System.out.println(listResult);//[3, 4, 5]
        List<Integer> list2 = List.of(1, 2, 3, 4, 3, 0);
        List<Integer> listResult2 = list2.stream().dropWhile(x -> x < 3).collect(toList());
        System.out.println(listResult2);//[3, 4, 3, 0]
    }

    // 创建支持全 null 的 Stream
    @Test
    public void ofNullable() {
        Stream<Integer> stream = Stream.of(1, 2, null);
        stream.forEach(System.out::print);

        // stream = Stream.of(null); // 空指针异常
        stream = Stream.ofNullable(null);
        stream.forEach(System.out::print);
    }

    //可以重载迭代器
    @Test
    public void iterate() {
        IntStream.iterate(0, x -> x < 10, x -> x + 1).forEach(System.out::print);//0123456789
    }

    // Optional 转换成 Stream
    @Test
    public void optional() {
        Stream<Integer> s = Optional.of(1).stream();
        s.forEach(System.out::print);
    }
}

接口私有方法

package jdk9;

/**
 * 接口私有方法
 */
public class Interface {
    public static void main(String[] args) {
        A a = new A();
        a.sleep();
        a.eat();
        a.doXxx();
        /*
         * 躺着睡
         * 喝水
         * 喝水
         */
    }
}

class A implements People{

    @Override
    public void sleep() {
        System.out.println("躺着睡");
    }

}

interface People{
    void sleep();
    default void eat(){
        drink();
    }

    default void doXxx() {
        drink();
    }
    
    // 私有方法
    private void drink(){
        System.out.println("喝水");
    }
}

HTTP/2 客户端，11有新变化