Java：31-新特性

新特性

Java8的新特性------------------------------------

Java8是 Java 语言的一个重要版本，该版本于2014年3月发布，是自Java5以来最具革命性的版本

这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性

函数式接口------------------------------------

函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator接口等，只能是一个方法（接口），否则该接口不算函数式接口，也就不能利用对应的特性了，即若写上会报错的（一般是编译期报错），一般静态的可以写，默认的可以写，私有的可以写，Object有的也可以写（因为也是默认存在的），其他的只要写上就不是函数式接口，自己可以进行测试

Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错

Java8中增加了java.util.function包，该包包含了常用的函数式接口，具体如下：

接口名称           方法声明       功能介绍
Consumer          void accept(T t)    根据指定的参数执行操作
Supplier          T get()          得到一个返回值
Function<T,R>     R apply(T t)   根据指定的参数执行操作并返回
Predicate         boolean test(T t)      判断指定的参数是否满足条件

Lambda表达式------------------------------------

Lambda 表达式是实例化函数式接口的重要方式，使用 Lambda 表达式可以使代码变的更加简洁紧凑，即对于的表达式以及后面说明的，基本都只是服务员函数式接口，否则若对方不是函数式接口，那么就会报错

lambda表达式：参数列表、箭头符号->和方法体组成，而方法体中可以是表达式，也可以是语句块

语法格式：(参数列表) -> { 方法体; } - 其中()、参数类型、{} 以及return关键字 可以省略

且认为是引用的类型的创建

如 a a = () -> System.out.println(“1”);

是与a有关的，与实现无关，其中a是接口，且参数列表里面只有一个参数时，()才可以省略，否则报错

且方法有返回值类型，那么结果就是返回值，而不是代码，即必须要当作返回值的Lambda表达式来使用

若要省略的话，{}和return要一起省略，否则若只省略{}，return会认为直接的返回，所以idea会提示的（自然也是编译的提示，他们认为是一起的，虽然idea可能扩展了）

若（）里没参数，那么（）不可以省略

匿名内部类重新写方法，即可以有@Override注解，当然不写这个注解也可以，且匿名内部类的方法可以使用当前整个方法的东西

如写在main方法里，那么main方法的变量，可以直接用

由于匿名内部类可重新写方法，那么接口的必须有该方法，即重写，而类可以不用，因为使用接口方法是必须要重写的

即可以理解为接口来说是实现，对类来说是继承

package com.lagou.task22;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class FunctionalInterfaceTest {

    public static void main(String[] args) {

        // 1.匿名内部类的语法格式： 父类/接口类型  引用变量名 = new 父类/接口类型(){ 方法的重写 };
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是既没有参数又没有返回值的方法！");
            }
        };
        runnable.run(); // 我是既没有参数又没有返回值的方法！

        // 使用lambda表达式实现函数式接口对象的创建: (参数列表)->{方法体;}
        //Runnable runnable1 = () -> { System.out.println("我是既没有参数又没有返回值的方法！"); };
        Runnable runnable1 = () -> System.out.println("我是既没有参数又没有返回值的方法！");  //如果是作为参数自然不需要;，;是用来结束的
        runnable1.run();

        System.out.println("----------------------------------------------------------------------");
        Consumer consumer = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o + "有参但没有返回值的方法就是我！");
            }
        };
        consumer.accept("友情提示："); // 友情提示：有参但没有返回值的方法就是我！

        //Consumer consumer1 = (Object o) -> {System.out.println(o+ "有参但没有返回值的方法就是我！");};
        //Consumer consumer1 = (o) -> System.out.println(o + "有参但没有返回值的方法就是我！");
        // 省略了()、参数类型、{}， 自动类型推断
        Consumer consumer1 = o -> System.out.println(o + "有参但没有返回值的方法就是我！");
        consumer1.accept("友情提示：");

        System.out.println("----------------------------------------------------------------------");
        Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return "无参有返回值！";
            }
        };
        System.out.println(supplier.get()); // 无参有返回值
        //可以在代码后面点sout那么就会直接到sout里面去
        //如上述的supplier.get().sout => System.out.println(supplier.get());
        //Supplier supplier1 = () -> {return "无参有返回值！";};
        Supplier supplier1 = () -> "无参有返回值！";
        System.out.println(supplier1.get());

        System.out.println("----------------------------------------------------------------------");
        Function function = new Function() {
            @Override
            public Object apply(Object o) {
                return o;
            }
        };
        System.out.println(function.apply("有参有返回值的方法")); // 有参有返回值的方法

        // return 和 {} 都可以省略
        Function function1 = o -> o;
        System.out.println(function1.apply("有参有返回值的方法"));

        System.out.println("----------------------------------------------------------------------");
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
        System.out.println(comparator.compare(10, 20)); // 0

        Comparator comparator1 = (o1, o2) -> 0;
        System.out.println(comparator1.compare(10, 20));

        System.out.println("----------------------------------------------------------------------");
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Object o) {
                return false;
            }
        };
        System.out.println(predicate.test("hello")); // false

        Predicate predicate1 = o -> false;
        System.out.println(predicate1.test("hello"));
    }
}

