JDK 8 新特性，从入门到精通

2020 年 12 月 21 日
笔记
JDK8~13

default关键字

　　在jdk1.8以前接口里面是只能有抽象方法，不能有任何方法的实现的。

　　在jdk1.8里面打破了这个规定，引入了新的关键字：default，使用default修饰方法，可以在接口里定义具体的方法

创建一个工程

代码实现

默认方法

　　接口里面定义了一个默认方法，这个接口的实现类实现了这个接口之后，不用管这个default修饰的方法就可以直接调用，即接口方法的默认实现。

package com.ybchen.defaults;

public interface People {
    void run();
    void eat();
    default void speak(){
        System.out.println("讲中国话");
    }
}

People

package com.ybchen.defaults;

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/19 2:30 下午
 * @Versiion：1.0
 */
public class LaoChen implements People{
    @Override
    public void run() {
        System.out.println("老陈同志在跑步");
    }

    @Override
    public void eat() {
        System.out.println("老陈同志在吃饭");
    }
}

LaoChen

package com.ybchen.defaults;

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/19 2:31 下午
 * @Versiion：1.0
 */
public class DefaultMain {
    public static void main(String[] args) {
        People people=new LaoChen();
        people.eat();
        people.run();
        people.speak();
    }
}

DefaultMain

静态方法

　　调用方式：接口名.静态方法，来访问接口中的静态方法

base64加解密API

旧实现方式

　　使用JDK里的sun.misc下的BASE64Encoder和BASE64Decoder两个类

package com.ybchen.base64;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.IOException;

/**
 * @Description：base64 加密、解密
 * @Author：chenyanbin
 * @Date：2020/12/19 2:58 下午
 * @Versiion：1.0
 */
public class Base64Demo {
    public static void main(String[] args) throws IOException {
        BASE64Encoder encoder=new BASE64Encoder();
        BASE64Decoder decoder=new BASE64Decoder();
        String str="博客地址：//www.cnblogs.com/chenyanbin/";
        //加密
        String encode = encoder.encode(str.getBytes("utf-8"));
        System.out.println("加密后的值:"+encode);
        //解密
        byte[] bytes = decoder.decodeBuffer(encode);
        String decoderStr=new String(bytes,"utf-8");
        System.out.println("解密后的值:"+decoderStr);
    }
}

Base64Demo

jdk1.8实现方式

　　在jdk1.8的java.util包中

package com.ybchen.base64;

import java.io.IOException;
import java.util.Base64;

/**
 * @Description：base64 加密、解密
 * @Author：chenyanbin
 * @Date：2020/12/19 2:58 下午
 * @Versiion：1.0
 */
public class Base64Demo {
    public static void main(String[] args) throws IOException {
        String str = "博客地址：//www.cnblogs.com/chenyanbin/";
        Base64.Encoder encoder = Base64.getEncoder();
        Base64.Decoder decoder = Base64.getDecoder();
        //加密
        String encode = encoder.encodeToString(str.getBytes("utf-8"));
        System.out.println("加密后的值:" + encode);
        //解密
        byte[] bytes = decoder.decode(encode);
        String decoderStr = new String(bytes, "utf-8");
        System.out.println("解密后的值:" + decoderStr);
    }
}

Base64Demo

日期处理类(必备)

　　包所在的位置：java.time

核心类

LocalDate：不包含具体时间的日期
LocalTime：不含日期的时间
LocalDateTime：包含日期及时间

package com.ybchen.local_date;

import java.time.LocalDate;

/**
 * @Description：LocalDate，不包含具体时间的日期
 * @Author：chenyanbin
 * @Date：2020/12/19 4:00 下午
 * @Versiion：1.0
 */
