扩展篇】五.java8新特性（代码版）

1. 项目准备

1.1 定义User

package com.wpj.model;

import java.io.Serializable;
import java.util.Date;
import java.util.Objects;

public class User implements Serializable {

    private Integer id;
    private String name;
    private Date birthday;

    public User() {
    }

    public User(Integer id) {
        this.id = id;
    }

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public User(Integer id, String name, Date birthday) {
        this.id = id;
        this.name = name;
        this.birthday = birthday;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) &&
                Objects.equals(name, user.name) &&
                Objects.equals(birthday, user.birthday);
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

2. Lambda

package com.wpj.lamdba;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @author JieKaMi
 * @date 2020/6/1 11:00
 * @Description
 *      Lambda表达式，以前匿名实现类都可以用lambda表达式来写。
 */
public class LambdaDemo {

    @Test
    public void RunnableTest() {
        // {} 里只有一条执行语句 可以省略
        Runnable runnable = () -> {
            System.out.println("Runnable.run Lambda表达式");
        };
        runnable.run();
    }

    @Test
    public void ComparatorTest() {
        // lambda
        Comparator<Integer> comparator = (o1, o2) -> o1.compareTo(o2);
        int compare = comparator.compare(1, 2);
        System.out.println(compare);
        // 方法引用
        Comparator<Integer> comparator2 = Integer::compareTo;
        int compare2 = comparator2.compare(11, 2);
        System.out.println(compare2);

    }

    @Test
    public void ConsumerTest(){
        // () 只有一个参数可以省略
        Consumer<String> consumer = (s) -> System.out.println(s);
        consumer.accept("Consumer.accept Lambda表达式");
    }

}

3. Functional

package com.wpj.functional;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author JieKaMi
 * @date 2020/6/1 11:30
 * @Description
 *      函数式接口
 *          4大核心接口
 *              消费型接口 Consumer<T>       void accept(T t)
 *              供给型接口 Supplier<T>       T get()
 *              函数型接口 Function<T, R>    R apply(T t)
 *              断定型接口 Predicate<T>      boolean test(T t)
 */
public class FunctionalDemo {


    @Test
    public void testFunctional() {

        testConsumer("JieKaMi", name -> System.out.println("我叫" + name));

        System.out.println(testSupplier(() -> "Functional Supplier"));

        System.out.println(testFunction(i -> i + " + 1 = 2"));

        System.out.println(testPredicate(Arrays.asList("北瓜", "南瓜", "东瓜", "西瓜", "瓜皮"), s -> s.contains("瓜")));

    }

    public void testConsumer(String name, Consumer<String> consumer) {
        consumer.accept(name);
    }

    public String testSupplier(Supplier<String> supplier) {
        return supplier.get();
    }

    public String testFunction(Function<Integer, String> function) {
        return function.apply(1);
    }

    public List<String> testPredicate(List<String> stringList, Predicate<String> predicate) {

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

        for (String str : stringList) {
            if (predicate.test(str)) {
                list.add(str);
            }
        }
        return list;
    }

}

4. 引用

4.1 方法引用

package com.wpj.references;

import com.wpj.model.User;
import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.Date;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author JieKaMi
 * @date 2020/6/1 14:34
 * @Description
 *      方法引用    接口中抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值相同
 *          对象 :: 非静态方法
 *          类 :: 静态方法
 *          类 :: 非静态方法  (有点特殊)
 */
public class MethodReferencesDemo {
    /**
     * Consumer 中的 void accept(T t)
     * PrintStream 中的 void println(T t)
     */
    @Test
    public void methodReferencesConsumer(){
        // 对象 :: 非静态方法
        // lambda
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("lambda Consumer");
        // 方法引用
        PrintStream out = System.out;
        Consumer<String> consumer2 = out::println;
        consumer2.accept("methodReferences Consumer");
    }

    /**
     * Supplier 中的 T get()
     * User 中的 String getName();
     */
    @Test
    public void methodReferencesSupplier(){
        // 对象 :: 非静态方法
        User user = new User(1, "JieKaMi", new Date());
        // lambda
        Supplier<String> supplier = () -> user.getName();
        System.out.println(supplier.get());
        // 方法引用
        Supplier<String> supplier2 = user :: getName;
        System.out.println(supplier2.get());
    }

