JAVA8新特性

Posted 2023-05-24 第七天堂

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA8新特性相关的知识，希望对你有一定的参考价值。

Lambda表达式

1.基本格式

（参数列表）->代码

2.省略规则

参数类型可以省略
方法体只有一句代码时大括号return和唯一一句代码的分号可以省略
方法只有一个参数时小括号可以省略

Stream流

1.创建流

单列集合：集合对象.stream()
数组：Arrays.stream(数组对象) 或 Stream.of(数组对象)

双列集合：转换成单列集合后再创建

例：

Map<String,Integer> map = new HashMap<>();
Stream<Map.Entry<String,Integer>> stream = map.entrySet().stream();

2.中间操作

filter

可以对流中数据进行过滤，符合条件的才能留在流中
map

可以把对流中的元素进行计算或转换
distinct

可以去除流中的重复元素
sorted

可以对流中的元素进行排序

注意：如果调用空参的sorted()方法，需要流中的元素实现了Comparable
limit

可以设置流的最大长度，超出的部分将被抛弃
skip

跳过流中的前n个元素，返回剩下的元素
flatMap

map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素

3.终结操作

forEach

对流中的元素进行遍历操作，可以通过传入的参数去指定对遍历到的元素进行什么具体操作
count

可以用来获取当前流中元素的个数
max & min

可以用来计算流中的最值
collect

把当前流转换成一个
anyMatch

可以用来判断是否有任意符合匹配条件的元素，结果为Boolean
allMatch

可以用来判断是否都符合匹配条件，结果为Boolean
noneMatch

可以判断是否都不符合匹配条件，结果为Boolean
findAny

获取流中的任意一个元素，该方法没有办法保证获取的一定是流中的第一个元素
findFirst

获取流中的第一个元素
reduce归并

对流中的数据按照自定义的计算方式计算出一个结果。（缩减操作）

reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和在初始化值的基础上进行计算，计算结果再和后面的元素计算

内部的计算方式如下
```
T result = identity;
for (T element : this stream)
    result = accumulator.apply(result,element)
return result;
```

4.注意事项

惰性求值（如果没有终结操作，没有中间操作是不会得到执行的）
流是一次性的（一旦一个流对象经过一个终结操作后，这个流就不能再被使用）
不会影响原数据（我们在流中可以多数据做很多处理，但正常情况下是不会影响原来集合中的元素的。这往往也是我们期望的）

Optional

1.创建对象

一般使用Optional的静态方法ofNullable来把数据封装成一个Optional对象，无论传入的参数是否为null都不会出现问题

Example example = getExample();
Optional<Example> exampleOptional = Optional.ofNullable(example);

在确定一个对象不为空的则可以使用Optional的静态方法of来把数据封装成Optional对象

Example example = getExample();
Optional<Example> exampleOptional = Optional.of(example);

如果一个方法的返回值类型是Optional类型，而如果我们经判断发现某次得到的返回值为null,这个时候就需要把null封装成Optional对象返回。这时则可以使用Optional的静态方法empty来进行封装。

Optional.empty();

2.消费值

使用 ifPresent 方法来消费其中的值，这个方法会判断其内封装的数据是否为空，不为空时才会执行具体的消费代码

optiona1<Example> exampleOptiona1 = optional.ofNul1ab1e(getAxample());
exampleOptiona1.ifPresent(example -> system.out.println(example.getName()));

3.获取值

get()

不推荐使用此种方法获取，因为当Optional内部数据为空时会出现异常
orElseGet()

获取数据并且设置数据为空时的黑认值。如果数据不为空就能获取到该数据。如果为空则根据你传入的参数来创建对象作为默认值返回
```
Optional<Example> exampleOptional = Optional.ofNullable(getExample());
Example example = exampleOptional.orElseGet(() -> new Example());
```

orElseThrow()

获取数据，如果数据不为空就能获取到该数据，如果为空则根据传入的参数来创建异常抛出

Optional<Example> exampleOptional = Optional.ofNullable(getExample());
try
    Example example = exampleOptional.orElseThrow(() -> new RuntimeException("example为空"));
    System.out.println(example.getName());
 catch(Throwable throwable) 
    throwable.printStachTrace();

4.过滤

使用filter方法对数据进行过滤，如果原本是有数据的，但是不符合判断，也会变成一个无数据的Optional对象

Optional<Example> exampleOptional = Optional.ofNullable(getExample());
exampleOptional.filter(example -> example.getAge() > 100).ifPresent(example -> System.out.println(example.getName()));

5.判断

可以使用isPresent方法进行是否存在数据的判断。如果为空，返回值为false；如果不为空，返回值为true。但是这种方式并不能体现Optional的好处，更推荐使用ifPresent方法。

