Java8

Lambda表达式

​ Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递) , java中Lambda的本质是作为函数式接口的实例

​ “->” 操作符被称为 Lambda 操作符或箭头操作符 , 左侧：指定了 Lambda 表达式需要的参数列表 右侧：指定了Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

//格式一: 无参数无返回值
Runnable r1=new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名实现");
    }
};
r1.run();
System.out.println("**** Lambda ****");
Runnable r2=()-> {System.out.println("格式一: 无参数无返回值");};
r2.run();

//格式二: 一个参数,无返回值
Consumer<String> con=new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
con.accept("hhh");
System.out.println("**** Lambda ****");
Consumer<String> con1=(String s)->{System.out.println(s);};
con1.accept("格式二: 一个参数,无返回值");

//格式三: 数据类型可以省略,类型推断
System.out.println("**** Lambda ****");
Consumer<String> con2=(s)->{System.out.println(s);};
con2.accept("格式三: 数据类型可以省略,类型推断");

//格式四: Lambda若只需要一个参数,参数小括号可省
System.out.println("**** Lambda ****");
Consumer<String> con3=s->{System.out.println(s);};
con3.accept("格式四: Lambda若只需要一个参数,参数小括号可省");

//格式五: Lambda需要两个或以上的参数,多条执行语句,并且可以有返回值
Comparator<Integer> com1=new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1,o2);
    }
};
System.out.println(com1.compare(12, 23));
System.out.println("**** Lambda ****");
//Lambda表达式
Comparator<Integer> com2=(o1,o2)->{
    System.out.println("格式五: Lambda需要两个或以上的参数,多条执行语句,并且可以有返回值");
    return Integer.compare(o1,o2);
};
System.out.println(com2.compare(1, 2));

//格式六:当lambda题只有一条语句时,return和{}若有,都可以省略
Comparator<Integer> com3=(o1,o2)->Integer.compare(o1,o2);
System.out.println(com3.compare(2,1));
}

函数式接口

如果一个接口,只声明了一个抽象方法,则此接口就为函数式接口 @FunctionalInterface , Lambda表达式是一个函数式接口的实例

@FunctionalInterface
public interface MyInterface {
    void method1();
}

四大核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer<T>消费型接口	T	void	对类型为T的对应应用操作,包含方法void accept(T t)
Supplier<T>供给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function<T,R>函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)
Predicate<T>断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回 boolean 值。包含方法：boolean test(T t)

@Test
public void test4(){
    happyTime(500, new Consumer<Double>() {
        @Override
        public void accept(Double aDouble) {
            System.out.println("普通测试"+aDouble);
        }
    });
    happyTime(400,money-> System.out.println("Lambda"+money));
}
public void happyTime(double money,Consumer<Double> con){
    con.accept(money);
}

@Test
public void test5(){
    List<String> list= Arrays.asList("北京","天津","东京","西京","南京","上海");
    List<String> filterStrs = filterString(list, new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.contains("京");
        }
    });
    System.out.println(filterStrs);
}
//根据给定的规则,过滤集合中的字符串,规则由Predicate的方法确定
public List<String> filterString(List<String> list, Predicate<String> pre){
    ArrayList<String> filterList=new ArrayList<>();
    for(String s:list){
        if(pre.test(s)){
            filterList.add(s);
        }
    }
    return filterList;
}
List<String> filterStrs1 = filterString(list, s->s.contains("京"));
System.out.println(filterStrs1);

函数式接口	参数类型	返回类型	用途
BiFunction <T, U ,R>	T, U	R	对类型为 T, U 参数应用操作，返回 R 类型的结 果。包含方法为： R apply(T t, U u);
UnaryOperator<T> (Function子接口)	T	T	对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为：T apply(T t);
BinaryOperator <T>(BiFunction 子接口)	T,T	T	对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为： T apply(T t1, T t2);
BiConsumer< T, U >	T,U	void	对类型为T, U 参数应用操作。 包含方法为： void accept(T t, U u)
BiPredicate <T,U>	T,U	boolean	包含方法为： boolean test(T t,U u)
ToIntFunction<T> ToLongFunction <T> ToDoubleFunction<T>	T	int long double	分别计算int、long、double值的函数
IntFunction<R> LongFunction <R>DoubleFunction<R>	int long double	R	参数分别为int、long、double 类型的函数

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用 , 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致