    /**
     * Comparator 中的 int compare(T t1, T t2)
     * Integer 中的 int compareTo(T t1, T t2)
     */
    @Test
    public void methodReferencesComparator(){
        // 类 :: 静态方法
        // lambda
        Comparator<Integer> comparator = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(comparator.compare(1, 2));
        // 方法引用
        Comparator<Integer> comparator2 = Integer::compareTo;
        System.out.println(comparator2.compare(2, 1));
    }

    /**
     * Function 中的 R apply(T t)
     * Math 中的 Long round(Double double)
     */
    @Test
    public void methodReferencesFunction() {
        // 类 :: 静态方法
        // lambda
        Function<Double, Long> function = d -> Math.round(d);
        System.out.println(function.apply(3.14));
        // 方法引用
        Function<Double, Long> function2 = Math::round;
        System.out.println(function2.apply(3.14));
    }

    /**
     * 类 :: 非静态方法
     * Comparator 中的 int compare(T t1, T t2)
     * String 中的 int t1.compareTo(t2)
     */
    @Test
    public void methodReferencesComparator2(){
        // lambda
        Comparator<String> comparator = (s1, s2) -> s1.compareTo(s2);
        System.out.println(comparator.compare("wupeijie","jiekami"));
        // 方法引用
        Comparator<String> comparator2 = String::compareTo;
        System.out.println(comparator2.compare("jiekami2", "wupeijie"));
    }

    /**
     * 类 :: 非静态方法
     * BiPredicate 中的 boolean test(T t1, T t2)
     * String 中的 boolean t1.equals(t2)
     */
    @Test
    public void methodReferencesBiPredicate(){
        // 类 :: 非静态方法
        // lambda
        BiPredicate<String, String> biPredicate = (s1, s2) -> s1.equals(s2);
        System.out.println(biPredicate.test("wupeijie", "wupeijie"));
        // 方法引用
        BiPredicate<String, String> biPredicate2 = String::equals;
        System.out.println(biPredicate2.test("wupeijie", "wupeijie"));
    }

    /**
     * 类 :: 非静态方法
     * R    apply(T t)
     * String getName()
     */
    @Test
    public void methodReferencesFunction2(){
        // lambda
        Function<User, String> function = u -> u.getName();
        System.out.println(function.apply(new User(1, "jiekami", new Date())));
        // 方法引用
        Function<User, String> function2 = User::getName;
        System.out.println(function2.apply(new User(1, "jiekami", new Date())));

    }
}

4.2 构造引用

package com.wpj.references;

import com.wpj.model.User;
import org.junit.Test;

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author JieKaMi
 * @date 2020/6/1 15:24
 * @Description
 *      构造器引用
 */
public class ConstructorReferencesDemo {

    @Test
    public void constructorReferencesSupplier(){
        Supplier<User> supplier = () -> new User();
        Supplier<User> supplier2 = User :: new;
    }

    @Test
    public void constructorReferencesFunction(){
        Function<Integer, User> function = id -> new User(id);
        Function<Integer, User> function2 = User:: new;
    }
    @Test
    public void constructorReferencesBiFunction(){
        BiFunction<Integer, String, User> biFunction = (id, name) -> new User(id, name);
        BiFunction<Integer, String, User> biFunction2 = User::new;
    }
}

4.3 数组引用

package com.wpj.references;

import org.junit.Test;

import java.util.Arrays;
import java.util.function.Function;

/**
 * @author JieKaMi
 * @date 2020/6/1 15:30
 * @Description
 *      数组引用
 */
public class ArrayReferencesDemo {