方法引用------------------------------------

方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行

方法引用使用一对冒号 :: 将类或对象与方法名进行连接

通常使用方式如下：

对象的非静态方法引用：ObjectName :: MethodName

类的静态方法引用：ClassName :: StaticMethodName

类的非静态方法引用：ClassName :: MethodName

构造器的引用：ClassName :: new

数组的引用：TypeName[] :: new

方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码

下面的了解即可，一般来说，只要都一样就没有问题

对于对象的非静态方法引用和类的静态方法引用来说--------------------------------------------------------------------

函数式接口的方法基本上必须要与调用的方法的返回值类型和参数列表一样才可使用该引用

之所以是基本上，是因为返回值类型可以不一样

即函数式接口的返回值类型为void时，调用方法的返回值类型可以不为void

即调用方法必须要满足函数式接口的作用，即无返回值时，当作语句块

有返回值时，你必须要返回一个值，且与函数式接口的返回值有关（自动装箱类似的操作，可以满足的也算）

而不是语句块，因为你要满足我的需求

即可以说函数式接口在返回值为void时，操作语句块，返回值不为void时，操作return

且调用方法的参数与函数式接口的参数一样（按顺序传入），即默认是该参数，当然在有返回值类型里也是一样的操作

对于类的非静态方法引用来说--------------------------------------------------------------------

函数式接口的方法可以与调用的方法的返回值类型，参数列表一样才可以使用该引用

之所以是可以，是因为返回值类型和参数列表都可以不相同，由于是类的非静态方法引用，那么就可以是类来调用

所以在使用类的非静态方法引用时，不会像类的静态方法引用那样，会调用类似的方法，而是解决函数式接口的参数来调用方法，这里就要说明特殊情况了，即后面的return o1.compareTo(o2);情况，一般当参数不一致，会使得将第一个作为引用，其余进行补充

因为需要引用，而这个引用就是参数，所以函数式接口的参数类型，必须要有一个是能调用的类型，如Test a,其中Test是类

那么类的非静态方法引用就是Test::(具体方法)，所以函数式接口里，必须要有一个参数是具体类的类型

而其他的参数必须要与调用方法一致，因为会为调用方法默认添加这些参数，实现调用，而返回值不同与上述需求一样，当然若满足来基本对应，那么以基本对应为主

对于构造器的引用来说--------------------------------------------------------------------

由于是创建对象，那么就会与函数式接口无关，即直接使用类::new，就可以创建该类的对象了，但是要注意

函数式的接口返回值类型要么为void，要么为该类，否则不会满足需求

如返回值为int，那么你返回对象是很明显的不可以