public class LocalDateDemo {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("今天日期：" + today);
        //年
        System.out.println("现在是那年：" + today.getYear());
        //月
        System.out.println("现在是那月(英文)：" + today.getMonth());
        System.out.println("现在是那月(数字)：" + today.getMonthValue());
        //这月的那一天
        System.out.println("现在是这月的那天：" + today.getDayOfMonth());
        //现在是周几
        System.out.println("现在是周几" + today.getDayOfWeek());
        //现在是这年的第几天
        System.out.println("现在是这年的第几天:" + today.getDayOfYear());
        //加一年
        System.out.println("加一年："+today.plusYears(1));
        //加一月
        System.out.println("加一月："+today.plusMonths(1));
        //加一天
        System.out.println("加一天:"+today.plusDays(1));
        //减一年
        System.out.println("减一年："+today.minusYears(1));
        //减一月
        System.out.println("减一月："+today.minusMonths(1));
        //减一天
        System.out.println("减一天："+today.minusDays(1));
        //减一周
        System.out.println("减一周"+today.minusWeeks(1));
        //日期比较，是否在某年之后
        LocalDate plusYearDate = today.plusYears(1);
        System.out.println("是否在某年之后："+today.isAfter(plusYearDate));
        //日期比较，两个日期对象是否相等
        System.out.println("两个日期是否相等:"+today.isEqual(plusYearDate));
    }
}

LocalDateDemo

package com.ybchen.local_date;

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @Description：日期格式化
 * @Author：chenyanbin
 * @Date：2020/12/19 11:52 下午
 * @Versiion：1.0
 */
public class LocalDateTimeFormatDemo {
    public static void main(String[] args) {
        //日期格式化
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println("格式化后的日期格式：" + localDateTime.format(dateTimeFormatter));
        //获取指定的日期时间对象
        LocalDateTime ldt = LocalDateTime.of(2020, 12, 19, 11, 59, 59);
        System.out.println("获取指定日期时间对象：" + ldt);
        //计算日期时间差
        LocalDateTime toDay = LocalDateTime.now();
        System.out.println(toDay);
        LocalDateTime changeDate = LocalDateTime.of(2020, 12, 29, 11, 59, 59);
        System.out.println(changeDate);
        //相差多少天
        Duration duration = Duration.between(toDay, changeDate);
        System.out.println("相差多少天:"+ duration.toDays());
        System.out.println("相差多少小时:"+duration.toHours());
        System.out.println("相差多少分钟："+duration.toMinutes());
        System.out.println("相差多少毫秒数："+duration.toMillis());
        System.out.println("相差的纳秒数："+duration.toNanos());
    }
}

LocalDateTimeFormatDemo

Optional类

作用

空指针异常(NPE)

演示

package com.ybchen.opt;

import java.util.Optional;

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/20 12:15 上午
 * @Versiion：1.0
 */
public class OptionDemo {
    public static void main(String[] args) {
        Student student=null;
//        Student student=new Student("1","2");
        //null值作为参数传递进去，会抛异常
//        Optional<Student> optStudent = Optional.of(student);
//        //如果对象即可能是null也可能是非null，应该使用ofNullable
//        Optional<Student> optStudent2 = Optional.ofNullable(student);
//        //isPresent如果不为null时，返回true
//        if (optStudent2.isPresent()){
//            System.out.println("不为null");
//            //获取泛型中的值
//            Student student2 = optStudent2.get();
//            System.out.println(student2);
//        }else {
//            System.out.println("为null");
//        }
//
        //兜底orElse方法
        Student student3 = new Student("1", "2");
        Student student1 = Optional.ofNullable(student).orElse(student3);
        System.out.println(student1);
    }
}

OptionDemo

Lambda表达式

语法

(parameters) -> expression
或
(parameters) ->{ statements; }

重要特征

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
可选的大括号：如果主题包含了一个语句，就不需要使用大括号
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。

本质

　　Lambda表达式的实现方式本质是“以匿名内部类的方法”进行实现，重构现有臃肿代码，更高的开发效率。

package com.ybchen.lambda;

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

/**
 * @Description：lambda代码演示
 * @Author：chenyanbin
 * @Date：2020/12/20 11:16 上午
 * @Versiion：1.0
 */
