谨个人学习Java8新特性历程

Java 8 新特性概述

Lambda表达式

Lambda 是一个匿名函数，可以理解为一段可以传递的代码（将代码像数据一样进行传递。）

本质：作为函数式接口的实例

语法格式一：无参无返回值

Runnbale r1 = () -> {System.out.println("Hello World");};

语法格式二：有一个参数，但没有返回值

Person<Integer> per = (int x) -> {System.out.println(x);};

语法格式三：数据类型可以省略，可由编译器推断获取，“类型推断”

Person<Integer> per = (x) -> {System.out.println(x);};

语法格式四：若只需要一个参数时，包裹参数的小括弧可以省略

Person<Integer> per = x -> {System.out.println(x);};

语法格式五：两个参数或两个以上的参数，多条执行语句，可以有返回值

Person<Integer> per = (x, y) -> {
    System.out.println("Hello World");
    return x + y ;
};

语法格式六：当 Lambda 体只有一条语句时，若存在 return 和大括号，可以省略

Person<Integer> per = (x, y) -> x + y ;

函数式(function)接口

接口中有且仅有一个抽象方法。

可以使用注解@FunctionalInterface 检查是否是哟个函数式接口。

实例：根据给定的规则 ,过滤集合中的字符串, 规则由 Predicate 的 test() 方法决定

public static void main(String[] args) {
    List<String> stringList = Arrays.asList("东北", "西北", "华北", "晋西");
    List<String> list = list(stringList, s -> s.contains("北"));
    System.out.println(list);
}
public static List<String>list(List<String> list, Predicate<String> predicate) {
    List<String> stringList = new ArrayList<>();
    for (String s : list) {
        if (predicate.test(s)) {
            stringList.add(s);
        }
    }
    return stringList;
}

方法引用与构造器引用

方法引用 具体分为如下三种情况

一、引用静态方法：类名称 :: static方法名称;
二、引用某个实例对象的方法：实例化对象 :: 普通方法;
三、引用特定类型的方法：特定类 :: 普通方法;

方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同。

以下三种情况（方法引用使用的要求 针对于情况一和情况二）

情况一：对象 :: 实例方法

/*
* Consumer 中 void accept(T t)
* PrintStream 中 void println(T t)
* */
@Test
public void test02() {
    Consumer<String> consumer01 = str -> System.out.println(str);
    consumer01.accept("北京");

    PrintStream pw = System.out;
    Consumer<String> consumer02 =  pw::println;
    consumer02.accept("天津");
}

情况二：类 :: 静态方法

/*
* Comparator 中的 int compare(T t1, T t2)
* Integer 中的 int compare(T t1, T t2)
* */
@Test
public void test02() {
    Comparator<Integer> comparator01 = (t1, t2) ->Integer.compare(t1, t2);
    System.out.println(comparator01.compare(12, 13));

    Comparator<Integer> comparator02 = Integer::compareTo;
    System.out.println(comparator02.compare(14, 12));
}

情况三：类 :: 实例方法

/* 案例1
* Comparator 中的 int compare(T t1, T t2)
* String 中的 int t1.compareTo(t2)
* */
@Test
public void test02() {
    Comparator<String> comparator01 = (s1, s2) -> s1.compareTo(s2);
    System.out.println(comparator01.compare("opr", "abc"));

    Comparator<String> comparator02 = String::compareTo;
    System.out.println(comparator02.compare("acd", "wer"));
}

/* 案例2
* BiPredicate 中的 boolean test(T t1, T t2)
* String 中的 boolean t1.equals(t2)
 */
@Test
public void test02() {
    BiPredicate<String, String> biPredicate01 = (t1,t2) -> t1.equals(t2);
    System.out.println(biPredicate01.test("aaa", "AAA"));

    BiPredicate<String, String> biPredicate02 = String::equals;
    System.out.println(biPredicate02.test("AAA", "AAA"));
}

构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。