若需要函数式接口有参数，就会默认为该创建的对象按顺序传入参数

对于数组的引用来说--------------------------------------------------------------------

与构造器的引用类似，但是创建方式是数组名[]::new，即创建一个数组

且参数只可以是一个参数，不可以有多个，是用来指定长度的

package com.lagou.task22;

import java.util.Arrays;
import java.util.Comparator;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodReferenceTest {

    public static void main(String[] args) {

        // 1.使用匿名内部类的方式通过函数式接口Runnable中的方法实现对Person类中show方法的调用
        Person person = new Person("zhangfei", 30);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                person.show();
            }
        };
        runnable.run(); // 没事出来秀一下哦

        System.out.println("-------------------------------------------------------------");
        // 2.使用lambda表达式的方式实现Person类中show方法的调用
        Runnable runnable1 = () -> person.show();
        runnable1.run(); // 没事出来秀一下哦

        System.out.println("-------------------------------------------------------------");
        // 3.使用方法引用的方式实现Person类中show方法的调用
        Runnable runnable2 = person::show;
        runnable2.run();

        System.out.println("-------------------------------------------------------------");
        // 4.使用匿名内部类的方式通过函数式接口Consumer中的方法来实现Person类中setName方法的调用
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                person.setName(s);
            }
        };
        consumer.accept("guanyu");
        System.out.println("person = " + person); // guanyu 30

        System.out.println("-------------------------------------------------------------");
        // 5.使用lambda表达式的方式实现Person类中setName方法的调用
        Consumer<String> consumer1 = s -> person.setName("1");
        consumer1.accept("liubei");
        System.out.println("person = " + person); // liubei 30（没有设置1的话）

        System.out.println("-------------------------------------------------------------");
        // 6.使用方法引用的方式实现Person类中setName方法的调用
        Consumer<String> consumer2 = person::setName; //注意：当参数为类时，一般是作为调用者的，而不是参数，其他的函数式编程基本也是如此，当然，具体需要看你的测试，并不需要记住，在以后使用时，会熟悉的，复习即可
        consumer2.accept("zhangfei");
        System.out.println("person = " + person); // zhangfei 30

        System.out.println("-------------------------------------------------------------");
        // 7.使用匿名内部类的方式通过函数式接口Supplier中的方法来实现Person类中getName方法的调用
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return person.getName();
            }
        };
        System.out.println(supplier.get()); // zhangfei

        Supplier<String> supplier1 = () -> person.getName();
        System.out.println(supplier1.get()); // zhangfei

        Supplier<String> supplier2 = person::getName;
        System.out.println(supplier2.get()); // zhangfei

        System.out.println("-------------------------------------------------------------");
        // 8.使用匿名内部类的方式通过函数式接口Function中的方法实现Integer类中parseInt方法的调用
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        System.out.println(function.apply("12345")); // 12345

        Function<String, Integer> function1 = s -> Integer.parseInt(s);
        System.out.println(function1.apply("12345")); // 12345

        Function<String, Integer> function2 = Integer::parseInt;
        System.out.println(function2.apply("12345")); // 12345

        System.out.println("-------------------------------------------------------------");
        // 9.使用匿名内部类的方式通过函数式接口Comparator中的方法实现Integer类中compare方法的调用
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(comparator.compare(10, 20));  // -1

        Comparator<Integer> comparator1 = (o1, o2) -> Integer.compare(o1, o2);
        System.out.println(comparator1.compare(10, 20)); // -1

        Comparator<Integer> comparator2 = Integer::compare;
        System.out.println(comparator2.compare(10, 20)); // -1

        System.out.println("-------------------------------------------------------------");
        // 10.使用匿名内部类的方式通过类名来调用非静态方法
        // 其中一个参数对象作为调用对象来调用方法时，可以使用上述方式   更抽象
        Comparator<Integer> comparator3 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator3.compare(10, 20)); // -1

        Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comparator4.compare(10, 20)); // -1

        Comparator<Integer> comparator5 = Integer::compareTo;
        System.out.println(comparator5.compare(10, 20)); // -1

        System.out.println("-------------------------------------------------------------");
        // 11.使用匿名内部类的方式通过Supplier函数式接口创建Person类型的对象并返回
        Supplier<Person> supplier3 = new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person();
            }
        };
        System.out.println(supplier3.get()); // null 0

        Supplier<Person> supplier4 = () -> new Person();
        System.out.println(supplier4.get()); // null 0

        Supplier<Person> supplier5 = Person::new;
        System.out.println(supplier5.get()); // null 0

        System.out.println("-------------------------------------------------------------");
        // 12.使用匿名内部类的方式通过BiFunction函数式接口采用有参方式创建Person类型的对象并返回
        BiFunction<String, Integer, Person> biFunction = new BiFunction<String, Integer, Person>() {
            @Override
            public Person apply(String s, Integer integer) {
                return new Person(s, integer);
            }
        };
        System.out.println(biFunction.apply("zhangfei", 30)); // zhangfei 30

        BiFunction<String, Integer, Person> biFunction1 = (s, integer) -> new Person(s, integer);
        System.out.println(biFunction1.apply("zhangfei", 30)); // zhangfei 30

        BiFunction<String, Integer, Person> biFunction2 = Person::new;
        System.out.println(biFunction2.apply("zhangfei", 30)); // zhangfei 30

        System.out.println("-------------------------------------------------------------");
        // 12.使用匿名内部类的方式通过Function函数式接口创建指定数量的Person类型的对象数组并返回
        Function<Integer, Person[]> function3 = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer integer) {
                return new Person[integer];
            }
        };
        Person[] pArr = function3.apply(3);
        System.out.println(Arrays.toString(pArr));

        Function<Integer, Person[]> function4 = integer -> new Person[integer];
        System.out.println(Arrays.toString(function4.apply(4)));

        Function<Integer, Person[]> function5 = Person[]::new;
        System.out.println(Arrays.toString(function5.apply(5)));
    }
}