• 格式

  • 对象::非静态方法
  • 类::静态方法
  • 类::非静态方法

// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("北京");
System.out.println("*******************");
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("beijing");

Employee emp = new Employee(1001,"Tom",23,5600);
Supplier<String> sup1 = () -> emp.getName();
System.out.println(sup1.get());
System.out.println("*******************");
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());


// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)

Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
System.out.println(com1.compare(12,21));
System.out.println("*******************");
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(12,3));

Function<Double,Long> func = new Function<Double, Long>() {
    @Override
    public Long apply(Double d) {
        return Math.round(d);
    }
};
System.out.println("*******************");
Function<Double,Long> func1 = d -> Math.round(d);
System.out.println(func1.apply(12.3));
System.out.println("*******************");
Function<Double,Long> func2 = Math::round;
System.out.println(func2.apply(12.6));

// 情况三：类 :: 非静态方法
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
System.out.println(com1.compare("abc","abd"));
System.out.println("*******************");
Comparator<String> com2 = String :: compareTo;
System.out.println(com2.compare("abd","abm"));
//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
System.out.println(pre1.test("abc","abc"));
System.out.println("*******************");
BiPredicate<String,String> pre2 = String :: equals;
System.out.println(pre2.test("abc","abd"));

Function<Employee,String> func1 = e -> e.getName();
System.out.println(func1.apply(employee));
System.out.println("*******************");
Function<Employee,String> func2 = Employee::getName;
System.out.println(func2.apply(employee));

构造器引用

	和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

Supplier<Employee> sup = new Supplier<Employee>() {
    @Override
    public Employee get() {
        return new Employee();
    }
};
System.out.println("*******************");
Supplier<Employee>  sup1 = () -> new Employee();
System.out.println(sup1.get());
System.out.println("*******************");
Supplier<Employee>  sup2 = Employee :: new;
System.out.println(sup2.get());

Function<Integer,Employee> func1 = id -> new Employee(id);
Employee employee = func1.apply(1001);
System.out.println(employee);
System.out.println("*******************");
Function<Integer,Employee> func2 = Employee :: new;
Employee employee1 = func2.apply(1002);
System.out.println(employee1);

数组引用

把数组看成一个特殊的类

//Function中的R apply(T t)
Function<Integer,String[]> func1 = length -> new String[length];
String[] arr1 = func1.apply(5);
System.out.println(Arrays.toString(arr1));
System.out.println("*******************");
Function<Integer,String[]> func2 = String[] :: new;
String[] arr2 = func2.apply(10);
System.out.println(Arrays.toString(arr2));

Stream API

Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据 结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中， 后者主要是面向 CPU，通过 CPU 实现计算。

• Stream 自己不会存储元素。

• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

• Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

1. 创建 Stream 一个数据源（如：集合、数组），获取一个流
2. 中间操作 一个中间操作链，对数据源的数据进行处理
3. 终止操作(终端操作) 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

实例化StreamAPI

//创建 Stream方式一：通过集合
@Test
public void test1() {
    List<Employee> employees = EmployeeData.getEmployees();
    //        default Stream<E> stream() : 返回一个顺序流
    Stream<Employee> stream = employees.stream();
    //        default Stream<E> parallelStream() : 返回一个并行流
    Stream<Employee> parallelStream = employees.parallelStream();
}

//创建 Stream方式二：通过数组
@Test
public void test2() {
    int[] arr = new int[]{1, 2, 3, 4, 5, 6};
    //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
    IntStream stream = Arrays.stream(arr);
    Employee e1 = new Employee(1001, "Tom");
    Employee e2 = new Employee(1002, "Jerry");
    Employee[] arr1 = new Employee[]{e1, e2};
    Stream<Employee> stream1 = Arrays.stream(arr1);

}

//创建 Stream方式三：通过Stream的of()
@Test
public void test3() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
}

//创建 Stream方式四：创建无限流
@Test
public void test4() {
    //      迭代
    //      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
    //遍历前10个偶数
    Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
    //      生成
    //      public static<T> Stream<T> generate(Supplier<T> s)
    Stream.generate(Math::random).limit(10).forEach(System.out::println);
}

Stream 的中间操作

