JDK 8 新特性，從入門到精通
阿新 • • 發佈：2020-12-22
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("講中國話");
}
}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("老陳同志在吃飯");
}
}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();
}
}靜態方法
呼叫方式：介面名.靜態方法，來訪問介面中的靜態方法
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 = 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&nbs