java 最新技术 java的新技术

Java新特性

• 一. 常用设计原则和设计模式

• 1. 常用的设计原则（记住）

• 1.1 软件开发的流程
• 1.2 常用的设计原则

• 2. 常用的设计模式

• 2.1 基本概念
• 2.2 基本分类

• 3. 设计模式详解（重点）

• 3.1 单例设计模式
• 3.2 普通工厂模式
• 3.3 多个工厂方法模式
• 3.4 静态工厂方法模式
• 3.5 抽象工厂模式
• 3.6 装饰器模式
• 3.7 代理模式
• 3.8 模板方法模式

• 二. 新特性

• 1. Java8的新特性

• 1.1 Java8的概述
• 1.2 函数式接口
• 1.3 Lambda表达式
• 1.4 方法引用
• 1.5 Stream接口

• 案例题目
• 基本概念
• 使用步骤
• 创建方式
• 中间操作
• 终止操作

• 1.6 Optional类

• 案例题目
• 基本概念
• 常用的方法

• 2. Java9的新特性

• 2.1 Java9的概述
• 2.2 模块化的使用
• 2.3 钻石操作符的使用升级
• 2.4 集合工厂方法
• 2.5 InputStream的增强

• 3. Java10的新特性

• 3.1 Java10的概述
• 3.2 局部变量类型推断

• 4. Java11的新特性

• 4.1 Java11的概述
• 4.2 简化的编译运行操作
• 4.3 String类新增方法

一. 常用设计原则和设计模式

1. 常用的设计原则（记住）

1.1 软件开发的流程

需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级

1.2 常用的设计原则

● 开闭原则（Open Close Principle）
对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。
● 里氏代换原则（Liskov Substitution Principle）
任何基类可以出现的地方，子类一定可以出现，多使用多态的方式。
● 依赖倒转原则（Dependence Inversion Principle）
尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性
● 接口隔离原则（Interface Segregation Principle）
尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度。
● 迪米特法则（最少知道原则）（Demeter Principle）
一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。
高内聚，低耦合。
● 合成复用原则（Composite Reuse Principle）
尽量多使用合成/聚合的方式，而不是继承的方式。

2. 常用的设计模式

2.1 基本概念

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
设计模式就是一种用于固定场合的固定套路。

2.2 基本分类

创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、…
结构型模式 - 装饰器模式、代理模式、…
行为型模式 - 模板设计模式、…

3. 设计模式详解（重点）

3.1 单例设计模式

单例设计模式主要分为：饿汉式 和 懒汉式，懒汉式需要对多线程进行同步处理。

懒汉式对多线程进行同步处理:

public class Singleton {

    // 2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
    private static Singleton sin = null;

    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {}

    // 3.提供公有的get方法负责将上述对象返回出去，使用public static关键字修饰
    public static /*synchronized*/ Singleton getInstance() {
        /*synchronized (Singleton.class) {
            if (null == sin) {
                sin = new Singleton();
            }
            return sin;
        }*/
        if (null == sin) {
            synchronized (Singleton.class) {
                if (null == sin) {
                    sin = new Singleton();
                }
            }
        }
        return sin;
    }
}

3.2 普通工厂模式

基本概念
普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建。

类图结构

接口Sender:

public interface Sender {
    // 自定义抽象方法来描述发送的行为
    void send();
}

实现类MailSender：

public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送邮件...");
    }
}

实现类SmsSender：

public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送短信...");
    }
}

工厂类SendFactory：

public class SendFactory {
    // 自定义成员方法实现对象的创建
    public Sender produce(String type) {
        //System.out.println("随便加一句打印进行测试");
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }
}

测试类：

public class SendFactoryTest {

    public static void main(String[] args) {

        // 缺点：代码复杂，可读性略差
        // 优点：扩展性和可维护性更强！  尤其是在创建大量对象的前提下
        // 1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        Sender sender = sf.produce("mail");
        //Sender sender = sf.produce("maill");
        // 3.使用对象调用方法模拟发生的行为
        sender.send();

        System.out.println("-------------------------------------");
        // 优点：代码简单，可读性强    在创建单个对象时有优势
        // 缺点：扩展性和可维护性略差
        Sender sender1 = new MailSender();
        sender1.send();
    }
}

主要缺点
在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常。

3.3 多个工厂方法模式

类图结构

工厂类：

public class SendFactory {
    // 自定义成员方法实现对象的创建
 
    public Sender produceMail() {
        return new MailSender();
    }
    public Sender produceSms() {
        return new SmsSender();
    }
}

测试类：

public class SendFactoryTest {

    public static void main(String[] args) {

        // 1.声明工厂类类型的引用指向工厂类类型的对象
        SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produce("maill");
        Sender sender = sf.produceMail();

        // 3.使用对象调用方法模拟发生的行为
        sender.send();
    }
}

主要缺点
在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法。

3.4 静态工厂方法模式

类图结构

工厂类：

public class SendFactory {
    // 自定义静态成员方法实现对象的创建，类名.调用
    public static Sender produceMail() {
        return new MailSender();
    }
    public static Sender produceSms() {
        return new SmsSender();
    }
}