//1-筛选与切片
@Test
public void test1(){
    List<Employee> list = EmployeeData.getEmployees();
    //        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
    Stream<Employee> stream = list.stream();
    //练习：查询员工表中薪资大于7000的员工信息
    stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
    System.out.println();
    
    //        limit(n)——截断流，使其元素不超过给定数量。
    list.stream().limit(3).forEach(System.out::println);
    System.out.println();

    //        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
    list.stream().skip(3).forEach(System.out::println);
    System.out.println();
    
    //        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    list.add(new Employee(1010,"刘强东",40,8000));
    list.add(new Employee(1010,"刘强东",41,8000));
    list.add(new Employee(1010,"刘强东",40,8000));
    list.add(new Employee(1010,"刘强东",40,8000));
    list.add(new Employee(1010,"刘强东",40,8000));
    //        System.out.println(list);
    list.stream().distinct().forEach(System.out::println);
}

//2-映射
@Test
public void test2(){
    //        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
    List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
    list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

    //        练习1：获取员工姓名长度大于3的员工的姓名。
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<String> namesStream = employees.stream().map(Employee::getName);
    namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
    System.out.println();
    //练习2：
    Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
    streamStream.forEach(s ->{
        s.forEach(System.out::println);
    });
    System.out.println();
    //        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
    Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
    characterStream.forEach(System.out::println);

}

//将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str){//aa
    ArrayList<Character> list = new ArrayList<>();
    for(Character c : str.toCharArray()){
        list.add(c);
    }
    return list.stream();
}
@Test
public void test3(){
    ArrayList list1 = new ArrayList();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    ArrayList list2 = new ArrayList();
    list2.add(4);
    list2.add(5);
    list2.add(6);

    //        list1.add(list2);
    list1.addAll(list2);
    System.out.println(list1);

}

//3-排序
@Test
public void test4(){
    //        sorted()——自然排序
    List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
    list.stream().sorted().forEach(System.out::println);
    //抛异常，原因:Employee没有实现Comparable接口
    //        List<Employee> employees = EmployeeData.getEmployees();
    //        employees.stream().sorted().forEach(System.out::println);
    
    //sorted(Comparator com)——定制排序
    List<Employee> employees = EmployeeData.getEmployees();
    employees.stream().sorted( (e1,e2) -> {
        int ageValue = Integer.compare(e1.getAge(),e2.getAge());
        if(ageValue != 0){
            return ageValue;
        }else{
            return -Double.compare(e1.getSalary(),e2.getSalary());
        }
    }).forEach(System.out::println);
}

终止操作

//1-匹配与查找
@Test
public void test1(){
    List<Employee> employees = EmployeeData.getEmployees();

    //        allMatch(Predicate p)——检查是否匹配所有元素。
    //          练习：是否所有的员工的年龄都大于18
    boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
    System.out.println(allMatch);

    //        anyMatch(Predicate p)——检查是否至少匹配一个元素。
    //         练习：是否存在员工的工资大于 10000
    boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
    System.out.println(anyMatch);

    //        noneMatch(Predicate p)——检查是否没有匹配的元素。
    //          练习：是否存在员工姓“雷”
    boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
    System.out.println(noneMatch);
    //        findFirst——返回第一个元素
    Optional<Employee> employee = employees.stream().findFirst();
    System.out.println(employee);
    //        findAny——返回当前流中的任意元素
    Optional<Employee> employee1 = employees.parallelStream().findAny();
    System.out.println(employee1);
}
@Test
public void test2(){
    List<Employee> employees = EmployeeData.getEmployees();
    // count——返回流中元素的总个数
    long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
    System.out.println(count);
    //        max(Comparator c)——返回流中最大值
    //        练习：返回最高的工资：
    Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
    Optional<Double> maxSalary = salaryStream.max(Double::compare);
    System.out.println(maxSalary);
    //        min(Comparator c)——返回流中最小值
    //        练习：返回最低工资的员工
    Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    System.out.println(employee);
    System.out.println();
    //        forEach(Consumer c)——内部迭代
    employees.stream().forEach(System.out::println);
    //使用集合的遍历操作
    employees.forEach(System.out::println);
}