    @Test
    public void arrayReferencesFunction(){

        Function<Integer, String[]> function = length -> new String[length];
        String[] apply = function.apply(54);
        System.out.println(Arrays.toString(apply));


        Function<Integer, String[]> function2 = String[]::new;
        String[] apply2 = function2.apply(54);
        System.out.println(Arrays.toString(apply2));

    }


}

5. stream

5.1 stream

package com.wpj.stream;

import com.wpj.model.User;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author JieKaMi
 * @date 2020/6/1 17:38
 * @Description StreamAPI
 */
public class StreamDemo {

    @Test
    public void testStreamList() {
        List<User> users = new ArrayList<>();
        users.add(new User(1, "jiekami", new Date()));
        users.add(new User(2, "jiekami2", new Date()));
        users.add(new User(2, "jiekami3", new Date()));

        // 顺序流
        Stream<User> stream = users.stream();
        // 并行流
        Stream<User> parallelStream = users.parallelStream();

    }

    @Test
    public void testStreamArray() {

        int[] arr = {1, 2, 3, 4, 5, 6};

        IntStream stream = Arrays.stream(arr);


        User user = new User(1, "jiekami", new Date());
        User user2 = new User(2, "jiekami2", new Date());
        User user3 = new User(2, "jiekami3", new Date());
        User[] users = {user, user2, user3};

        Stream<User> userStream = Arrays.stream(users);
    }

    @Test
    public void testStreamOf() {
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
    }