这里需要提一下函数式编程：他是一种编程范式，它强调将计算视为函数的计算，并避免使用可变状态和可变数据，比如下面的Stream就是一个函数式编程的实现，可以发现，我们操作他时，只需要参照函数的作用和参数即可，非常简洁，这就是函数式编程的特点或者说作用

Stream接口------------------------------------

public interface Stream<T>
extends BaseStream<T,Stream<T>>

public interface BaseStream<T,S extends BaseStream<T,S>>
extends AutoCloseable

public interface AutoCloseable

案例题目：准备一个List集合并放入Person类型的对象，将集合中所有成年人过滤出来放到另外一个集合并打印出来

package com.lagou.task22;

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println("没事出来秀一下哦");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        //return getName().compareTo(o.getName());
        return getAge() - o.getAge();
    }
}

package com.lagou.task22;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class ListPersonTest {

    public static void main(String[] args) {

        // 1.准备一个List集合并放入Person类型的对象后打印
        List<Person> list = new LinkedList<>();
        list.add(new Person("zhangfei", 30));
        list.add(new Person("xiaoqiao", 17));
        list.add(new Person("zhouyu", 20));
        list.add(new Person("zhangfei", 30));
        list.add(new Person("guanyu", 35));
        list.add(new Person("liubei", 40));
        for (Person tp: list) {
            System.out.println(tp);
        }

        System.out.println("-------------------------------------------------------");
        // 2.将List集合中所有成年人过滤出来并放入另外一个集合中打印
        List<Person> list1 = new LinkedList<>();
        for (Person tp : list) {
            if (tp.getAge() >= 18) {
                list1.add(tp);
            }
        }
        for (Person tp : list1) {
            System.out.println(tp);
        }

        System.out.println("-------------------------------------------------------");
        // 3.使用Stream接口实现上述功能
        list.stream().filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() >= 18;
            }
        }).forEach(new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println(person);
            }
        });

        System.out.println("-------------------------------------------------------");
        // 4.使用lambda表达式对上述代码进行优化
         //list.stream().filter(person -> person.getAge() >= 18).forEach(person -> System.out.println(person));
        list.stream().filter(person -> person.getAge() >= 18).forEach(System.out::println);
        //里面的内部不能加上;，因为他们代表整个参数，而参数自然不能加上的（也需要考虑;的结束意思），虽然有点怪，但是这是语法，规定如此，或者说函数式就是规定如此，遵守即可，除法你修改底层代码

        System.out.println("-------------------------------------------------------");
        // 5.实现对集合中元素通过流跳过2个元素后再取3个元素后打印
        list.stream().skip(2).limit(3).forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 6.实现集合中所有元素中的年龄获取出来并打印
        list.stream().map(new Function<Person, Integer>() {
            @Override
            public Integer apply(Person person) {
                return person.getAge();
            }
        }).forEach(System.out::println);

        //list.stream().map(person -> person.getAge()).forEach(System.out::println);
        list.stream().map(Person::getAge).forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 7.实现集合中所有元素的自然排序并打印
        list.stream().sorted().forEach(System.out::println);

        System.out.println("-------------------------------------------------------");
        // 8.判断集合中是否没有元素的年龄是大于45岁的
        boolean b1 = list.stream().noneMatch(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge() > 45;
            }
        });
        System.out.println("b1 = " + b1); // true

        b1 = list1.stream().noneMatch(person -> person.getAge() > 45);
        System.out.println("b1 = " + b1); // true

        System.out.println("-------------------------------------------------------");
        // 9.按照指定的比较器规则获取集合所有元素中的最大值
        Optional<Person> max = list.stream().max(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("按照年龄排序后的最大值是：" + max);

        max = list.stream().max((o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println("按照年龄排序后的最大值是：" + max);

        System.out.println("-------------------------------------------------------");
        // 10.实现将集合中所有元素的年龄映射出来并进行累加后打印
        Optional<Integer> reduce = list.stream().map(Person::getAge).
            reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        });
        System.out.println("最终所有年龄的累加和是：" + reduce); // 172

        //reduce = list.stream().map(Person::getAge).reduce(((integer, integer2) 
        -> integer + integer2));
        reduce = list.stream().map(Person::getAge).reduce((Integer::sum));
        System.out.println("最终所有年龄的累加和是：" + reduce); // 172

        System.out.println("-------------------------------------------------------");
        // 11.实现将集合中所有元素的姓名映射出来并收集到集合中打印
               list.stream().map(Person::getName).collect(Collectors.toList()).
                   forEach(System.out::println);