//2-归约
@Test
public void test3(){
    //reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
    //        练习1：计算1-10的自然数的和
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer sum = list.stream().reduce(0, Integer::sum);
    System.out.println(sum);
    //reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
    //        练习2：计算公司所有员工工资的总和
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
    //Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
    Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
    System.out.println(sumMoney.get());
}
//3-收集
@Test
public void test4(){
    //collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
    //练习：查找工资大于6000的员工，结果返回为一个List或Set
    List<Employee> employees = EmployeeData.getEmployees();
    List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
    employeeList.forEach(System.out::println);
    System.out.println();
    Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
    employeeSet.forEach(System.out::println);
}

Optional类

​ Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表 这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不 存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象

• 创建Optional类对象的方法：
  • Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
  • Optional.empty() : 创建一个空的 Optional 实例
  • Optional.ofNullable(T t)：t可以为null
• 判断Optional容器中是否包含对象：
  • boolean isPresent() : 判断是否包含对象
  • void ifPresent(Consumer consumer) ：如果有值，就执行Consumer 接口的实现代码，并且该值会作为参数传给它。
• 获取Optional容器的对象：
  • T get(): 如果调用对象包含值，返回该值，否则抛异常
  • T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
  • T orElseGet(Supplier other) ：如果有值则将其返回，否则返回由 Supplier接口实现提供的对象。
  • T orElseThrow(Supplier exceptionSupplier) ：如果有值则将其返 回，否则抛出由Supplier接口实现提供的异常。

Girl girl = new Girl();
//of(T t):保证t是非空的
Optional<Girl> optionalGirl = Optional.of(girl);
girl = null;
//ofNullable(T t)：t可以为null
Optional<Girl> optionalGirl = Optional.ofNullable(girl);
//orElse(T t1):如果单前的Optional内部封装的t是非空的，则返回内部的t.
//如果内部的t是空的，则返回orElse()方法中的参数t1.
Girl girl1 = optionalGirl.orElse(new Girl("aaa"));

Optional<Boy> boyOptional = Optional.ofNullable(boy);
//此时的boy1一定非空
Boy boy1 = boyOptional.orElse(new Boy(new Girl("aaa")));
Girl girl = boy1.getGirl();
Optional<Girl> girlOptional = Optional.ofNullable(girl);
//girl1一定非空
Girl girl1 = girlOptional.orElse(new Girl("bbb"));

Java9

模块化系统

​ 模块(module)的概念，其实就是package外再裹一层，不声明默认就是隐藏。

​ 不同模块src下简历module-info.java

module java9test {

    exports com.atguigu.bean;
}

module day13 {

    requires java9test;
    requires java.net.http;
}

jShell命令

Java的REPL工具： jShell命令 , 让Java可以像脚本语言一样运行，从 控制台启动jShell，利用jShell在没有创建类的情况下直接声明变量，计算表达式， 执行语句。也可以从文件中加载语句或者将语句保存到文件中。

命令行输入jshell打开 , /edit可调出编辑窗口

接口的私有方法

在Java 9中，接口更加的灵活和强大，接口的方法的访问权限修饰符可以声明为private

钻石操作符升级

将能够与匿名实现类共同使用钻石操作符

// anonymous classes can now use type inference
Comparator<Object> com = new Comparator<>(){
	@Override
	public int compare(Object o1, Object o2) {
		return 0;
	}
};

try语句

​ Java 8 中，可以实现资源的自动关闭，但是要求执行后必须关闭的所有资源必须在try子句中初始化，否则编译不通过。Java 9 中，用资源语句编写try将更容易，可以在try子句中使用已经初始化过的资源，此时的资源是final的：

//java 8之前的资源关闭的操作
//        InputStreamReader reader = null;
//        try {
//            reader = new InputStreamReader(System.in);
//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf) )!= -1){
//                String str = new String(cbuf,0,len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            if(reader != null){
//                try {
//                    reader.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//
//            }
//        }

        //java 8中资源关闭操作: Java 8 中，可以实现资源的自动关闭
        //要求自动关闭的资源的实例化必须放在try的一对小括号中,多组之间分号相隔
//        try(InputStreamReader reader = new InputStreamReader(System.in)){
//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf) )!= -1){
//                String str = new String(cbuf,0,len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//java9中资源关闭操作：需要自动关闭的资源的实例化可以放在try的一对小括号外。
//此时的资源属性是常量，声明为final的，不可修改
InputStreamReader reader = new InputStreamReader(System.in);
try (reader) {

    char[] cbuf = new char[20];
    int len;
    if((len = reader.read(cbuf) )!= -1){
        String str = new String(cbuf,0,len);
        System.out.println(str);
    }

    //            reader = null;
} catch (IOException e) {
    e.printStackTrace();
}