抽象方法的返回值类型即为构造器所属类的类型。

/*
BiFunction<T, U, R> 中的 R apply(T t, U u)
*/
@Test
public void test02() {
    BiFunction<String, Integer, Employee> biFunction01 = (name, id) -> new Employee(name, id);
    System.out.println(biFunction01.apply("张三", 15));

    BiFunction<String, Integer, Employee> biFunction = Employee :: new;
    Employee apply = biFunction.apply("102", 12);
    System.out.println(apply);
}

数组引用

可以把数组看作是一个特殊的类，写法与构造器引用一致。

/*
* Function 中的 R apply(T t)
* */
@Test
public void test02() {
    Function<Integer, String[]> function01 = length -> new String[length];
    String[] apply = function01.apply(3);
    System.out.println(Arrays.toString(apply));

    Function<Integer, String[]> function02 = String[] :: new;
    String[] apply1 = function02.apply(3);
    System.out.println(Arrays.toString(apply1));
}

Stream API

1、Stream 关注的是对数据的运算，与 CPU 打交道。

而集合关注的是数据的存储，与内存打交道

2、

①、Stream 自己不会存储元素。

②、Stream 不会改变源对象，它会返回一个持有结果的新 Stream 。

③、Stream 操作是延迟执行的，这意味着它会等到需要结果的时候才会执行。

Stream 的操作三个步骤

1-创建 Stream

一个数据源（集合、数组 ...），获取一个流

2-中间操作

一个中间操作链，对数据源的数据进行处理（过滤、映射...）

3-终止操作 (终端操作)

一旦执行终止操作，就执行中间操作链，并产生结果，之后不会再被使用。

Stream 的实例化

// 创建 Stream 方式一 ：通过集合
@Test
public void test01() {
    List<Employee> employees = EmployeeData.getEmployees();
    // default Stream<E> stream()  返回一个顺序流
    Stream<Employee> stream = employees.stream();   
    // default Stream<E> parallelStream() 返回一个并行流
    Stream<Employee> employeeStream = employees.parallelStream();
}
// 创建 Stream 方式二 ：通过数组
@Test
public void test02() {
    int[] arr = new int[]{1,2,3,4,5};
    // 调用Arrays 类的 IntStream stream(int[] array)
    IntStream stream = Arrays.stream(arr); // 返回一个流

    Employee emp1 = new Employee("张山", 20);
    Employee emp2 = new Employee("五山", 30);
    Employee[] arr1 = new Employee[]{emp1, emp2};
    Stream<Employee> employeeStream = Arrays.stream(arr1);
}
// 创建 Stream 方式三 ：通过 Stream 的 of()
@Test
public void test03() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
}
// 创建 Stream 方式四 ：创建无限流
@Test
public void test04() {
    // 迭代
    // 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);

    // 生成
    // static<T> Stream<T> generate(Supplier<T> s)
    Stream.generate(Math::random).limit(10).forEach(System.out :: println);
}

Stream 中间操作：筛选与切片

多个中间操作可以连接起来形成一条流水线, 除非流水线上触发终止操作，否则中间操作不会执行任何的处理，而在终止操作时一次性全部处理，称为 “惰性求值”

实例：

@Test
public void test01() {
    List<Employee>list = EmployeeData.getEmployees();
    Stream<Employee> stream = list.stream();
    
    // 1.filter(Predicate p) ————接收 Lambda ，从流中排除某些元素
    stream.filter(e -> e.getAge() >124).forEach(System.out::println);
    System.out.println();
    
    // 2.limit(n) ————截断流 ，使其元素不超过给定元素 。
    list.stream().limit(3).forEach(System.out::println);
    System.out.println();

    // 3.skip(n) ————跳过元素 ，返回一个扔掉了前 n 个元素的流 ，若流中不足 n 个 ，则返回一个空流
    list.stream().skip(3).forEach(System.out::println);
    System.out.println();

    // 4.distinct() ———— 筛选, 通过流所生成元素的 hashCode() 和 equals() ,去除重复元素
    list.add(new Employee("123", 15));
    list.add(new Employee("123", 15));
    list.add(new Employee("123", 15));
    list.add(new Employee("123", 15));
    list.stream().distinct().forEach(System.out::println);
}