optiona1<Example> exampleOptional = optional.ofNullab1e(getExample());
if (exampleOptional.isPresent() 
	system.out.println(exampleOptional.get().getName());

6.数据转换

Optional还提供了map可以让我们的对数据进行转换，并且转换得到的数据也还是被Optional包装好的，保证了我们的使用安全。

optiona1<Example> exampleOptional = optional.ofNullab1e(getExample());
Optional<List<Book>> books = exampleOptional.map(author -> author.getBooks());
books.ifPresent(book -> System.out.printLn(book.getName()));

函数式接口

1.概述

只有一个抽象方法的接口我们称之为函数接口

JDK的函数式接口都加上了 @FunctionalINterface 注解进行标识。但是无论是否加上该注解只要接口中只有一个抽象方法，都是函数式接口

2.常见函数式接口

Consumer 消费接口

可以在方法中对传入的参数进行消费
Function 计算转换接口

可以在方法中对传入的参数计算或转换，把结果返回
Predicate 判断接口

可以在方法中对传入的参数条件判断，返回判断结果
Supplier 生产型接口

可以在方法中创建对象，把创建好的对象返回

3.常用的默认方法

and

在使用 Predicate 接口的时候可能需要进行判断条件的拼接。而 and方法相当于是使用 && 来拼接两个判断条件
or

在使用 Predicate 接口时相当于 ||
negete

Predicate 接口中的方法，相当于是在判断前加了！表示取反

方法引用

在使用Lambda时，如果方法体中只有一个方法的调用的话（包括构造方法），可以用方法引用进一步简化代码

基本格式：

类名或对象名::方法名

高级用法

JDK5中引入的自动装箱和自动拆箱虽然方便，但也是要消耗时间的，为了能对这部分的时间消耗进行优化，Stream提供了很多专门针对基本数据类型的方法

例如：

mapToInt、mapToLong、mapToDouble、flatMapToInt、flatMapToDouble 等

并行流

当流中有大量元素时，可以使用并行流去提高操作的效率。其实并行流就是把任务分配给多个线程去完成。使用Stream时，只需要修改一个方法的调用就可以使用并行流，从而提高效率。

stream.parallel()

也可以通过 parallelStream 直接获取并行流对象

parallelStream()

Java8新特性

1. Java8新特性_简介

HashMap在jdk1.7和jdk1.8中区别

jdk1.7：数组+链表

jdk1.8：数组+链表+红黑树
当哈希碰撞即链表上个数大于8并且总容量个数大于64，链表转成红黑树

红黑树除了添加以外，其他（查询、删除）效率都比链表高
扩容后重排序，不用重新运算hashCode值，直接找对应元素在原来哈希表的总长度加上它当前所在哈希表的位置

HashSet，同理

ConcurrentHashMap

jdk1.7
并发级别：16
锁+段机制：默认16段，每段默认16表
段太多浪费空间，段太少导致每段元素过多效率遍地

jdk1.8
CAS
无锁算法
CAS是底层操作系统支持的算法，效率高

Java 8新特性简介

速度更快
代码更少（增加了新的语法Lambda表达式）
强大的Stream API
便于并行
最大化减少空指针异常 Optional

2. 为什么使用 Lambda 表达式

1-Lambda表达式

为什么使用 Lambda 表达式
Lambda是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

package day01.com.lm.java8;

import java.util.Objects;

public class Employee {
    private int id;
    private String name;
    private Integer age;
    private double salary;
    private Status status;

    public Employee(String name, Integer age, double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }

    public Employee() {
        super();
    }

    public Employee(int id) {
        this.id = id;
    }

    public Employee(String name, Integer age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", status=" + status +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id &&
                age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, salary);
    }

    public enum Status {
        FREE,
        BUSY,
        VOCATION
    }
}

package day01.com.lm.java8;

public interface MyPredicate<T> {

    public boolean test(T t);
}

package day01.com.lm.java8;

public class FilterEmployeeByAge implements MyPredicate<Employee> {

    @Override
    public boolean test(Employee t) {
        return t.getAge() >= 35;
    }
}

package day01.com.lm.java8;

public class FilterEmployeeBySalary implements MyPredicate<Employee> {
    @Override
    public boolean test(Employee t) {
        return t.getSalary() >= 5000;
    }
}

package day01.com.lm.java8;

import org.junit.Test;

import java.util.*;

public class TestLambda1 {

    //原来的匿名内部类
    public void test1() {
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };

