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="博客地址：https://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 = "博客地址：https://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("博客地址：https://www.cnblogs.com/chenyanbin/");
            }
        }).start();
        //jdk1.8之后需
        new Thread(() -> System.out.println("博客地址：https://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="博客地址：https://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 = https://www.cnblogs.com/chenyanbin/p/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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/238332.html

標籤：Java

上一篇：JVM GC耗時頻頻升高，我來教你排查

下一篇：PHP設計模式之策略模式

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集合統計