测试类：

public class SendFactoryTest {

    public static void main(String[] args) {

        // 1.声明工厂类类型的引用指向工厂类类型的对象
        //SendFactory sf = new SendFactory();
        // 2.调用生产方法来实现对象的创建
        //Sender sender = sf.produce("mail");
        //Sender sender = sf.produce("maill");
        //Sender sender = sf.produceMail();
        Sender sender = SendFactory.produceMail();
        // 3.使用对象调用方法模拟发生的行为
        sender.send();
    }
}

实际意义
工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建。

主要缺点
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则。

3.5 抽象工厂模式

类图结构

接口：Provider

public interface Provider {
    // 自定义抽象方法描述产品的生产行为
    Sender produce();
}

实现类MailSendFactory：

public class MailSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

实现类SmsSendFactory：

public class SmsSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

抽象工厂模式便于拓展程序生产新的产品，比如再增加一个产品包裹，只需要增加PacketSender类实现Sender接口，用于发送包裹；增加PacketFactory类实现Provider接口，用于生产包裹对象。

实现类PacketSende：

public class PacketSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送包裹...");
    }
}

实现类PacketSendFactory：

public class PacketSendFactory implements Provider {
    @Override
    public Sender produce() {
        return new PacketSender();
    }
}

测试类：

public class SendFactoryTest {

    public static void main(String[] args) {

        Provider provider1 = new MailSendFactory();
        Sender sender1 = provider1.produce();
        sender1.send();
		
		Provider provider2 = new SmsSendFactory();
        Sender sender2 = provider2.produce();
        sender2.send();

        System.out.println("-------------------------------------");
        Provider provider3 = new PacketSendFactory();
        Sender sender3 = provider3.produce();
        sender3.send();
    }
}

3.6 装饰器模式

基本概念
装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

类图结构

接口Sourceable：

public interface Sourceable {
    // 自定义抽象方法
    void method();
}

实现类Sourceable：

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("素颜美可以如此之美！");
    }
}

修饰类Decorator实现接口Sourceable：

public class Decorator implements Sourceable {
    private Sourceable source;

    public Decorator(Sourceable source) {
        this.source = source;
    }

    @Override
    public void method() {
        source.method(); // 保证原有功能不变
        System.out.println("化妆之后你会更美！");
    }
}

测试类：

public class SourceableTest {

    public static void main(String[] args) {

        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("---------------------------------------------------");
        // 接下来使用装饰类实现功能
        Sourceable sourceable1 = new Decorator(sourceable); 
        sourceable1.method();
    }
}

运行结果：

实际意义
● 可以实现一个类功能的扩展。
● 可以动态的增加功能，而且还能动态撤销（继承不行）。
● 缺点：产生过多相似的对象，不易排错。

3.7 代理模式

基本概念
代理模式就是找一个代理类替原对象进行一些操作。
比如我们在租房子的时候找中介，再如我们打官司需要请律师，中介和律师在这里就是我们的代理。

类图结构

代理类Proxy实现接口Sourceable：

在代理类的构造方法中，直接new一个Source类的对象，测试类new一个Proxy类的对象时，就已经建好Source类的对象source，接下来一切对source的操作都交给这个Proxy类的对象，从而实现代理，即Source类的对象source对外不可见

public class Proxy implements Sourceable {
    private Source source;

    public Proxy() {
        source = new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("我和装饰器模式其实是不一样的！");
    }
}

测试类：

public class SourceableTest {

    public static void main(String[] args) {

        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("---------------------------------------------------");
        // 接下来使用装饰类实现功能
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();

        // 接下来使用代理类实现功能
        System.out.println("---------------------------------------------------");
        Sourceable sourceable2 = new Proxy();
        sourceable2.method();
    }
}

运行结果：

实际意义
● 如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式。
● 使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

代理模式和装饰器模式的比较
● 装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。
● 装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。

3.8 模板方法模式

基本概念
模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果。

类图结构

抽象类AbstractCalculator：

public abstract class AbstractCalculator {

    // 自定义成员方法实现将参数指定的表达式按照参数指定的规则进行切割并返回计算结果  1+1  +
    public int splitExpression(String exp, String op) {
        String[] sArr = exp.split(op);
        return calculate(Integer.parseInt(sArr[0]), Integer.parseInt(sArr[1]));
    }

    // 自定义抽象方法实现运算
    public abstract int calculate(int ia, int ib);
}

子类Plus：

public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia + ib;
    }
}

子类Minus：

public class Minus extends AbstractCalculator {
    @Override
    public int calculate(int ia, int ib) {
        return ia - ib;
    }
}

测试类：

public class AbstractCalculatorTest {

    public static void main(String[] args) {

        AbstractCalculator abstractCalculator = new Plus();
        int res = abstractCalculator.splitExpression("1+1", "\\+");
        System.out.println("最终的运算结果是：" + res); // 2
    }
}

实际意义
● 将多个子类共有且逻辑基本相同的内容提取出来实现代码复用。
● 不同的子类实现不同的效果形成多态，有助于后期维护。

二. 新特性