        TreeSet<Integer> ts = new TreeSet<>(com);
    }

    //Lambda 表达式
    public void test2() {
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        TreeSet<Integer> ts = new TreeSet<>(com);
    }

    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 38, 5555.99),
            new Employee("王五", 50, 6666.66),
            new Employee("赵六", 16, 3333.33),
            new Employee("田七", 8, 7777.77)
    );

    //需求：获取当前公司中员工年龄大于35的员工信息
    @Test
    public void test3() {
        List<Employee> list = filterEmployees(this.employees);

        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

    public List<Employee> filterEmployees(List<Employee> list) {
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list) {
            if (emp.getAge() >= 35) {
                emps.add(emp);
            }
        }
        return emps;
    }

    //需求：获取当前公司中员工工资大于5000的员工信息
    public List<Employee> filterEmployees2(List<Employee> list) {
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list) {
            if (emp.getSalary() >= 5000) {
                emps.add(emp);
            }
        }
        return emps;
    }

    //优化方式一：策略设计模式
    @Test
    public void test4() {
        List<Employee> list = filterEmployee(employees, new FilterEmployeeByAge());

        for (Employee employee : list) {
            System.out.println(employee);
        }

        System.out.println("-----------------------------------");

        List<Employee> list2 = filterEmployee(employees, new FilterEmployeeBySalary());

        for (Employee employee : list2) {
            System.out.println(employee);
        }
    }

    public List<Employee> filterEmployee(List<Employee> list, MyPredicate<Employee> mp) {
        List<Employee> emps = new ArrayList<>();
        for (Employee employee : list) {
            if (mp.test(employee)) {
                emps.add(employee);
            }
        }
        return emps;
    }

    //优化方式二：匿名内部类
    @Test
    public void test5() {
        List<Employee> list = filterEmployee(employees, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee t) {
                return t.getSalary() <= 5000;
            }
        });

        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

    //优化方式三：Lambda表达式
    @Test
    public void test6() {
        List<Employee> list = filterEmployee(employees, (e) -> e.getSalary() <= 5000);
        list.forEach(System.out::println);
    }

    //优化方式四：Stream API
    @Test
    public void test7() {
        employees.stream()
                .filter((e) -> e.getSalary() >= 5000)
                .limit(2)
                .forEach(System.out::println);

        System.out.println("----------------------------------------");

        employees.stream()
                .map(Employee::getName)
                .forEach(System.out::println);
    }
}

3. Java8新特性_Lambda 基础语法

从匿名类到 Lambda 的转换
在这里插入图片描述
从原来使用匿名内部类作为参数传递到Lambda表达式作为参数传递

Lambda 表达式语法
Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ，该操作符被称
为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的所有参数
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。
在这里插入图片描述

类型推断
上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”

2-函数式接口

什么是函数式接口

只包含一个抽象方法的接口，称为函数式接口。
你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

自定义函数式接口
在这里插入图片描述

package day01.com.lm.java8;

import org.junit.Test;

import java.util.*;
import java.util.function.Consumer;

/**
 * 一、Lambda表达式的基础语法：Java8中引入了一个新的操作符“->” 该操作符称为箭头操作符或Lambda操作符
 *                             箭头操作符将Lambda表达式拆分成两部分：
 * 左侧：Lambda表达式的参数列表
 * 右侧：Lambda表达式中所需要执行的功能，即Lambda体
 *
 * 语法格式一：无参数，无返回值
 *      () -> System.out.println("Hello Lambda!");
 *
 * 语法格式二：有一个参数，并且无返回值
 *      (x) -> System.out.println(x);
 *
 * 语法格式三：只有一个参数，小括号可以省略不写
 *      x -> System.out.println(x);
 *
 * 语法格式四：有两个以上的参数，有返回值，并且Lambda体有多条语句
 *        Comparator<Integer> com = (x, y) -> {
 *             System.out.println("函数式接口");
 *             return Integer.compare(x, y);
 *         };
 *
 * 语法格式五：若Lambda体中只有一条语句，return和大括号都可以省略不写
 *      Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
 *
 * 语法格式六：Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出数据类型，即“类型推断”
 *      Comparator<Integer> com = (Integer x, Integer y) -> Integer.compare(x, y);
 *
 * 上联：左右遇一括号省
 * 下联：左侧推断类型省
 * 横批：能省则省
 *
 * 二、Lambda表达式需要“函数式接口”的支持
 * 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。
 *             可以使用注解@FunctionalInterface修饰可以检查是否是函数式接口
 */
public class TestLambda2 {

    @Test
    public void test1() {//无参数，无返回值
        int num = 0;//jdk1.7前，必须加final

        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!" + num);
            }
        };

        r.run();

        System.out.println("--------------------------------------------");

        Runnable r1 = () -> System.out.println("Hello World!" + num);
        r1.run();
    }

    @Test
    public void test2() {//有一个参数，并且无返回值
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("民哥威武！");
        //只有一个参数，小括号可以省略不写
        Consumer<String> con2 = x -> System.out.println(x);
        con2.accept("民哥威武！");
    }

    @Test
    public void test3() {//有两个以上的参数，有返回值，并且Lambda体有多条语句
        Comparator<Integer> com = (x, y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);
        };
    }

    @Test
    public void test4() {//若Lambda体中只有一条语句，return和大括号都可以省略不写
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        Comparator<Integer> com2 = (Integer x, Integer y) -> Integer.compare(x, y);
    }

    @Test
    public void test5() {
        String[] strs = {"aaa", "bbb", "ccc"};
//        String[] strs;
//        strs = {"aaa", "bbb", "ccc"};

        List<String> list = new ArrayList<>();

        show(new HashMap<>());
    }

    public void show(Map<String, Integer> map) {

    }

    //需求：对一个数进行运算
    @Test
    public void test6() {
        Integer num = operation(100, (x) -> x * x);
        System.out.println(num);

        System.out.println以上是关于JAVA8新特性的主要内容，如果未能解决你的问题，请参考以下文章 
 Java8新特性一张图带你领略Java8有哪些新特性
 Java8新特性
 Java8新特性
 Java8新特性文章
 java8新特性总结
 java8新特性-入门摘要