String存储结构

String StringBuffer 和 StringBuilder 不再使用char[] 存储，改成了 byte[] 加上编码标记，节约了一些空间。

集合工厂方法

快速创建只读集合

只读、不可改变的集合，必须构造和分配它，然后添加元素，最后 包装成一个不可修改的集合。

//jdk8
List<String> namesList = new ArrayList<>();
namesList.add("Joe");
namesList.add("Bob");
namesList.add("Bill");
//返回的namesList是一个只读的集合
namesList = Collections.unmodifiableList(namesList);
namesList.add("Tom");//ERROR
System.out.println(namesList);
List<String> list = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));
Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));
// 如下操作不适用于jdk 8 及之前版本,适用于jdk 9
Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() {
    {
        put("a", 1);
        put("b", 2);
        put("c", 3);
    }
});
map.forEach((k, v) -> System.out.println(k + ":" + v));

//此时得到的集合list也是一个只读集合。
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
//报异常
list.add(6);

//java9新特性八：集合工厂方法：创建只读集合 of方法
List<Integer> list1 = List.of(1, 2, 3, 4, 5);
Set<Integer> set1 = Set.of(23, 3, 54, 65, 43, 76, 87, 34, 46);
Map<String, Integer> map1 = Map.of("Tom", 23, "Jerry", 54, "HanMeimei", 12);
Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 34), Map.entry("Jerry", 21));

InputStream的新方法:tranferTo()

ClassLoader cl = this.getClass().getClassLoader();
try (InputStream is = cl.getResourceAsStream("hello.txt");
     OutputStream os = new FileOutputStream("src\\hello1.txt")) {
    is.transferTo(os); // 把输入流中的所有数据直接自动地复制到输出流中
} catch (IOException e) {
    e.printStackTrace();
}

增强的 Stream API

//java9新特性十：Stream API的加强
@Test
public void test1(){
    List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);
    //takeWhile 返回从开头开始的按照指定规则尽量多的元素
    //        list.stream().takeWhile(x -> x < 60).forEach(System.out::println);
    //dropWhile():与 takeWhile 相反，返回剩余的元素。
    list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
}
@Test
public void test2(){
    //of()参数中的多个元素，可以包含null值
    Stream<Integer> stream1 = Stream.of(1, 2, 3,null);
    stream1.forEach(System.out::println);
    //of()参数不能存储单个null值。否则，报异常
    //Stream<Object> stream2 = Stream.of(null);
    //stream2.forEach(System.out::println);
    Integer i = 10;
    i = null;
    //ofNullable()：形参变量是可以为null值的单个元素  Java8中Stream不能完全为null，否则会报空指针异常
    Stream<Integer> stream3 = Stream.ofNullable(i);
    long count = stream3.count();
    System.out.println(count);
}
@Test
public void test3(){
    Stream.iterate(0,x -> x + 1).limit(10).forEach(System.out::println);
    //java9中新增的重载的方法
    Stream.iterate(0,x -> x < 100,x -> x + 1).forEach(System.out::println);
}

//java9新特性十一：Optional提供了新的方法stream()
@Test
public void test4(){
    List<String> list = new ArrayList<>();
    list.add("Tom");
    list.add("Jerry");
    list.add("Tim");

    Optional<List<String>> optional = Optional.ofNullable(list);
    Stream<List<String>> stream = optional.stream();
    //        long count = stream.count();
    //        System.out.println(count);
    stream.flatMap(x -> x.stream()).forEach(System.out::println);
}

Javascript引擎升级

​ Nashorn 项目在 JDK 9 中得到改进，它为Java提供轻量级的Javascript运行。JDK 9 包含一个用来解析 Nashorn 的 ECMAScript 语法树的 API。这个 API 使得 IDE 和服务端框架不需要依赖 Nashorn 项目的内部实现类，就能够分析 ECMAScript 代码

​ JDK11移除

Java10

局部变量类型推断

//1.局部变量的初始化
var list = new ArrayList<Integer>();
list.add(123);
//2.增强for循环中的索引
for(var v : list) {
	System.out.println(v);
}
//3.传统for循环中
for(var i = 0;i < 100;i++) {
	System.out.println(i);
}