public class LambdaDemo {
    public static void main(String[] args) {
        //使用多线程打印一句话
        //jdk1.8之前
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("博客地址：//www.cnblogs.com/chenyanbin/");
            }
        }).start();
        //jdk1.8之后需
        new Thread(() -> System.out.println("博客地址：//www.cnblogs.com/chenyanbin/")).start();

        //List排序
        List<String> list= Arrays.asList("a","f","b","c");
        //jdk1.8之前排序：Comparator
//        Collections.sort(list, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareTo(o2);
//            }
//        });
//        System.out.println(list);
        //jdk 1.8 lambda排序
        Collections.sort(list,(o1, o2)->o1.compareTo(o2));
        System.out.println(list);
    }
}

自定义Lambda接口编程

定义一个函数式接口，需要标注此接口：@FunctionalInterface，否则万一团队成员在接口上加了其他方法则容易出现故障
编写一个方法，输入需要操作的数据和接口
在调用方法时传入数据和lambda表达式，用来操作数据

需求

　　定义一个可以使用加减乘除的接口，以前的话，需要定义4个接口，现在只需要定义一个即可。

代码实现

package com.ybchen.lambda;
@FunctionalInterface
//R:return；T：参数
public interface OperatorFunction<R,T> {
    R operator(T t1,T t2);
}

OperatorFunction

package com.ybchen.lambda;

/**
 * @Description：四则运算
 * @Author：chenyanbin
 * @Date：2020/12/20 1:35 下午
 * @Versiion：1.0
 */
public class OperatorDemo {
    public static void main(String[] args) {
        System.out.println("加法：" + operator(20, 5, (x, y) -> x + y));
        System.out.println("减法：" + operator(20, 5, (x, y) -> x - y));
        System.out.println("乘法：" + operator(20, 5, (x, y) -> x * y));
        System.out.println("除法：" + operator(20, 5, (x, y) -> x / y));
    }

    private static Integer operator(Integer x, Integer y, OperatorFunction<Integer, Integer> operatorFunction) {
        return operatorFunction.operator(x, y);
    }
}

OperatorDemo

JDK 1.8 新增加的函数接口

　　文档地址：点我直达

函数式编程Function

传入一个值经过函数的计算返回另一个值
T：入参类型，R：出参类型
调用方法：R apply(T t)

函数式编程Bifunction

Function只能接收一个参数，如果要传递两个参数，则用Bifunction

package com.ybchen.lambda;

import java.util.function.BiFunction;

/**
 * @Description：BiFunction
 * @Author：chenyanbin
 * @Date：2020/12/20 2:27 下午
 * @Versiion：1.0
 */
public class BiFunctionDemo {
    public static void main(String[] args) {
        System.out.println("加法：" + operator(20, 5, (x, y) -> x + y));
        System.out.println("减法：" + operator(20, 5, (x, y) -> x - y));
        System.out.println("乘法：" + operator(20, 5, (x, y) -> x * y));
        System.out.println("除法：" + operator(20, 5, (x, y) -> x / y));
    }
    private static Integer operator(Integer x, Integer y, BiFunction<Integer,Integer,Integer> biFunction){
        return biFunction.apply(x,y);
    }
}

BiFunctionDemo

函数式编程Consumer

有入参，无返回值
用途：因为没有出参，常用于打印、发送短信等消费动作

package com.ybchen.lambda;

import java.util.function.Consumer;

/**
 * @Description：Consumer
 * @Author：chenyanbin
 * @Date：2020/12/20 2:35 下午
 * @Versiion：1.0
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        Consumer<String> consumer=(phone)->{
            System.out.println("手机号："+phone);
            System.out.println("发送短信成功");
        };
        sendMsg("11111",consumer);
    }
    private static void sendMsg(String phone, Consumer<String> consumer){
        consumer.accept(phone);
    }
}

ConsumerDemo

jdk源码中的使用

函数式编程Supplier

供给型接口：无入参，有返回值
T：出参类型，没有入参
用途：泛型一定和方法的返回值类型是一种类型，如果需要获得一个数据，并且不需要传入参数，可以使用Supplier接口，例如：无参的工厂方法，即工厂设计模式创建(点我直达)对象，简单来说就是提供者，方便程序的解耦，(给你个眼神自己体会)

package com.ybchen.lambda;

import java.util.function.Supplier;

/**
 * @Description：Supplier功能演示
 * @Author：chenyanbin
 * @Date：2020/12/20 8:30 下午
 * @Versiion：1.0
 */