//一般生成的集合都是新的（如collect，除非有特别的），但是数据是移动过去的，所以集合不相等，数据相等

    }
}

java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选等操作

Stream接口借助于Lambda 表达式极大的提高编程效率和程序可读性

同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势

一般一个函数要返回，需要操作完流中的所有元素，如map（当然，有些函数的作用是不同的，可能并不是这样的意思，具体了解即可），这也是并行模式的出现，可以考虑异步处理来加快速度（因为只看操作完）

使用步骤------------------------------------

创建Stream，通过一个数据源来获取一个流

转换Stream，每次转换返回一个新的Stream对象。对Stream进行聚合操作并产生结果

创建方式------------------------------------

方式一：通过调用集合的默认方法来获取流，如：default Stream stream()

方式二：通过数组工具类中的静态方法来获取流，如：static IntStream stream(int[] array)

方式三：通过Stream接口的静态方法来获取流，如：static Stream of(T… values)

方式四：通过Stream接口的静态方法来获取流，static Stream generate(Supplier<? extends T> s)

中间操作------------------------------------

筛选与切片的常用方法如下：

Stream filter(Predicate<? super T> predicate)，返回一个包含匹配元素的流
Stream distinct()，返回不包含重复元素的流
Stream limit(long maxSize)，返回不超过给定元素数量的流
Stream skip(long n)，返回丢弃前n个元素后的流