在局部变量中使用时，如下情况不适用：

• 初始值为null
• 方法引用
• Lambda表达式
• 为数组静态初始化(只能省一边)

不适用以下的结构中:

• 没有初始化的局部变量声明
• 方法的返回类型
• 方法的参数类型
• 构造器的参数类型
• 属性
• catch块

集合新增创建不可变集合的方法

​ Java 9 开始，Jdk 里面为集合（List / Set / Map）都添加了 of (jdk9新增)和 copyOf (jdk10新增)方法，它们两个都用来创建不可变的集合。

//示例1：本身只读返回同一个
var list1 = List.of("Java", "Python", "C");
var copy1 = List.copyOf(list1);
System.out.println(list1 == copy1); // true
//示例2：本身不为只读,新建一个只读集合
var list2 = new ArrayList<String>();
var copy2 = List.copyOf(list2);
System.out.println(list2 == copy2); // false

Java11

字符串处理

描述	举例
判断字符串是否为空白(\t \n都为空白)	" ".isBlank(); // true
去除首尾空白	" Javastack ".strip(); // “Javastack”
去除尾部空格	" Javastack “.stripTrailing();// " Javastack”
去除首部空格	Javastack ".stripLeading(); // "Javastack "
复制字符串	“Java”.repeat(3);// “JavaJavaJava”
行数统计	“A\nB\nC”.lines().count(); // 3

Optional 加强

var op = Optional.empty();
System.out.println(op.isPresent());//判断内部的value是否存在
System.out.println(op.isEmpty());//判断内部的value是否为空

op = Optional.of("abc");
//orElseThrow()value非空，返回value；否则抛异常NoSuchElementException
var obj = op.orElseThrow();
System.out.println(obj);

Optional<String> op1 = Optional.of("hello");
//or:value非空，返回对应的Optional；value为空，返回形参封装的Optional
Optional<Object> op2 = op.or(() -> op1);
System.out.println(op2);

局部变量类型推断升级

在var上添加注解的语法格式

//使用var的好处是在使用lambda表达式时给参数加上注解。
Consumer<String> con2 = (@Deprecated var t) -> 
System.out.println(t.toUpperCase());

全新的HTTP 客户端API

​ HTTP/1.1和HTTP/2的主要区别是如何在客户端和服务器之间构建和传输数据。 HTTP/1.1依赖于请求/响应周期。 HTTP/2允许服务器“push”数据：它可以发 送比客户端请求更多的数据。将替代仅适用blocking 模式的 HttpURLConnection （HttpURLConnection是在HTTP 1.0的时代创建的，并使用了协议无关的方法 , 并提供对WebSocket 和 HTTP/2的支持

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
BodyHandler<String> responseBodyHandler = BodyHandlers.ofString();
HttpResponse<String> response = client.send(request, responseBodyHandler);
String body = response.body();
System.out.println(body);

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
BodyHandler<String> responseBodyHandler = BodyHandlers.ofString();
CompletableFuture<HttpResponse<String>> sendAsync = client.sendAsync(request, responseBodyHandler);
sendAsync.thenApply(t -> t.body()).thenAccept(System.out::println);
//HttpResponse<String> response = sendAsync.get();
//String body = response.body();
//System.out.println(body);

更简化的编译运行程序

java Javastack.java

注意点:

1. 执行源文件中的第一个类, 第一个类必须包含主方法。
2. 并且不可以使用其它源文件中的自定义类, 本文件中的自定义类是可以使用的

废弃Nashorn引擎

废弃Nashorn引擎

ZGC

​ ZGC, A Scalable Low-Latency Garbage Collector(Experimental) ZGC, 这应该是JDK11最为瞩目的特性。ZGC是一个并发, 基于region, 压缩型的垃圾收集器, 只有root扫描阶段会 STW(stop the world), 因此GC停顿时间不会随着堆的增长和存活对象的增长 而变长

GC暂停时间不会超过10ms

既能处理几百兆的小堆, 也能处理几个T的大堆(OMG)

和G1相比, 应用吞吐能力不会下降超过15%

为未来的GC功能和利用colord指针以及Load barriers优化奠定基础

初始只支持64位系统