public class SupplierDemo {
    public static void main(String[] args) {
        Student2 stu=getStudent2();
        System.out.println(stu);
    }
    private static Student2 getStudent2(){
        Supplier<Student2> supplier=()->{
            Student2 student2=new Student2();
            student2.setId("2");
            student2.setName("默认名称");
            return student2;
        };
        return supplier.get();
    }
}
class Student2{
    private String id;
    private String name;

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

SupplierDemo

函数式编程Predicate

断言型接口：有入参，有返回值i，返回值类型确定是Boolean
T：入参类型；出参类型是Boolean
调用方法：boolean test(T t)
用途：接收一个参数，用于判断是否满足一定的条件，过滤数据

package com.ybchen.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * @Description：Predicate断言演示
 * @Author：chenyanbin
 * @Date：2020/12/20 8:56 下午
 * @Versiion：1.0
 */
public class PredicateDemo {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,3,4,5,6);
        List<Integer> fileter = fileter(list, num -> num % 2 == 0);
        fileter.forEach(num-> System.out.println(num));
    }
    private static List<Integer> fileter(List<Integer> list, Predicate<Integer> predicate){
        List<Integer> resultList=new ArrayList<>();
        for (Integer i:list){
            if (predicate.test(i)){
                resultList.add(i);
            }
        }
        return resultList;
    }
}

PredicateDemo

构造函数引用

　　jdk1.8之前，方法调用，对象.方法名，或者 类名.方法名

　　jdk1.8提供了另外一种调用方式::

　　方法引用时一种更简洁易懂的lambda表达式，操作符是双冒号“::”，用来直接访问类或者实例已经存在的方法或构造方法。

静态方法，ClassName::methodName
实例方法，Intance::methodName
构造函数，类名::new

package com.ybchen.lambda;

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

/**
 * @Description：构造函数的引用
 * @Author：chenyanbin
 * @Date：2020/12/20 9:33 下午
 * @Versiion：1.0
 */
public class ConstructionDemo {
    public static void main(String[] args) {
        //使用双冒号::，来构造静态函数的引用
        Function<String,Integer> func=Integer::parseInt;
        System.out.println(func.apply("123") instanceof Integer);
        //使用双冒号::，来构造非静态函数的引用
        String content="博客地址：//www.cnblogs.com/chenyanbin/";
        Function<Integer,String> func2=content::substring;
        String result = func2.apply(2);
        System.out.println(result);
        //构造函数
        Function<String,Student3> func3=Student3::new;
        Student3 stu3 = func3.apply("1");
        System.out.println(stu3);
        BiFunction<String,String,Student3> func4=Student3::new;
        Student3 stu4 = func4.apply("1", "老陈");
        System.out.println(stu4);
    }
}
class Student3{
    private String id;
    private String name;

    public Student3() {
    }

    public Student3(String id) {
        this.id = id;
    }

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

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

true
地址：https://www.cnblogs.com/chenyanbin/
Student3{id='1', name='null'}
Student3{id='1', name='老陈'}

Process finished with exit code 0

集合框架

什么是Stream？

　　Stream中文称为“流”，通过将集合转换为“流”的元素队列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作

map和filter函数

map

将流中的每一个元素T映射为R
应用场景：转换对象，如：DO对象转换为DTO对象

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：map功能演示
 * @Author：chenyanbin
 * @Date：2020/12/20 10:15 下午
 * @Versiion：1.0
 */
public class MapDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("老陈","老李","老王");
        List<String> collect = list.stream().map(name -> "我叫：" + name).collect(Collectors.toList());
        collect.forEach(name-> System.out.println(name));
    }
}