Stream 中间操作：映射

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

    // 返回 员工姓名长度大于1的 员工
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<String> stringStream = employees.stream().map(Employee::getName);
    stringStream.filter(name -> name.length() > 1).forEach(System.out::println);

    System.out.println();
    // 如下方式 相当于 list.add(list1);[1,2,3,[4,5,6]] , 所以需要遍历两次
    Stream<Stream<Character>> streamStream = stringList.stream().map(LambdaTest::fromStringToStream);
    streamStream.forEach(s ->{
        s.forEach(System.out::println);
    });

    System.out.println();
    // 如下方式相当于 list.addAll(list1);[1,2,3,4,5,6]
    // flatMap(Function f) 接收一个函数作为参数 ，将流的每个值换成另一个流，然后把所有流重新连接起来成一个流 。
    stringList.stream().flatMap(LambdaTest::fromStringToStream).forEach(System.out::println);
}
public static Stream<Character> fromStringToStream(String str) {
    List<Character> list = new ArrayList<>();
    for (Character c : str.toCharArray()) {
        list.add(c);
    }
    return list.stream();
}

Stream 中间操作：排序

注意：对象排序(自然排序)的时候，类需要实现 Comparable 接口 ,否则会抛异常。

// java.lang.ClassCastException:  cannot be cast to java.lang.Comparable
// 错误示例 ，Employee类 需要实现 Comparable 接口 
List<Employee> employeeList = EmployeeData.getEmployees();
employeeList.stream().sorted().forEach(System.out::println);

// sorted() ————自然排序
List<Integer> list = Arrays.asList(12,45,69,02,03,65);
list.stream().sorted().forEach(System.out::println);

定制排序：

// sorted(Comparator com) ————定制排序
List<Employee> employees = EmployeeData.getEmployees();
employees.stream().sorted((e1, e2) -> {
    int compare = Integer.compare(e1.getAge(), e2.getAge());
    if (compare != 0) {
        return compare;
    } else {
		// 如果 年龄相等 ，就按照如下排序方式进行排序 。
        return Double.compare(e1.getAge(), e2.getAge());
    }
}).forEach(System.out::println);

Stream 终止操作：匹配与查找

**allMatch(Predicate p)——检查是否匹配所有元素 **

是否所有的员工的年龄都大于 120

@Test
    public void test02() {
        List<Employee> employees = EmployeeData.getEmployees();
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 120);
        System.out.println(allMatch);	// true 
    }

anyMatch(Predicate p)——检查是否至少匹配一个元素。

是否存在员工的年龄大于 121

boolean b = employees.stream().anyMatch(e -> e.getAge() > 121);
System.out.println(b);	// true

noneMatch(Predicate p)——检查是否没有匹配的元素

是否存在姓氏为 "雷" 的员工，没有匹配则返回 true ，

boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
System.out.println(noneMatch); // true

findFirst()——返回第一个元素

可以先预处理然后再返回第一个元素，例如, 先排序，升序或降序，检查石佛满足条件等等，

Optional<Employee> first = employees.stream().findFirst();
System.out.println(first);	// Optional[Employee{name='张三', age=121}]

findAny——返回当前流中的任意元素

parallelStream() ——返回一个并行流

Optional<Employee> first1 = employees.parallelStream().findAny();
System.out.println(first1); // Optional[Employee{name='张三4', age=124}]

count——返回流中的总个数

员工年龄大于 “121” 的员工总数。

long count = employees.stream().filter(e -> e.getAge() > 121).count();
System.out.println(count);	// 4

max(Comparator con)——返回流中的最大值