映射的常用方法如下：

Stream map(Function<? super T,? extends R> mapper)，返回每个处理过元素组成的流
Stream flatMap(Function<? super T,? extends Stream<? extends R>> mapper)，返回每个被替换过元素组成的流
并将所有流合成一个流

排序的常用方法如下：

Stream sorted()，返回经过自然排序后元素组成的流
Stream sorted(Comparator<? super T> comparator)，返回经过比较器排序后元素组成的流
//自然排序和比较器排序实际上都是对方法的操作

终止操作------------------------------------

匹配与查找的常用方法如下：

Optional findFirst()，返回该流的第一个元素
boolean allMatch(Predicate<? super T> predicate)，返回所有元素是否匹配
boolean noneMatch(Predicate<? super T> predicate)，返回没有元素是否匹配
Optional max(Comparator<? super T> comparator)，根据比较器返回最大元素
Optional min(Comparator<? super T> comparator)，根据比较器返回最小元素
long count()，返回元素的个数
void forEach(Consumer<? super T> action)，对流中每个元素执行操作

规约的常用方法如下：

Optional reduce(BinaryOperator accumulator)，返回结合后的元素值

收集的常用方法如下：

<R,A> R collect(Collector<? super T,A,R> collector)，使用收集器对元素进行处理

注意：一般情况下，我们并不会使用，因为对于大多数人来说，他并不会学习这种情况，因为这虽然看起来是很简便的，但是无非就是方法的集成而已，只是他帮我们写好了

Optional类------------------------------------

public final class Optional<T>
extends Object

案例题目

判断字符串是否为空，若不为空则打印字符串的长度，否则打印

package com.lagou.task22;

import java.util.Optional;
import java.util.function.Function;

public class OptionalTest {

    public static void main(String[] args) {

        //String str1 = "hello";
        String str1 = null;
        if (null != str1) {
            System.out.println("字符串的长度是：" + str1.length()); // 5  空指针异常
        } else {
            System.out.println("字符串为空，因此长度为0！");
        }

        System.out.println("----------------------------------------------------");
        // Java8中使用Optional类实现空值的处理
        // 1.将数据str1装到Optional对象代表的容器中
        Optional<String> optional = Optional.ofNullable(str1);
        // 2.建立映射关系  使用字符串的长度与字符串建立映射关系
        /*Optional<Integer> integer = optional.map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        });*/
        //Optional<Integer> integer = optional.map(s -> s.length());
        Optional<Integer> integer = optional.map(String::length);
        // 3.若字符串为空则打印0，否则打印字符串的数值
        System.out.println("integer = " + integer); // Optional.empty
        System.out.println(integer.orElse(0)); // 0
    }
}

java.util.Optional类可以理解为一个简单的容器，其值可能是null或者不是null，代表一个值存在或不存在

该类的引入很好的解决空指针异常，不用显式进行空值检测，然而大多数我们会直接的写，这里就要注意一点，这里说明的类，基本的集成的，并不需要完全的知道，只需要他的使用即可

常用的方法-------------------------

static Optional ofNullable(T value)，根据参数指定数值来得到Optional类型的对象
Optional map(Function<? super T,? extends U>mapper)，根据参数指定规则的结果来得到Optional类型的对象
T orElse(T other)，若该值存在就返回，否则返回other的数值

Java9的新特性-------------------------

Java9发布于2017年9月发布，带来了很多新特性，其中最主要的变化是模块化系统

模块就是代码和数据的封装体，模块的代码被组织成多个包，每个包中包含Java类和接口

模块的数据则包括资源文件和其他静态信息