MapDemo

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：map，do转dto功能演示
 * @Author：chenyanbin
 * @Date：2020/12/20 10:48 下午
 * @Versiion：1.0
 */
public class MapDemo2 {
    public static void main(String[] args) {
        List<User> list= Arrays.asList(new User("1","老陈","123"),
                new User("1","老王","123456"));
        List<UserDTO> collect = list.stream().map(obj -> new UserDTO(obj.getId(), obj.getName())).collect(Collectors.toList());
        collect.forEach(obj-> System.out.println(obj));
    }
}
class User{
    private String id;
    private String name;
    private String pwd;

    public User() {
    }

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

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }
}
class UserDTO{
    private String userId;
    private String userName;

    public UserDTO(String userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }

    @Override
    public String toString() {
        return "UserDTO{" +
                "userId='" + userId + '\'' +
                ", userName='" + userName + '\'' +
                '}';
    }
}

MapDemo2

filter

应用：用于设置条件的过滤

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：Filter功能演示，过滤对2取余等于0的元素
 * @Author：chenyanbin
 * @Date：2020/12/20 10:19 下午
 * @Versiion：1.0
 */
public class FilterDemo {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        List<Integer> collect = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
        collect.forEach(num-> System.out.println(num));
    }
}

FilterDemo

limit、skip、sorted函数

sorted

对流进行自然排序，其中的元素必须实现Comparable接口

package com.ybchen.stream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/20 11:23 下午
 * @Versiion：1.0
 */
public class SortedDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","Dubbo","SpringCloud");
        //默认升序
        List<String> collect = list.stream().sorted().collect(Collectors.toList());
        System.out.println(collect);
        System.out.println("-----------");
        //自定义排序，根据长度升序
        List<String> collect1 = list.stream().sorted(Comparator.comparing(obj -> obj.length())).collect(Collectors.toList());
        System.out.println(collect1);
        //自定义排序，根据长度降序
        List<String> collect2 = list.stream().sorted(Comparator.comparing(obj -> obj.length(),Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(collect2);
        //方法引用的玩法
        List<String> collect3 = list.stream().sorted(Comparator.comparing(String::length,Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(collect3);

    }
}

limit

截断流使用最多只包含指定数量的元素

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：获取前3个元素
 * @Author：chenyanbin
 * @Date：2020/12/20 11:36 下午
 * @Versiion：1.0
 */
public class LimitDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","Dubbo","SpringCloud");
        List<String> collect = list.stream().limit(3).collect(Collectors.toList());
        System.out.println(collect);
    }
}

LimitDemo

skip

跳过多少个元素

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：跳过前2个元素
 * @Author：chenyanbin
 * @Date：2020/12/20 11:41 下午
 * @Versiion：1.0
 */
public class SkipDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","Dubbo","SpringCloud");
        List<String> collect = list.stream().skip(2).collect(Collectors.toList());
        System.out.println(list);
        System.out.println(collect);
    }
}

SkipDemo

allMatch和anyMatch函数

allMatch

检查是否匹配所有元素，只有全部符合才返回true

package com.ybchen.stream;

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

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/20 11:46 下午
 * @Versiion：1.0
 */
public class AllMatchDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","SDubbo","SpringCloud");
        boolean b = list.stream().allMatch(str -> str.startsWith("S"));
        System.out.println(b);
    }
}

AllMatchDemo

anyMatch

检查是否至少匹配一个元素

package com.ybchen.stream;

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

/**
 * @Description：至少匹配一个返回true
 * @Author：chenyanbin
 * @Date：2020/12/20 11:48 下午
 * @Versiion：1.0
 */
public class AnyMatchDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","Dubbo","SpringCloud");
        boolean b = list.stream().anyMatch(str -> str.startsWith("s"));
        System.out.println(b);
    }
}

AnyMatchDemo

max和min函数

求最大、最小

package com.ybchen.stream;

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