返回员工中最大的年龄

Stream<Integer> integerStream = employees.stream().map(e -> e.getAge());
Optional<Integer> max = integerStream.max(Double::compare);
System.out.println(max);	// 126

min(Comparator con)——返回流中的最小值

返回最小年龄的员工

Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getAge(), e2.getAge()));
System.out.println(min);  // Optional[Employee{name='张三2', age=121}]

forEach()——内部迭代

将流中的数据遍历打印

employees.stream().forEach(System.out ::println);
employees.forEach(System.out ::println); // 使用集合的遍历操作 。

等价于：如下代码

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

Stream 终止操作：规约

T reduce(T identity, BinaryOperator accumulator)——可以将流中元素反复结合起来，得到一个值,返回泛型T

计算1-10 的自然数的和。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer reduceSum = list.stream().reduce(0, Integer::sum);
System.out.println(reduceSum); // 55

Optional reduce(BinaryOperator accumulator) 可以将流中的元素反复结合起来，得到一个值 ,返回Optional

计算所有员工的年龄总和。

List<Employee> employees = EmployeeData.getEmployees();
Stream<Integer> integerStream = employees.stream().map(Employee::getAge);
Optional<Integer> reduceAge = integerStream.reduce(Integer::sum);
System.out.println(reduceAge); // Optional[739]
// 第二种 ，如果不知道Integer中有sum()方法 ，可以用 Lambda 表达式 
// Optional<Integer> reduceAge1 = integerStream.reduce((d1, d2) -> d1 + d2);
// System.out.println(reduceAge1);// Optional[739]

Stream 终止操作：收集

<R, A> R collect(Collector<? super T, A, R> collector)

将流转换为其他形式，接收一个 Collectors 接口的实现，用于给 Stream 中元素做汇总。

查找年龄大于121的员工，结果返回一个 List 或 Set

其他 Stream流收集操作。

Optional 类

Optional类：为了在程序中避免空指针异常 .

Optional 类 (java.uitl.Optional) 是一个容器类。它可以保存类型 T 的值，代表这个值存在。或者仅仅保存 null ，表示这个值不存在，原来用 null 表示一个值不存在，现在用 Optional 可以更好的表达这个概念。并且可以避免空指针异常 。

常用方法：

ofNullable(T t) —— orElse(T t) 这两个方法通常在一起用

of(T t) —— get() 这两个方法通常在一起用，确定不会出现空指针异常 .

示例 1 ：

public T orElse(T other) , 如果有值返回内部封装的t , 否则返回指定的other对象

@Test
public void test05() {
    Girl girl = new Girl();
    girl = null;
    Optional<Girl> optionalGirl = Optional.ofNullable(girl);
    System.out.println(optionalGirl); // Optional.empty
    Girl girl1 = optionalGirl.orElse(new Girl("刘德华"));
    System.out.println(girl1); // Girl{name='刘德华'}
}

示例二：使用 Optional类

public String getGirlName(Boy boy) {
    Optional<Boy> optionalBoy = Optional.ofNullable(boy);
    // 当boy为空的时候,返回orElse指定的other对象.
    Boy boy1 = optionalBoy.orElse(new Boy(new Girl("迪丽热巴")));

    Girl girl = boy1.getGirl();

    // 当 girl 为空的时候,返回orElse指定的other对象.
    Optional<Girl> girl1 = Optional.ofNullable(girl);
    Girl girl2 = girl1.orElse(new Girl("刘德华"));
    return girl2.getName();
}
@Test // 测试 
public void test05() {
    Boy boy = null;	// 迪丽热巴
    // boy = new Boy();	// 刘德华
    // boy = new Boy(new Girl("古力娜扎"));	// 古力娜扎
    String girlName = getGirlName(boy);
    System.out.println(girlName);
}

posted @ 2020-12-07 16:15 san只松鼠阅读(97) 评论(0) 收藏举报

刷新页面返回顶部

san只松鼠