Java：部分常用函式式介面，Stream流
1、常用函式式介面-Predicate判斷介面
有時候我們需要對某種型別的資料進行判斷，從而得到一個boolean值結果。這時可以
使用java.util.function.Predicate<T>介面。
1）、抽象方法：判斷“是否”，用於判斷，重寫方法
public boolean test(T t);
2）、預設方法：判斷“並且”
public default Predicate<T> and(Predicate<? super T> other){}
3）、預設方法：判斷“或者”
public default Predicate<T> or 4）、預設方法：判斷”非“
public default Predicate<T> negate(){}
例：
test()：接收一個字串，如果長度大於5，列印：很長；否則列印：不長
public static void main(String[] args) {
//1.測試：抽象方法：boolean test(T t)
fun1((String s)->{return s.length() > 5;},"HelloWorld");
}
//1.測試：抽象方法：boolean test(T t) and()：判斷字串中即包含H，又包含W
public static void main(String[] args) {
//2.測試：預設方法：and--判斷字串中即包含H，又包含W or()：判斷字串中包含H，或者包含W
public static void main(String[] args) {
//3.測試：預設方法：or--判斷字串中包含H，或者包含W
fun3((String s) -> {return s.contains("H");}, (String s) -> {return s.contains("W");}, "helloworld");
}
//3.測試：預設方法：or--判斷字串中是否包含H，或者W
//分析：需要兩個判斷，而且兩個判斷是"或者"關係，所以需要兩個Predicat
public static void fun3(Predicate<String> p1, Predicate<String> p2, String s) {
boolean b = p1.or(p2).test(s);
System.out.println("判斷字串中是否包含H，或者W ： " + b);
}
negate()：判斷字串中是否不包含H
public static void main(String[] args) {
//4.測試：預設方法：negate--判斷字串中是否不包含H
fun4((String s) -> {
return s.contains("H");
}, "hello");
}
//4.測試：預設方法：negate--判斷字串中是否不包含H
//分析：需要一個判斷
public static void fun4(Predicate<String> p1, String s) {
boolean b = p1.negate().test(s);
System.out.println("判斷字串中是否不包含H : " + b);
}
2、常用函式式介面-Predicate判斷介面-練習
有以下陣列：
String[ ] array = { "迪麗熱巴, 女", "古力娜扎, 女", "馬爾扎哈, 男", "趙麗穎, 女" };
需求：1、必須為女生，2、姓名為4個字
程式碼實現：
public static void main(String[] args) {
String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };
for (String s : array) {
fun((String ss) -> {
return ss.split(",")[0].length() == 4;
}, (String ss) -> {
return ss.split(",")[1].equals("女");
}, s);
}
}
//編寫方法，可以找出：1).名字必須是4個字；2).女生
//分析：需要兩個判斷，而且是並且關係，所以需要兩個Preticate
public static void fun(Predicate<String> p1, Predicate<String> p2, String s) {
boolean b = p1.and(p2).test(s);
if (b == true) {
System.out.println(s);
}
}
3、常用函式式介面-Funnction函式介面
java.util.function.Function<T,R>介面用來根據一個型別的資料得到另一個型別的資料，前者稱為前置條件，後者稱為後置條件。有進有出，所以稱為“函式Function”。
JDK中的原始碼：（部分）
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);//通常用於“轉換”，例如將：String轉換為Integer
default Function andThen(Function after) {//將本次轉換的結果再次轉換
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
....
}
1）、抽象方法：Rapply(T t)，將String型別轉換為Integer型別
public static void main(String[] args) {
//1.測試：抽象方法：R apply(T t)，將String型別轉換為Integer型別
fun1((String s) -> {
return Integer.parseInt(s);
}, "20");
}
//1.測試：抽象方法：R apply(T t)，將String型別轉換為Integer型別
public static void fun1(Function<String, Integer> f, String s) {
Integer n = f.apply(s);
System.out.println("轉換後的結果 + 10 = " + (n + 10));
}
2）、預設方法：andThen()：將String型別轉換為Integer型別，再將結果+10後轉換為String
public static void main(String[] args) {
//2.測試：預設方法：andThen():，將String型別轉換為Integer型別，將轉換後結果 + 10 後再轉為String
fun2((String s) -> {
return Integer.parseInt(s);
}, (Integer n) -> {
return Integer.toString(n + 10 );
}, "24");
}
//2.測試：預設方法：andThen():，將String型別轉換為Integer型別，將轉換後結果 + 10 再轉換為String
//分析：需要兩次轉換：第一次：String-->Integer ；第二次：Integer + 10 -->String
// (雖然是計算，但也可以作為一次轉換)
public static void fun2(Function<String, Integer> f1, Function<Integer, String> f2, String s) {
String n = f1.andThen(f2).apply(s);
System.out.println("轉換後的結果：" + n);
}
4、常用函式式介面-Funnction函式介面-練習
需求：
有字串：String str = “趙麗穎，20”;
1）、將字串擷取數字年齡部分，得到字串
2）、將上一步的字串轉換為int型別的數字
3）、將上一步的int數字累加100，得到結果int數字
程式碼實現：
public static void main(String[] args) {
String str = "趙麗穎,20";
fun1((String s) -> {
return s.split(",")[1];
},
(String s) -> {
return Integer.parseInt(s);
},
(Integer n) -> {
return n + 100;
}, str);
}
/*
1 .將字串擷取數字年齡部分，得到字串；
2. 將上一步的字串轉換成為int型別的數字；
3. 將上一步的int數字累加100， 得到結果int數字。
*/
//分析：三次轉換，需要三個Function
public static void fun1(Function<String, String> f1,
Function<String, Integer> f2,
Function<Integer, Integer> f3, String s) {
Integer n = f1.andThen(f2).andThen(f3).apply(s);
System.out.println("最後結果：" + n + " 資料型別：" + n.getClass().getName());
}
5、常用函式式介面-總結-延遲方法與終結方法
1）、延遲方法：只是在拼接Lambda函式模型的方法，並不立即執行得到結果
2）、終結方法：根據拼好的Lambda函式模型，立即執行得到結果值的方法。
| 介面名稱 | 方法名稱 | 抽象/預設 | 延遲/終結 |
|---|---|---|---|
| Supplier | get | 抽象 | 終結 |
| Consumer | accept | 抽象 | 終結 |
| andThen | 預設 | 延遲 | |
| Predicate | test | 抽象 | 終結 |
| and | 預設 | 延遲 | |
| or | 預設 | 延遲 | |
| negate | 預設 | 延遲 | |
| Function | apply | 抽象 | 終結 |
| andThen | 預設 | 延遲 |
6、Stream流-Stream流進行集合過濾的效果演示
public static void main(String[] args) {
List<String> list = new ArrayList<>() ;
list. add("張無忌") ;
list. add("周芷若") ;
list. add("張學友") ;
list. add("張強") ;
list. add("張三丰") ;
//***********我們自己查詢*************//
//1.找出所有的"張姓"學員
/*List<String> zhangList = new ArrayList<>();
for (String s : list) {
if(s.startsWith("張")){
zhangList.add(s);
}
}
//2.再找出"張姓"學員中，三個字的學員
List<String> list3 = new ArrayList<>();
for (String s : zhangList) {
if (s.length() == 3) {
list3.add(s);
}
}
//3.取前張姓，三個字的，前兩名學員
List<String> list4 = new ArrayList<>();
for (int i = 0; i < list3.size() ; i++) {
if (i == 0 || i == 1) {
list4.add(list3.get(i));
}
}
System.out.println(list4);*/
//**********使用stream流******************//
list.stream()
.filter((String s)-> {return s.startsWith("張");})
.filter((String s)->{return s.length() == 3;})
.limit(2)
.forEach((String s)->{System.out.println(s);});
}
7、Stream流-流思想概述
Stream流：類似於迭代器，是對集合進行操作的工具類，包含了很多對集合操作的方法，尤其進行篩選，過濾，求總數量…等操作，使用Stream流+Lambda表示式，非常方便
Stream流不會有倆個泛型
12、Stream流-獲取List-Set-Map-陣列流
Stream流通常是通過集合進行獲取的
1）、List集合獲取流：
List<String> list = new ArrayList<>();
....
Stream<String> s = list.stream();
2）、Set集合獲取流：
Set<String> set = new HashSet<>();
...
Stream<String> s = set.stream();
3）、Map集合獲取流：
Map<String,String> map = new HashMap<>();
...
Stream<String> keyStream = map.keySet().stream();
String<String> valueStream = map.values().stream();
所有的Collection集合都可以通過stream預設方法獲取流；
4）、通過“陣列”獲取流：
//1、零散的資料
Stream<String> s1 = Stream.of("a", "b", "c", "d");
//2、“陣列”獲取流
Integer[] arr = {10, 20, 30, 40};//必須是引用型別陣列
Stream<Integer> s2 = Stream.of(arr);
//3、基本型別陣列
int[] arr2 = {10, 20, 30, 40};
IntStream s3 = IntStream.of(arr2);
System.out.println(s3.max().getAsInt());
13、Stream流-常用方法-過濾filter
1）、原始碼：
Stream<T> filter(Predicate predicate)
2）、測試：
List<String> list = new ArrayList<>() ;
list. add("張無忌") ;
list. add("周芷若") ;
list. add("張學友") ;
list. add("張強") ;
list. add("張三丰") ;
Stream<String> stream = list.stream();
stream.filter((String s)->{ return s.startsWith("張");});
14、Stream流-常用方法-逐一處理forEach
1）、原始碼：
void forEach(Consumer action);
2）、測試：
List<String> list = new ArrayList<>() ;
list. add("張無忌") ;
list. add("周芷若") ;
list. add("張學友") ;
list. add("張強") ;
list. add("張三丰") ;
list.stream().forEach((String s)->{System.out.println(s);});
//引用：System.out.println()方法
list.stream().forEach(System.out::println);
15、Stream流-常用方法-統計個數count
1）、原始碼：
long count();
2）、測試：
List<String> list = new ArrayList<>() ;
list. add("張無忌") ;
list. add("周芷若") ;
list. add("張學友") ;
list. add("張強") ;
list. add("張三丰") ;
long c = list.stream().filter((String s)->{return s.startsWith("張");}).count();
System.out.println("張姓學員公有：" + c + " 名");
16、Stream流-常用方法-取前幾個limit
1）、原始碼：
Stream<T> limit(long maxSize);
2）、測試：
List<String> list = new ArrayList<>() ;
list. add(
相關推薦
Java：部分常用函式式介面，Stream流
1、常用函式式介面-Predicate判斷介面
有時候我們需要對某種型別的資料進行判斷，從而得到一個boolean值結果。這時可以
使用java.util.function.Predicate<T>介面。
1）、抽象方法：判斷“是否”，用於判斷，重寫
Java 8 函式式介面，Function，Consumer，Predicate 介面的學習
void accept(T t);
2.1 使用
還是如上的例子，Demo程式碼如下：
public class Test {
public static void main(String[] args) throws InterruptedException {
JAVA基礎程式設計104--函式式介面《下》
函式式介面使用案例
一、Runnable
/**
* 1、Runnable :執行緒啟用介面
* A、void run()
* 多執行緒用junit5.0進行單元測試
*/
@Test
pub
java8實戰二------lambda表示式和函式式介面，簡單就好
一、Lambda
可以把Lambda表示式理解為簡潔地i表示可傳遞的匿名函式的一種方式：它沒有名稱，但它有引數列表、函式主體、返回型別，可能還是一個可以丟擲的異常列表。
聽上去，跟我們用的匿名類，匿名方法什麼的很像。我們繼續看看把。
第一篇，我們做的事分蘋果，這次我們給蘋果根據重量來做個Comparat
8000字長文讓你徹底瞭解 Java 8 的 Lambda、函式式介面、Stream 用法和原理
> 我是風箏，公眾號「古時的風箏」。一個兼具深度與廣度的程式設計師鼓勵師，一個本打算寫詩卻寫起了程式碼的田園碼農！
文章會收錄在 [JavaNewBee](https://github.com/huzhicheng/JavaNewBee) 中，更有 Java 後端知識圖譜，從小白到大牛要走的路都在裡面。公眾號
Java：函式式介面、方法引用
1、函式式介面-概念及格式
函式式介面：有且只有一個抽象方法的介面（可以有其他的方法：預設方法，靜態方法，私有方法…）
2、函式式介面[email protected]註解
1）、在定義函式式介面時，為防止發生定義錯誤，可使用@FunctionalIn
Java 8中一些常用的全新的函式式介面
函式式介面
什麼是函式式介面？
函式式介面，@FunctionalInterface，簡稱FI，簡單的說，FI就是指僅含有一個抽象方法的介面，以@Functionalnterface標註，注意⚠️，這裡的抽象方法指的是該介面自己特有的抽象方法，而不包含它從其
死磕Lambda表示式（四）：常用的函式式介面
失去人性，失去很多；失去獸性，失去一切。——《三體》
在Java8支援Lambda表示式以後，為了滿足Lambda表示式的一些典型使用場景，JDK為我們提供了大量常用的函式式介面。它們主要在 java.util.function 包中，下面簡單介紹幾個其中的介面及其使用示例。
Supplier介面
Sup
初識Lambda表示式2(JDK提供的函式式介面的引出)----java
一個小栗子
為了更加深刻的理解lambda表示式,寫了如下一個栗子:
package com.nrsc.lambda.MoneyDemo;
import java.text.DecimalFormat;
@FunctionalInterface
inte
Java 8 常見函式式介面使用簡單示例
簡介
JDK 1.8 API包含了很多內建的函式式介面。之所以提供這些介面，是因為它們有比較多的使用場景，通過結合使用lambda表示式，我們可以很方便地利用這些介面將一些邏輯作為變數傳遞甚至組合起來實現更為複雜的邏輯，就像我們將一些普通類物件作為變數傳遞或者組合起來一樣方便。
初識Lambda表示式3----JDK提供函式式介面的引出2---java
寫在前面的話
總感覺上篇部落格有些東西需要補充,於是思來想去寫下了本篇部落格…
1.場景引入
場景: 假如有這樣一種場景,我們的專案裡有好多方法,這些方法的引數都包含一個介面,這些介面雖然其功能各不相同,但是卻都有一個共同點
java-函數語言程式設計-函式式介面以及方法應用
一、lambda表示式
1、 Lambda表示式是匿名內部類的簡化寫法。
Lambda標準格式：
(引數型別 引數名) -> {
方法體;
return 返回值;
}
java8第三課：函式式介面
這節課我們講講函式式介面。
什麼叫函式式介面?
如果一個介面有且僅有一個未實現的方法，我們就說這個介面是函式式介面。
public class FunctionalInterfaceTeach {
&nb
Java——Lambda表示式、方法引用及內建函式式介面
1.Lambda表示式
面向物件的基礎上支援函數語言程式設計
1.1 約束：
介面有且僅有一個抽象方法，如果存在兩個抽象方法，則無法使用函數語言程式設計。
介面有且僅有一個抽象方法，且想要轉化為lambda表示式，加註解 @FunctionalInterface
Java 8 函式式介面 : Supplier、Function、Consumer、Predicate
函式式介面特點
1、三種方法
唯一的抽象方法
使用default定義普通方法（預設方法），通過物件呼叫。
使用static定義靜態方法，通過介面名呼叫。
2、一個新註解@FunctionInterface
如果某一個介面就是為了函式式介面而生的，使用註解@F
Java8新特性：Lambda表示式和函式式介面
Java8新特性：速度更快，程式碼更少，stream API，便於並行，最大化減少空指標異常：Optional
Lambda表示式
好處：
Lambda是一個匿名函式，可以把lambda表示式理解為一
Java 8 新增函式式介面到底是什麼？
Java 8 新增函式式介面到底是什麼？
從 Java 8 開始便出現了函式式介面（Functional Interface，以下簡稱FI）
定義為： 如果一個介面只有唯一的一個抽象介面，則稱之為函式式介面。為了保證介面符合 FI ，通常會在介面類上新增 @FunctionalI
Function介面 – Java8中java.util.function包下的函式式介面
作者: Mohamed Sanaulla 譯者: 李璟([email protected])
早先我寫了一篇《函式式介面》，探討了Java8中函式式介面的用法。如果你正在瀏覽Java8的API，你會發現java.util.function中 Function, Supplier
Effective Java 第三版——44. 優先使用標準的函式式介面
Tips
《Effective Java, Third Edition》一書英文版已經出版，這本書的第二版想必很多人都讀過，號稱Java四大名著之一，不過第二版2009年出版，到現在已經將近8年的時間，但隨著Java 6，7，8，甚至9的釋出，Java語言發生了深刻的變化。
在這裡第一時間翻譯成中文版。供大
深入學習java原始碼之lambda表示式與函式式介面
深入學習java原始碼之lambda表示式與函式式介面
@FunctionalInterface JDK中的函式式介面舉例 java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.ut