/**
 * @Description：求最大、最小
 * @Author：chenyanbin
 * @Date：2020/12/21 12:01 上午
 * @Versiion：1.0
 */
public class MaxAndMinDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","Dubbo","SpringCloud");
        String s = list.stream().max((str1, str2) -> str1.length() - str2.length()).get();
        System.out.println(s);
        String s2 = list.stream().min((str1, str2) -> str1.length() - str2.length()).get();
        System.out.println(s2);
    }
}

MaxAndMinDemo

distinct函数

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description：对元素去重
 * @Author：chenyanbin
 * @Date：2020/12/20 11:54 下午
 * @Versiion：1.0
 */
public class DistinctDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("SpringBoot","SpringMvc","Dubbo","SpringCloud","Dubbo");
        System.out.println(list);
        List<String> collect = list.stream().distinct().collect(Collectors.toList());
        System.out.println(collect);
    }
}

DistinctDemo

并行流parallelStream

集合做重复的操作，如果使用串行执行会相当耗时，因此一般会采用多线程来加快，java 8的paralleStream用fork/join框架提供了并发执行能力

package com.ybchen.stream;

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

/**
 * @Description：ParallelStream串行流演示
 * @Author：chenyanbin
 * @Date：2020/12/21 9:41 下午
 * @Versiion：1.0
 */
public class ParallelStreamDemo {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8);
        list.stream().forEach(System.out::println);
        System.out.println("===============");
        list.parallelStream().forEach(System.out::println);
    }
}

ParallelStreamDemo

注意事项

parallelStream里面使用外部变量时，会出现线程安全问题，集合一定要使用线程安全集合

reduce操作

根据一定的规则将Stream中的元素进行计算后返回一个唯一的值

常用方法一

package com.ybchen.stream;

import java.util.stream.Stream;

/**
 * @Description：Reduce功能演示
 * @Author：chenyanbin
 * @Date：2020/12/21 10:01 下午
 * @Versiion：1.0
 */
public class ReduceDemo {
    public static void main(String[] args) {
        Integer sum = Stream.of(1, 2, 3, 4).reduce((num1, num2) -> num1 + num2).get();
        System.out.println(sum);
    }
}

ReduceDemo

求一堆数的最大值

package com.ybchen.stream;

import java.util.stream.Stream;

/**
 * @Description：Reduce功能演示
 * @Author：chenyanbin
 * @Date：2020/12/21 10:01 下午
 * @Versiion：1.0
 */
public class ReduceDemo {
    public static void main(String[] args) {
        //求一堆数的最大值
        Integer maxValue = Stream.of(1, 33, 5, 6, 2).reduce((num1, num2) -> num1 > num2 ? num1 : num2).get();
        System.out.println(maxValue);
    }
}

ReduceDemo

常用方法二

　　提供一个初始值，进行数据累加

package com.ybchen.stream;

import java.util.stream.Stream;

/**
 * @Description：Reduce功能演示
 * @Author：chenyanbin
 * @Date：2020/12/21 10:01 下午
 * @Versiion：1.0
 */
public class ReduceDemo {
    public static void main(String[] args) {
        //提供一个初始值，对数据进行累加操作
        Integer sum = Stream.of(1, 2, 3, 4).reduce(100,(num1, num2) -> num1 + num2);
        System.out.println(sum);
    }
}

ReduceDemo

收集器和集合统计

collector收集器

package com.ybchen.stream;

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

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/21 10:45 下午
 * @Versiion：1.0
 */
public class CollectorDemo {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,3,4,5);
        List<Integer> collect = list.stream().collect(Collectors.toList());
        Set<Integer> collect1 = list.stream().collect(Collectors.toCollection(TreeSet::new));
        List<Integer> collect2 = list.stream().collect(Collectors.toCollection(LinkedList::new));
    }
}

joining函数

拼接函数，Collectors.joining

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Description：字符串拼接
 * @Author：chenyanbin
 * @Date：2020/12/21 10:51 下午
 * @Versiion：1.0
 */