模块化的使用-------------------------

语法格式：在 module-info.java 文件中，我们可以用新的关键词module来声明一个模块，具体如下：module 模块名称 {}

模块化的优势：减少内存的开销， 可简化各种类库和大型应用的 开发和维护，安全性，可维护性，提高性能

其中模块里将某个包暴露出去时，必须要可以发现，如在同一个包里面，而且模块使用其他模块的类时，该类必须要public

使得可以访问到，否则报错，从而实现跨项目访问，因为一般情况下，idea对java类进行了整合，使得路径基本都会对应，那么在idea中由于整合，使得各个模块基本不能直接的访问，所以需要这个导出，而不是你可以全局（整个电脑）访问，即模块化是这个缺点的补充而已

package com.lagou;

/**
 *
 */
public class Person {
}

/**
 *
 */
module java91 {
    //实现将com.lagou这个包暴露出去
    exports com.lagou;
}

import com.lagou.Person;

/**
 *
 */
public class PersonTest {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

/**
 *
 */
module java92 {
//需要java9-01里的模块信息
    requires java91;
}

钻石操作符的使用升级：在Java9中允许在匿名内部类的使用中使用钻石操作符

package com.lagou.task22;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class DiamondTest {

    public static void main(String[] args) {

        // 实现匿名内部类和钻石操作符的搭配使用
        //Comparator<Integer> comparator = new Comparator<Integer>() {
        //后面是从引用的泛型推断出来，只不过省略了而已
        Comparator<Integer> comparator = new Comparator<>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        };
    }
}

当然，由于会推断，那么也会判断他们之间的泛型是否一致，否则报错

集合工厂方法-------------------------

Java9的List、Set和Map集合中增加了静态工厂方法of实现不可变实例的创建

不可变体现在无法添加、修改和删除它们的元素，不允许添加null元素对象

of方法里封装了最多10个元素的方法，再多的话，就是可变长参数了

实际意义

保证线程安全：在并发程序中既保证线程安全性，也大大增强了并发时的效率

被不可信的类库使用时会很安全，如果一个对象不需要支持修改操作，将会节省空间和时间的开销

可以当作一个常量来对待，并且这个对象在以后也不会被改变

package com.lagou.task22;

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

public class CollectionTest {

    public static void main(String[] args) {

        // 创建List类型的不可变实例
        List<Integer> list = List.of(1, 2, 3, 4, 5);
        //list.add(6); // 编译ok，运行发生UnsupportedOperationException不支持此操作的异常
        System.out.println(list); // [1, 2, 3, 4, 5]

        Set<Integer> set = Set.of(6, 7, 8);
        //set.add(null);// 编译ok，运行发生UnsupportedOperationException不支持此操作的异常

        Map<Integer, String> map = Map.of(1, "one", 2, "two");
        //map.put(3, "three");// 编译ok，运行发生UnsupportedOperationException不支持此操作的异常
    }
}

InputStream的增强-------------------------

InputStream类中提供了transferTo方法实现将数据直接传输到OutputStream中

package com.lagou.task22;

import java.io.*;

public class InputStreamTest {

    public static void main(String[] args) {

        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream("d:/a.txt");
            outputStream = new FileOutputStream("d:/b.txt");
            inputStream.transferTo(outputStream); // 实现数据的复制，底层是read和write方法的调用
            //
            /*
                         public long transferTo(OutputStream out) throws IOException {
                    Objects.requireNonNull(out, "out");
                    long transferred = 0;
                    byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
                    int read;
                    while ((read = this.read(buffer, 0, DEFAULT_BUFFER_SIZE)) >= 0) {
                        out.write(buffer, 0, read);
                        transferred += read;
                    }
                    return transferred;
                }
            }
            实际上就是封装了读和写
             */
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != outputStream) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != inputStream) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

记住，泛型只在编译时期来进行判断的，运行时是没有泛型，即擦除，所以他只是用来约束的