    @Test
    public void testStream() {
        // 迭代 遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
        // 生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

5.2 筛选和切片

package com.wpj.stream.screen;

import com.wpj.model.User;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author JieKaMi
 * @date 2020/6/2 9:10
 * @Description
 *      stream中间操作-筛选与切片
 */
public class StreamScreenDemo {

    @Test
    public void test() {

        List<User> users = new ArrayList<>();
        users.add(new User(1, "jiekami", new Date()));
        users.add(new User(2, "jiekami2", new Date()));
        users.add(new User(3, "jiekami3"));

        // 过滤 filter
        Stream<User> stream = users.stream();
//        stream.filter(e -> e.getId() > 2).forEach(System.out::println);

        // 截断流 limit
//        users.stream().limit(1).forEach(System.out::println);

        // 跳过 skip
//        users.stream().skip(1).forEach(System.out::println);
        users.add(new User(3, "jiekami3"));
        users.add(new User(3, "jiekami3"));
        users.add(new User(3, "jiekami3"));

        // 筛选 distinct
        users.stream().distinct().forEach(System.out::println);

    }
}

5.3 映射

package com.wpj.stream.mapping;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;

/**
 * @author JieKaMi
 * @date 2020/6/2 9:22
 * @Description
 *      stream 映射
 */
public class StreamMappingDemo {


    @Test
    public void test(){
        // 映射 map
        List<String> strings = Arrays.asList("aa", "bb", "cc", "dd");
        strings.stream().map(s -> s.toUpperCase()).forEach(System.out::println);


        // flatMap
//        strings.stream().flatMap().forEach(System.out::println);

    }
}

5.4 排序

package com.wpj.stream.sort;

import com.wpj.model.User;
import org.junit.Test;

import java.util.*;

/**
 * @author JieKaMi
 * @date 2020/6/2 9:36
 * @Description
 *      排序
 *
 */
public class StreamSortDemo {

    @Test
    public void test(){
        // 自然排序 sorted
        List<Integer> integers = Arrays.asList(12, 13, 3, 42, 24);
        integers.stream().sorted().forEach(System.out::println);
        // 定制排序 sorted(Comparable c)
        List<User> users = new ArrayList<>();
        users.add(new User(1, "jiekami", new Date()));
        users.add(new User(2, "jiekami2", new Date()));
        users.add(new User(3, "jiekami3", new Date()));
        users.stream().sorted((o1, o2) -> Integer.compare(o2.getId(), o2.getId())).forEach(System.out::println);


    }
}

5.5 中止

package com.wpj.stream.suspend;

import com.wpj.model.User;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author JieKaMi
 * @date 2020/6/2 9:46
 * @Description
 *      stream中止操作
 */
public class StreamSuspendDemo {

    @Test
    public void test(){
        // 匹配与查找

        List<User> users = new ArrayList<>();
        users.add(new User(1, "jiekami", new Date()));
        users.add(new User(2, "jiekami2", new Date()));
        users.add(new User(3, "jiekami3", new Date()));

        // allMatch() 检查是否匹配所有元素
        // anyMatch() 检查是否匹配至少一个元素 懒
        // noneMatch() 检查是否没有匹配元素 还是懒
        boolean allMatch = users.stream().allMatch(u -> u.getId() == 1);
        System.out.println(allMatch);

        // findFirst 返回第一个元素
        Optional<User> first = users.stream().findFirst();
        System.out.println(first);
        // findAny 返回流中任意一个元素
        Optional<User> any = users.parallelStream().findAny();
        System.out.println(any);

        // count 返回流中的个数
        long count = users.stream().count();
        long count2 = users.stream().filter(u -> u.getId()>2).count();
        System.out.println(count);

        // max(Comparator c) min(Comparator c) 最大最小值
        Stream<Integer> idStream = users.stream().map(u -> u.getId());
        Optional<Integer> max = idStream.max(Integer::compareTo);
        System.out.println(max);

        // foreach(Consumer c) 内部迭代
        users.stream().forEach(System.out::println);
        users.forEach(System.out::println);

    }

    @Test
    public void test2(){

        // 规约 reduce
        // 1-10自然数的和
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer reduce = integers.stream().reduce(0, Integer::sum);
        System.out.println(reduce);

        // 工资之和 没有工资 就给id 差不多


        List<User> users = new ArrayList<>();
        users.add(new User(1, "jiekami", new Date()));
        users.add(new User(2, "jiekami2", new Date()));
        users.add(new User(3, "jiekami3", new Date()));

        Stream<Integer> integerStream = users.stream().map(User::getId);
        Optional<Integer> reduce1 = integerStream.reduce(Integer::sum);
        System.out.println(reduce1);

    }

    @Test
    public void test3(){
        // 收集
        List<User> users = new ArrayList<>();
        users.add(new User(1, "jiekami", new Date()));
        users.add(new User(2, "jiekami2", new Date()));
        users.add(new User(3, "jiekami3", new Date()));

        List<User> collect = users.stream().filter(u -> u.getId() > 0).collect(Collectors.toList());
        System.out.println(collect);


    }
}

6. Optional

6.1 准备

package com.wpj.optional;

import java.util.Objects;

/**
 * @author JieKaMi
 * @date 2020/6/2 10:40
 * @Description
 */
public class Girl {

    private String name;

    public Girl() {
    }

    public Girl(String name) {
        this.name = name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Girl girl = (Girl) o;
        return Objects.equals(name, girl.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    public String getName() {
        return name;
    }

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

package com.wpj.optional;

/**
 * @author JieKaMi
 * @date 2020/6/2 10:40
 * @Description
 */
public class Boy {
    private Girl girl;

    public Girl getGirl() {
        return girl;
    }

    public void setGirl(Girl girl) {
        this.girl = girl;
    }

    public Boy(Girl girl) {
        this.girl = girl;
    }
}

6.2 Demo

package com.wpj.optional;

import org.junit.Test;

import java.util.Optional;

/**
 * @author JieKaMi
 * @date 2020/6/2 10:33
 * @Description
 *      容器类
 */
public class OptionalDemo {

    @Test
    public void test(){
        Girl girl = new Girl();
        Optional<Girl> optionalGirl = Optional.of(girl);
        System.out.println(optionalGirl);

        girl = null;
        Optional<Girl> optionalGirl2 = Optional.ofNullable(girl);
        System.out.println(optionalGirl2);

    }


    @Test
    public void test2(){

        Boy boy = null;
        String girlName = getGirlName(boy);
        System.out.println(girlName);

    }
    public String getGirlName(Boy boy) {

        Optional<Boy> optionalBoy = Optional.ofNullable(boy);
        Boy b = optionalBoy.orElse(new Boy(new Girl("没有的")));

        Optional<Girl> optionalGirl = Optional.ofNullable(b.getGirl());
        Girl girl = optionalGirl.orElse(new Girl("莫的"));

        return girl.getName();
    }

}