public class JoinDemo {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("a","b","c","d");
        String collect = list.stream().collect(Collectors.joining());
        System.out.println(collect);
        System.out.println("==========");
        String collect2 = list.stream().collect(Collectors.joining("_"));
        System.out.println(collect2);
        System.out.println("==========");
        String collect3 = list.stream().collect(Collectors.joining("_","(",")"));
        System.out.println(collect3);
        System.out.println("=========");
        String result = Stream.of("a", "b", "c", "d").collect(Collectors.joining(",", "“", "”"));
        System.out.println(result);
    }
}

JoinDemo

partitioningBy分组

Collectors.partitioningBy分组，key是boolean类型

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description：
 * @Author：chenyanbin
 * @Date：2020/12/21 11:01 下午
 * @Versiion：1.0
 */
public class PartitioningByDemo {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,3,4,5,6);
        Map<Boolean, List<Integer>> collect = list.stream().collect(Collectors.partitioningBy(num -> num % 2 == 0));
        System.out.println(collect);
    }
}

PartitioningByDemo

groupby分组

分组，Collectors.groupingBy()

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description：根据学生所在的省份，进行分组
 * @Author：chenyanbin
 * @Date：2020/12/21 11:05 下午
 * @Versiion：1.0
 */
public class GroupByDemo {
    public static void main(String[] args) {
        List<Student> list= Arrays.asList(
                new Student("老陈","上海"),
                new Student("老王","北京"),
                new Student("老李","上海"),
                new Student("老赵","广东"));
        Map<String, List<Student>> collect = list.stream().collect(Collectors.groupingBy(obj -> obj.getProvince()));
        System.out.println(collect);
    }
}
class Student{
    private String name;
    private String province;

    public Student(String name, String province) {
        this.name = name;
        this.province = province;
    }

    public String getProvince() {
        return province;
    }

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

GroupByDemo

counting集合统计

聚合函数进行统计查询，分组后统计个数
Collectors.counting()：统计元素个数

需求：统计省份的人数

package com.ybchen.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description：根据学生所在的省份，进行分组
 * @Author：chenyanbin
 * @Date：2020/12/21 11:05 下午
 * @Versiion：1.0
 */
public class GroupByDemo {
    public static void main(String[] args) {
        List<Student> list= Arrays.asList(
                new Student("老陈","上海"),
                new Student("老王","北京"),
                new Student("老李","上海"),
                new Student("老赵","广东"));
        Map<String, Long> collect = list.stream().collect(Collectors.groupingBy(obj -> obj.getProvince(), Collectors.counting()));
        System.out.println(collect);
    }
}
class Student{
    private String name;
    private String province;

    public Student(String name, String province) {
        this.name = name;
        this.province = province;
    }

    public String getProvince() {
        return province;
    }

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

GroupByDemo

Tags: JDK8~13

JDK 8 新特性，从入门到精通

default关键字

创建一个工程

代码实现

默认方法

静态方法

base64加解密API

旧实现方式

jdk1.8实现方式

日期处理类(必备)

核心类

Optional类

作用

演示

Lambda表达式

语法

重要特征

本质

自定义Lambda接口编程

需求

代码实现

JDK 1.8 新增加的函数接口

函数式编程Function

函数式编程Bifunction

函数式编程Consumer

jdk源码中的使用

函数式编程Supplier

函数式编程Predicate

构造函数引用

集合框架

什么是Stream？

map和filter函数

map

filter

limit、skip、sorted函数

sorted

limit

skip

allMatch和anyMatch函数

allMatch

anyMatch

max和min函数

distinct函数

并行流parallelStream

注意事项

reduce操作

常用方法一

常用方法二

收集器和集合统计

collector收集器

joining函数

partitioningBy分组

groupby分组

counting集合统计

分享此文：

Related Posts

At 、Crontabl定时任务

Terraform模块Module管理，聚合资源的抽取与复用

不一样的资产安全 3D 可视化平台

鲁大师Pro发布：免费掌控员工一举一动

VirMach 便宜 VPS

QNews

热门搜寻