1. Java8的新特性

1.1 Java8的概述

Java8是 Java 语言的一个重要版本，该版本于2014年3月发布，是自Java5以来最具革命性的版本，这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。

1.2 函数式接口

● 函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator接口等。

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

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

Tips:

Runnable 无参无返回值

Comparator 有参有返回值，参数为两个，返回值类型为int，即-1，0，1

Consumer 有参无返回值

Supplier 无参有返回值

Function 有参有返回值

Predicate 有参有返回值，返回值类型为boolean

BiFunction 有参有返回值，参数为两个，返回值类型根据泛型指定

1.3 Lambda表达式

● Lambda 表达式是实例化函数式接口的重要方式，使用 Lambda 表达式可以使代码变的更加简洁紧凑。
● lambda表达式：参数列表、箭头符号->和方法体组成，而方法体中可以是表达式，也可以是语句块。
● 语法格式：(参数列表) -> { 方法体; } -------------其中()、参数类型、{} 以及return关键字 可以省略。

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) {

        // 匿名内部类的语法格式： 父类/接口类型  引用变量名 = 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()); // 无参有返回值

        //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"));
    }
}

1.4 方法引用

● 方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行。
● 方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：
○ 对象的非静态方法引用 ObjectName :: MethodName
○ 类的静态方法引用 ClassName :: StaticMethodName
○ 类的非静态方法引用 ClassName :: MethodName
○ 构造器的引用 ClassName :: new
○ 数组的引用 TypeName[] :: new
● 方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码。

Person类：

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();
    }
}

方法引用示例：

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(s);
        consumer1.accept("liubei");
        System.out.println("person = " + person); // liubei 30

        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)));
    }
}

Tips：
1.compareTo(Object o) 方法是java.lang.Comparable接口中的方法；
当需要对某个类的对象进行排序时，该类需要实现Comparable接口的，必须重写public int compareTo(T o)方法。
2.compare(Object o1,Object o2)方法是java.util.Comparator接口的方法；
它实际上用的是待比较对象的compareTo(Object o)方法。

1.5 Stream接口

案例题目

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

基本概念

● java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选等操作。
● Stream接口借助于Lambda 表达式极大的提高编程效率和程序可读性，同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势。

使用步骤

● 创建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)

中间操作

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

● 映射的常用方法如下：

● 排序的常用方法如下：

终止操作

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

● 规约的常用方法如下：

● 收集的常用方法如下：

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);
    }
}

1.6 Optional类

案例题目

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

基本概念

● java.util.Optional类可以理解为一个简单的容器，其值可能是null或者不是null，代表一个值存在或不存在。
● 该类的引入很好的解决空指针异常，不用显式进行空值检测。

常用的方法

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
    }
}

2. Java9的新特性

2.1 Java9的概述

● Java9发布于2017年9月发布，带来了很多新特性，其中最主要的变化是模块化系统。
● 模块就是代码和数据的封装体，模块的代码被组织成多个包，每个包中包含Java类和接口，模块的数据则包括资源文件和其他静态信息。

2.2 模块化的使用

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

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

2.3 钻石操作符的使用升级

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

import java.util.Comparator;

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;
            }
        };
    }
}

2.4 集合工厂方法

基本概念
● Java9的List、Set和Map集合中增加了静态工厂方法of实现不可变实例的创建。
● 不可变体现在无法添加、修改和删除它们的元素。
● 不允许添加null元素对象。

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不支持此操作的异常
    }
}

实际意义
● 保证线程安全：在并发程序中既保证线程安全性，也大大增强了并发时的效率。
● 被不可信的类库使用时会很安全。
● 如果一个对象不需要支持修改操作，将会节省空间和时间的开销。
● 可以当作一个常量来对待，并且这个对象在以后也不会被改变。

2.5 InputStream的增强

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

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方法的调用
        } 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();
                }
            }
        }
    }
}

3. Java10的新特性

3.1 Java10的概述

● Java10于2018年3月发布，改进的关键点包括一个本地类型推断、一个垃圾回收的增强。
● Java10计划只是一个短期版本，因此公开更新将在六个月内结束，9月份发布的Java11将是Java的长期支持（LTS）版本，LTS版本的发布每三年发布一次。

3.2 局部变量类型推断

基本概念
● Java10可以使用var作为局部变量类型推断标识符，此符号仅适用于局部变量，增强for循环的索引，以及传统for循环的本地变量。
● 它不能使用于方法形式参数，构造函数形式参数，方法返回类型，字段，catch形式参数或任何其他类型的变量声明。

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++) {}
    }
}

实际意义
● 标识符var不是关键字，只是一个保留的类型名称。这意味着var用作变量，方法名或包名的代码不会受到影响，但var不能作为类或则接口的名字。
● 避免了信息冗余。
● 对齐了变量名。
● 更容易阅读。

4. Java11的新特性

4.1 Java11的概述

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

4.2 简化的编译运行操作

● 在Java11中可以使用java命令一次性进行编译和运行操作。
● 执行源文件中的第一个类必须包含主方法。
● 不可以使用其它源文件中自定义的类。

4.3 String类新增方法