//如
List s= new LinkedList<String>();
s.add(1);
System.out.println(s.get(0));
//输出结果为1
//是因为判断时，引用没泛型，默认为Object，那么1就不报错，运行时擦除泛型，那么String就没用了，所以不报错，所以泛型一般只会写在左边，因为编译基本以左边为基准，而在类里面，就是约束类对应的方法，如实现接口，即泛型就是约束，使得编译期判断符合

当然对于上述来说如果用以下方式就会报错

var s = new LinkedList<String>();
s.add(1);
//报错
//因为用var话，会根据后面的对象来推断，就如
//List<String> d = new LinkedList<>();一样
//对象根据引用来推断
//还要注意：虽然<>中可以写上，但是若是没有泛型的构造（主要是存在泛型），一般来说会报错的，这个时候要么省略，要么写上泛型，因为他是操作泛型的

Java10的新特性-------------------------

Java10于2018年3月发布，改进的关键点包括一个本地类型推断、一个垃圾回收的增强

Java10计划只是一个短期版本，因此公开更新将在六个月内结束

9月份发布的Java11将是Java的长期支持（LTS）版本，LTS版本的发布每三年发布一次

局部变量类型推断-------------------------

Java10可以使用var作为局部变量类型推断标识符，此符号仅适用于局部变量，增强for循环的索引，以及传统for循环的本地变量

它不能使用于方法形式参数，构造函数形式参数，方法返回类型，字段，catch形式参数或任何其他类型的变量声明

实际意义

标识符var不是关键字，只是一个保留的类型名称

这意味着var用作变量，方法名或包名的代码不会受到影响，但var不能作为类或则接口的名字

避免了信息冗余。对齐了变量名。更容易阅读

package com.lagou.task22;

import java.util.LinkedList;
import java.util.List;

public class VarTest {

    public static void main(String[] args) {

        // 由初始值可以推断出变量的类型，因此可以使用var取代
        //int num = 10;
        var num = 10;

        //List<Integer> list = new LinkedList<>();
        var list = new LinkedList<Integer>();
        list.add(10);

        for (var v : list) {
            System.out.println(v);
        }

        for (var i = 0; i < 10; i++) {}
    }
}

Java11的新特性-------------------------

Java11于2018年9月正式发布，这是 Java 大版本周期变化 后的第一个长期支持版本，非常值得关注

简化的编译运行操作-------------------------

在Java11中可以使用java命令一次性进行编译和运行操作

执行源文件中的第一个类必须包含主方法，不可以使用其它源文件中自定义的类（一般需要导包），其中可以存在两个public类，但是只能使用java xx.java来执行，且他只执行第一个类的main，如果第一个类的main没有，那么报错，这是因为java xx.java只找第一个

String类新增方法-------------------------

boolean isBlank()，判断字符串是否为空或只包含空白代码点
Optional map(Function<? super T,? extends U>mapper)，根据参数指定规则的结果来得到Optional类型的对象
T orElse(T other)，若该值存在就返回，否则返回other的数值

其实模块化通常已经被一些工程化所处理了，比如再maven中，再以后，基本上我们也几乎见不到模块化的操作了，因为技术是越来越方便的，甚至可能一些基础代码都不需要我们写了，并且，我们也建议多使用（如Stream，或者说函数式编程）流和Lambda表达式，因为他更加方便和整洁，当然了，这并不需要记忆，可以百度搜索（虽然不利于小白阅读，具体还是看自身情况吧）

为了完全说明javac和java的情况，这里给出所有的细节：

当我们java xxx.java只看第一个类，无论你是否是public，并且也看main，否则报错，且main不能有其他类使用，如实例，否则也报错（报错都是直接的执行）

javac只看public的类或者都不看，多个public也会报错，且public需要main，否则也报错，当一个public时，文件名称需要与对应的类名一致，否则也报错（报错都是编译）