Java 函數(shù)式編程
一、Lambda表達式
1.1 函數(shù)式編程思想概述
在數(shù)學中，函數(shù)就是有輸入量、輸出量的一套計算方案，也就是“拿數(shù)據(jù)做操作”
面向對象思想強調“必須通過對象的形式來做事情”
函數(shù)式思想強調則金量忽略面向對象的復雜語句：“強調做什么，而不是以什么形式去做”
而我們要學習的Lambda表達式就是函數(shù)式思想的體現(xiàn)
1.2 體驗Lambda表達式
需求：啟動一個線程，在控制臺輸出一句話：多線程程序啟動了
方式1：
定義一個類MyRunnable接口，重寫run方法
創(chuàng)建MyRunnable類的對象
創(chuàng)建Thread類對象，把MyRunnable的對象作為構造參數(shù)傳遞
啟動線程
public class MyRunnable implements Runnable { @Override public void run() { System.out.println("多線程程序啟動了"); } }
MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start();
方式2：
在方式1的基礎上進行改進，使用匿名內部類的方式
new Thread(new Runnable() { @Override public void run() { System.out.println("多線程程序啟動了"); } }).start();
方式3：
Lambda表達式的方式改進
new Thread(() -> { System.out.println("多線程程序啟動了"); }).start();
1.3 Lambda表達式的標準格式
匿名內部類中重寫run()方法的代碼分析：
方法形式參數(shù)為空，說明調用方法時不需要傳遞參數(shù)
方法返回值類型為void，說明方法執(zhí)行沒有結果返回
方法體中的內容，是我們具體要做的事情
new Thread(new Runnable() { @Override public void run() { System.out.println("多線程程序啟動了"); } }).start();
Lambda表達式的代碼分析：
()：里面沒有內容，可以看成是方法形式參數(shù)為空
->：用箭頭指向后面要做的事情
{}：包含一段代碼，我們稱之為代碼塊，可以看成是方法體中的內容
new Thread(() -> {
System.out.println("多線程程序啟動了");
}).start();
組成Lambda表達式的三要素：形式參數(shù)、箭頭、代碼塊
Lambda表達式的格式：
格式：（形式參數(shù)）->{代碼塊}
形式參數(shù)：如果有多個參數(shù)，參數(shù)之間用逗號隔開；如果沒有參數(shù)，留空即可
->：由英文中畫線和大于符號組成，固定寫法。代表指向動作
代碼塊：是我們具體要做的事情，也就是以前我們寫的方法體內容
1.4 Lambda表達式的練習
Lambda表達式的使用前提
有一個接口
接口中有且僅有一個抽象方法
練習1：
定義一個接口(Eatable)，里面定義一個抽象方法：void eat();
定義一個測試類（EatableDemo）,在測試類中提供兩個方法：
一個方法是：useEatable(Eatable e)
一個方法是主方法，在主方法中調用useEatable方法
定義一個接口：
public interface Eatable { void eat(); }
方式一：傳統(tǒng)接口實現(xiàn)類
public class EatableImpl implements Eatable{ @Override public void eat() { System.out.println("一日三餐，必不可少"); } }
public class EatableDemo{ public static void main(String[] args) { Eatable eatable = new EatableImpl(); eatable.eat(); } private static void useEatable(Eatable eatable){ eatable.eat(); } }
方式2：匿名內部類
public class EatableDemo{ public static void main(String[] args) { useEatable(new Eatable() { @Override public void eat() { System.out.println("一日三餐，必不可少"); } }); } private static void useEatable(Eatable eatable){ eatable.eat(); } }
方式3：Lambda表達式
public class EatableDemo{ public static void main(String[] args) { useEatable(()->{ System.out.println("一日三餐，必不可少"); }); } private static void useEatable(Eatable eatable){ eatable.eat(); } }
運行結果均相同
練習2：
定義一個接口（Flyable），里面定義一個抽象方法：void fiy(String s)；
定義一個測試類（FlyableDemo）,在測試類中提供兩個方法
一個方法是：useFlyable(Flyable f)
一個方法是主方法，在主方法中調用useFlayable方法
public interface Flyable { void fly(String s); }
public class FlyableDemo { public static void main(String[] args) { useFlyable(new Flyable() { @Override public void fly(String s) { System.out.println(s); System.out.println("飛機可以起飛"); } }); System.out.println("--------------------"); useFlyable((String s)->{ System.out.println(s); System.out.println("飛機可以起飛"); }); } private static void useFlyable(Flyable flyable){ flyable.fly("風和日麗，晴空萬里"); } }
練習3：
定義一個接口（Addable），里面定義一個抽象方法：int add(int x,int y);
定義一個測試類（AddableDemo）,在測試類中提供兩個方法
一個方法是：useAddable(Addable a)
一個方法是主方法，在主方法中調用useAddable方法
public interface Addable { int add(int x,int y); }
public class AddableDemo { public static void main(String[] args) { useAddable(new Addable() { @Override public int add(int x, int y) { return x + y; } }); useAddable((int x,int y)->{ return x + y; }); } private static void useAddable(Addable addable) { int sum = addable.add(10, 20); System.out.println(sum); } }
1.5 Lambda表達式的省略模式
省略規(guī)則：
參數(shù)類型可以省略。如果有多個參數(shù)的情況下，不能只省略一個
如果參數(shù)有且僅有一個，那么小括號可以省略
如果代碼塊的語句只有一條，可以省略大括號和分號，甚至時return
public class LambdaDemo5 { public static void main(String[] args) { //參數(shù)類型可以省略 useAddable((x, y) -> { return x + y; }); System.out.println("------------------------"); //如果只有一個參數(shù)，小括號也可以省略 useFlyable(s -> { System.out.println(s); }); System.out.println("------------------------"); //如果代碼塊的語句只有一條，可以省略大括號和分號(有return時要把return也去掉) useFlyable(s -> System.out.println(s) ); useAddable((x,y)->x+y); } private static void useFlyable(Flyable flyable) { flyable.fly("風和日麗，晴空萬里"); } private static void useAddable(Addable addable) { int sum = addable.add(10, 20); System.out.println(sum); } }
接口類參考1.4
1.6 Lambda表達式的注意事項
注意事項：
使用Lambda必須要有接口，并且要求接口中有且僅有一個抽象的方法
必須有上下文環(huán)境，才能推導出Lambda對應的接口
根據(jù)局部變量的賦值得知Lambda對應的接口：Runnable r =() ->System.out.println(“Lambda表達式”);
根據(jù)調用方法的參數(shù)得知Lambda對應的接口：new Thread(()->System.out.println(“Lambda表達式”)).start();
public interface Inter { void show(); }
public class LambdaDemo6 { public static void main(String[] args) { useInter(()-> System.out.println("Lambda表達式") ); new Thread(new Runnable() { @Override public void run() { System.out.println("匿名內部類"); } }).start(); Runnable r = () -> System.out.println("Lambda表達式"); new Thread(r).start(); new Thread(()-> System.out.println("Lambda表達式") ).start(); } private static void useInter(Inter inter){ inter.show(); } }
1.7 Lambda表達式和匿名內部類的區(qū)別
所需類型不同：
匿名內部類：可以是接口，也可以是抽象類，還可以是具體類
Lambda表達式：只能是接口
使用限制不同：
如果接口中有且僅有一個抽象方法，可以使用Lambda表達式，也可以使用匿名內部類
如果接口中多于一個抽象方法，只能使用匿名內部類，而不能使用Lambda表達式
實現(xiàn)原理不同：
匿名內部類：編譯之后，產生一個單獨的.class字節(jié)碼文件
Lambda表達式：編譯之后，沒有一個單獨的.class字節(jié)碼文件，對應的字節(jié)碼會在運行的時候動態(tài)生成
二、接口組成更新
1.1 接口組成更新概述
接口的組成
常量：public static final
抽象方法：public abstract
默認方法（Java 8）
靜態(tài)方法（Java 8）
私有方法 （Java 8）
1.2 接口中默認方法
接口中默認方法得定義格式：
格式：public default 返回值類型 方法名（參數(shù)列表）{}
范例：public default void show3(){}
接口中默認方法的注意事項：
默認方法不是抽象方法，所以不強制被重寫。但是可以被重寫，重寫的時候去掉default關鍵字
public可以省略，default不能重寫
public interface MyInterface { void show1(); void show2(); default void show3(){ System.out.println("show3"); } }
public class MyInterfaceImplOne implements MyInterface{ @Override public void show1() { System.out.println("One show1"); } @Override public void show2() { System.out.println("One show2"); } }
public class MyInterfaceImplTwo implements MyInterface{ @Override public void show1() { System.out.println("Two show1"); } @Override public void show2() { System.out.println("Two show2"); } }
public class InterfaceDemo { public static void main(String[] args) { MyInterface myInterface = new MyInterfaceImplOne(); myInterface.show1(); myInterface.show2(); myInterface.show3(); System.out.println("------------------"); MyInterface myInterface2 = new MyInterfaceImplTwo(); myInterface2.show1(); myInterface2.show2(); myInterface2.show3(); } }
運行結果： One show1 One show2 show3 ------------------ Two show1 Two show2 show3
1.3 接口中靜態(tài)方法
接口中靜態(tài)方法的定義格式：
格式：public static 返回值類型 方法名（參數(shù)列表）{ }
范例：public static void show(){ }
接口中靜態(tài)方法的注意事項：
靜態(tài)方法只能通過接口名調用，不能通過實現(xiàn)類名或者對象名調用
public可以省略，static不能省略
public interface Inter { void show(); default void method() { System.out.println("Inter 中的默認方法執(zhí)行了"); } public static void test(){ System.out.println("Inter 中的靜態(tài)方法執(zhí)行了"); } }
public class InterImpl implements Inter{ @Override public void show() { System.out.println("show方法執(zhí)行了"); } }
public class InterDemo { public static void main(String[] args) { Inter inter = new InterImpl(); inter.show(); inter.method(); Inter.test(); } }
1.4 接口中私有方法
Java 9中新增了帶方法體的私有方法，這其實在Java 8中就埋下了伏筆：Java 8允許在接口中定義帶方法體的默認方法和靜態(tài)方法。這樣可能就會引發(fā)一個問題：當兩個默認方法或者靜態(tài)方法中包含一段相同的代碼實現(xiàn)時，程序必然考慮將這段實現(xiàn)代碼抽取成一個共性方法，而這個共性方法時不需要讓別人使用的，因此用私有給隱藏起來，這就是Java 9增加私有方法的必然性。
接口中私有方法的定義格式：
格式1：private 返回值類型方法名（參數(shù)列表）{ }
范例1：private void show(){ }
格式2：private static 返回值類型 方法名(參數(shù)列表){ }
范例2：private static void method(){ }
接口中私有方法的注意事項：
默認方法可以調用私有的靜態(tài)方法和非靜態(tài)方法
靜態(tài)方法只能調用私有的靜態(tài)方法
public interface Inter { default void show1(){ System.out.println("show1開始執(zhí)行"); method(); System.out.println("show1結束執(zhí)行"); } default void show2(){ System.out.println("show2開始執(zhí)行"); method(); System.out.println("show2結束執(zhí)行"); } static void method1(){ System.out.println("method1開始執(zhí)行"); method(); System.out.println("method1結束執(zhí)行"); } static void method2(){ System.out.println("method2開始執(zhí)行"); method(); System.out.println("method2結束執(zhí)行"); } static void method(){ System.out.println("初級工程師"); System.out.println("中級工程師"); System.out.println("高級工程師"); } }
public class InterImpl implements Inter{ } public class InterDemo { public static void main(String[] args) { Inter inter = new InterImpl(); inter.show1(); System.out.println("------------------------"); inter.show2(); System.out.println("------------------------"); Inter.method1(); System.out.println("------------------------"); Inter.method2(); } }
三、方法引用
1.1 體驗方法引用
通過方法引用來使用已經存在的方案
public interface Printable { void printString(String s); } public class PrintableDemo { public static void main(String[] args) { usePrintable(s-> System.out.println(s) ); usePrintable(System.out::println); } private static void usePrintable(Printable p){ p.printString("hello world"); } }
1.2 方法引用符
：：該符號為引用運算符，而它所在表達式被稱為方法引用符
Lambda表達式：usePrintable(s->System.out.println(s));
分析：拿到參數(shù)s之后通過Lambda表達式，傳遞給System.out.println方法去處理
方法引用：usePrintable(System.out::println);
? 分析：直接使用System.out中的println方法來取代Lambda，代碼更加的簡潔
推導與省略：
如果使用Lambda，那么根據(jù)“可推導就是可省略”的原則，無需指定參數(shù)類型，也無需指定的重載形式，它們都將被自動推導
如果使用方法引用，也同要可以根據(jù)上下文進行推導
方法引用是Lambda的孿生兄弟
public interface Printable { void printInt(int i); } public class PrintableDemo2 { public static void main(String[] args) { usePrintable(i -> System.out.println(i)); usePrintable(System.out::println); } private static void usePrintable(Printable printable){ printable.printInt(1); } }
1.3 Lambda表達式支持的方法引用
常見的引用方式：
引用類方法
引用對象的實例方法
引用類的實例方法
引用構造器
1.4 引用類方法
引用類方法，其實就是引用類的靜態(tài)方法
格式：類名：：靜態(tài)方法
范例：Integer::parseInt
Integer類的方法：public static int parsenInt(String s),將此String轉換為int類型數(shù)據(jù)
Lambda表達式被類方法替代的時候，它的形式參數(shù)全部傳遞給靜態(tài)方法作為參數(shù)
public interface Converter { int convert(String s); } public class ConverterDemo { public static void main(String[] args) { useConverter(s -> Integer.parseInt(s)); useConverter(Integer::parseInt); } private static void useConverter(Converter c) { int number = c.convert("666"); System.out.println(number); } }
1.5 引用對象的實例方法
引用對象的實例方法，其實就是引用類中的成員方法
格式：對象：：成員方法
范例：“HelloWorld"::toUpperCase
String 類中的方法：public String toUpperCase()將此String所有字符轉為大寫
Lambda表達式被對象的實例方法替代的時候，它的形式參數(shù)全部傳遞給該方法作為參數(shù)
public interface Printer { void printUpperCase(String s); }
public class PrintString { public void printUpper(String s){ String result = s.toUpperCase(); System.out.println(result); } }
public class PrinterDemo { public static void main(String[] args) { usePrinter(s -> System.out.println(s.toUpperCase())); PrintString printString = new PrintString(); usePrinter(printString::printUpper); } private static void usePrinter(Printer printer) { printer.printUpperCase("HelloWorld"); } }
1.6 引用類的實例方法
引用類的實例方法，其實就是引用類中的成員方法
格式：類名：：成員方法
范例：String::substring
String類中的方法：public String subString(int beginIndex,int endIndex)從beginIndex開始到endIndex結束，截取字符串。返回一個子串，字串的長度為endIndex-beginIndex
Lambda表達式被類的實例方法替代的時候，第一個參數(shù)作為調用者，后面的參數(shù)全部傳遞給該方法作為參數(shù)
public interface MyString { String mySubString(String s, int x, int y); }
public class MyStringDemo { public static void main(String[] args) { useMyString((s, x, y) -> s.substring(x, y)); useMyString(String::substring); } private static void useMyString(MyString myString){ String s = myString.mySubString("HelloWorld", 5, 10); System.out.println(s); } }
1.7 引用構造器
引用構造器，其實就是引用構造方法
格式：類名：：new
范例：Student：：new
Lambda表達式被構造器代替的時候，它的形式參數(shù)全部傳遞給構造器作為參數(shù)
public class Student { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } }
public interface StudentBuilder { Student build(String name,int age); }
public class StudentDemo { public static void main(String[] args) { useStudentBuilder((name, age) -> new Student(name,age)); useStudentBuilder(Student::new); } private static void useStudentBuilder(StudentBuilder studentBuilder){ Student student = studentBuilder.build("xuanxuan", 22); System.out.println(student.getName()+","+student.getAge()); } }
四、函數(shù)式接口
1.1 函數(shù)接口概述
函數(shù)式接口：有且僅有一個抽象方法的接口
Java中的函數(shù)式編程體現(xiàn)就是Lambda表達式，所以函數(shù)式接口就是可以使用于Lambda使用的接口
只有確保接口中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導
如何檢測一個接口是不是函數(shù)式接口呢？
@FunctionalInterface
放在接口定義的上方：如果接口是函數(shù)接口，編譯通過；如果不是，編譯失敗
注意：
我們自己定義函數(shù)式接口的時候，@FunctionalInterface是可選的，就算我們不寫這個注解，只要保證滿足函數(shù)式接口定義的條件，也照樣是函數(shù)式接口。但是，建議加上注解。
@FunctionalInterface public interface MyInterface { void show(); }
public class MyInterfaceDemo { public static void main(String[] args) { MyInterface myInterface = ()-> System.out.println("函數(shù)式接口"); myInterface.show(); } }
1.2 函數(shù)式接口作為方法的參數(shù)
如果方法的參數(shù)是一個函數(shù)式接口，我們可以使用Lambda表達式作為參數(shù)傳遞
startThread(() -> System.out.println(Thread.currentThread().getName() + "線程啟動了"));
public class RunnableDemo { public static void main(String[] args) { startThread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + "線程啟動了"); } }); startThread(() -> System.out.println(Thread.currentThread().getName() + "線程啟動了")); startThread(()->{ System.out.println(Thread.currentThread().getName() + "線程啟動了"); }); } private static void startThread(Runnable runnable) { new Thread(runnable).start(); } }
1.3 函數(shù)式接口作為方法的返回值
如果方法的返回值是一個函數(shù)式接口，我們可以使用Lambda表達式作為結果返回
private static Comparator<String> getComparator() {
return (s1,s2) -> s1.length() - s2.length();
}
public class ComparatorDemo { public static void main(String[] args) { ArrayList<String> arrayList = new ArrayList<String>(); arrayList.add("ccc"); arrayList.add("aa"); arrayList.add("dddd"); arrayList.add("b"); System.out.println("排序前" + arrayList); Collections.sort(arrayList); System.out.println("排序后" + arrayList); Collections.sort(arrayList, getComparator()); System.out.println("使用定義比較器排序方法后：" + arrayList); } private static Comparator<String> getComparator() { // return new Comparator<String>() { // @Override // public int compare(String s1, String s2) { // return s1.length() - s2.length(); // } // }; return (s1,s2) -> s1.length() - s2.length(); } }
1.4 常用的函數(shù)式接口
Java 8 在java.util.function包下預定了大量的函數(shù)式接口供我們使用，常用如下：
Supplier接口
Consumer接口
Predicate接口
Function接口
1.5 Supplier接口
Supplier接口
T get()：獲得結果
該方法不需要參數(shù)，它會按照某種實現(xiàn)邏輯（由Lambda表達式實現(xiàn))返回一個數(shù)據(jù)
Supplier 接口也被稱為生產型接口，如果我們指定了接口的泛型是什么類型，那么接口中的get方法就會生產什么類型的數(shù)據(jù)供我們使用
public class SupplierDemo { public static void main(String[] args) { String s = getString(() -> "xuanxuan"); System.out.println(s); Integer i = getInteger(() -> 666); System.out.println(i); } public static String getString(Supplier<String> supplier) { return supplier.get(); } public static Integer getInteger(Supplier<Integer> supplier) { return supplier.get(); } }
練習：獲取最大值
public class SupplierDemo { public static void main(String[] args) { int[] arr = new int[]{17, 28, 49, 21, 32, 66}; int maxNumber = getMax(() -> { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (max < arr[i]) { max = arr[i]; } } return max; }); System.out.println("數(shù)組中的最大值是：" + maxNumber); } private static int getMax(Supplier<Integer> supplier) { return supplier.get(); } }
1.6 Consumer接口
Consumer：包含兩個方法
void accept(T t)：對給定的參數(shù)執(zhí)行此操作
default Consumer andThen(Consumer after)：返回一個組合的Consumer,依次執(zhí)行此操作，然后執(zhí)行after操作
Consumer 接口也被稱為消費型接口，它消費的數(shù)據(jù)類型由泛型指定
public class ConsumerDemo { public static void main(String[] args) { operatorString("abc", s -> System.out.println(s)); operatorString("abc", System.out::println); operatorString("abc", s -> System.out.println(new StringBuilder(s).reverse().toString())); System.out.println("----------------------------------"); operatorString("abc", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString())); } private static void operatorString(String name, Consumer<String> consumer) { consumer.accept(name); } private static void operatorString(String name, Consumer<String> consumer1, Consumer<String> consumer2) { // consumer1.accept(name); // consumer2.accept(name); consumer1.andThen(consumer2).accept(name); } }
練習：
字符串數(shù)組中又多條信息，按照：“姓名：name,年齡：age"的格式將信息打印出來
public class ConsumerDemo { public static void main(String[] args) { String[] arr = new String[]{"abc,30", "cbd,35", "dna,33"}; printInfo(arr, s -> System.out.print("姓名：" + s.split(",")[0] + ","), s -> System.out.println("年齡：" + Integer.parseInt(s.split(",")[1]))); } private static void printInfo(String[] arr, Consumer<String> consumer1, Consumer<String> consumer2) { for (String s : arr) { consumer1.andThen(consumer2).accept(s); } } }
1.7 Predicate接口
常用方法：
方法 說明
boolean test(T t) 對給定的參數(shù)進行判斷（判斷邏輯由Lambda表達式實現(xiàn)),返回一個布爾值
default Predicate negate() 返回一個邏輯的否定，對應邏輯非
default Predicate and (Predicate other) 返回一個組合判斷，對應短路與
default Predicate or (Predicate other) 返回一個組合判斷，對應短路或
練習：判斷給定的字符串是否滿足要求
public class PredicateDemo { public static void main(String[] args) { boolean b1 = checkString("hello", s -> s.length() > 5); System.out.println(b1); boolean b2 = checkString("helloworld", s -> s.length() > 8); System.out.println(b2); boolean b3 = checkString("hello", s -> s.length() > 5, s -> s.length() > 8); System.out.println(b3); boolean b4 = checkString("helloworld", s -> s.length() > 5, s -> s.length() > 8); System.out.println(b4); } private static boolean checkString(String s, Predicate<String> predicate) { return predicate.test(s); } private static boolean checkString(String s, Predicate<String> predicate, Predicate<String> predicate2) { // return predicate.and(predicate2).test(s); return predicate.or(predicate2).test(s); } }
練習2：
String[] strArray ={“孫悟空，30”,“唐僧，36”，“沙僧，34”，“豬八戒，32”，“白骨精，5000”}
字符串數(shù)組中有多條信息，請通過Predicate接口的拼裝將符合要求的字符串篩選到集合ArrayLitst中，并遍歷ArrayLitst集合
同時滿足如下要求：name長度大于2，age大于33
public class PredicateDemo3 { public static void main(String[] args) { String[] strArray = new String[]{"孫悟空，30", "唐僧，36", "沙僧，34", "豬八戒，32", "白骨精，5000"}; ArrayList<String> arrayList = myFilter(strArray, s -> s.split("，")[0].length() > 2, s -> Integer.parseInt(s.split("，")[1]) > 33); System.out.println("name長度大于2，age大于33有："); for (String s : arrayList) { System.out.print("name：" + s.split("，")[0] + "，"); System.out.println("age：" + Integer.parseInt(s.split("，")[1])); } } private static ArrayList<String> myFilter(String[] strArray, Predicate<String> predicate1, Predicate<String> predicate2) { ArrayList<String> arrayList = new ArrayList<String>(); for (String s : strArray) { if (predicate1.and(predicate2).test(s)) { arrayList.add(s); } } return arrayList; } }
1.8 Function接口
Function<T,R>兩個常用方法：
方法 說明
R apply(T t) 將此函數(shù)應用于給定的參數(shù)。
default Function<T,V> andThen(Function after) 返回一個組合函數(shù)，首先將該函數(shù)應用于其輸入，然后將 after函數(shù)應用于結果。
Function<T,R>接口通常用于對參數(shù)進行處理，轉換（處理邏輯由Lambda表達式實現(xiàn)）然后返回一個新的值
練習：
public class FunctionDemo { public static void main(String[] args) { convert("100", s -> Integer.parseInt(s)); convert("100", Integer::parseInt); convert(100, i -> String.valueOf(100 + i)); convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566)); } //定義一個方法，把一個int類型的數(shù)據(jù)加上一個整數(shù)之后，轉為字符串在控制臺輸出 private static void convert(String s, Function<String, Integer> function) { Integer i = function.apply(s); System.out.println(i); } //定義一個方法，把一個int類型的數(shù)據(jù)加上一個整數(shù)之后，轉為字符串在控制臺輸出 private static void convert(int i, Function<Integer, String> function) { String s = function.apply(i); System.out.println(s); } //定義一個方法，把一個字符串轉換為int類型，把int類型的數(shù)據(jù)加上一個整數(shù)之后，轉為字符串在控制臺輸出 private static void convert(String s, Function<String, Integer> function1, Function<Integer, String> function2) { String ss = function2.apply(function1.apply(s)); System.out.println(ss); } }
練習2：提取String中的年齡加70歲，并以int型輸出
public class FunctionDemo { public static void main(String[] args) { String s = "孫悟空，30"; convert(s, s1 -> s1.split("，")[1], s1 -> Integer.parseInt(s1) + 70); } private static void convert(String s, Function<String, String> function1, Function<String, Integer> function2) { Integer i = function2.apply(function1.apply(s)); System.out.println(i); } }
五、Stream流
1.1 體驗Stream流
需求：按照下面的要求完成集合的創(chuàng)建和遍歷
創(chuàng)建一個集合，存儲多個字符串元素
把集合中所有以“張”開頭的元素存儲到一個新的集合
再把長度為3的元素存儲到一個新集合
最后遍歷上一步得到的集合
使用Stream流的方式完成過濾操作：
直接閱讀代碼的字面意思即可完美展示無關邏輯方式的語義：生成流、過濾姓氏、過濾長度為3、逐一打印
Stream流把真正的函數(shù)式編程風格引入到java中
list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("張飛"); list.add("張三豐"); list.add("張三"); list.add("李四"); list.add("孫悟空"); list.add("張一飛"); ArrayList<String> zhangList = new ArrayList<String>(); for (String s : list) { if (s.startsWith("張")) { zhangList.add(s); } } ArrayList<String> treeList = new ArrayList<String>(); for (String s : zhangList) { if (s.length() == 3) { treeList.add(s); } } for (String s : treeList) { System.out.println(s); } System.out.println("-------------------------------"); //Stream流改進 list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s)); } }
1.2 Stream流的生成方式
Stream流的使用
生成流：通過數(shù)據(jù)源（集合、數(shù)組等）生成流
list.stream();
中間操作：一個流后面可以跟隨零個或者多個中間操作，其目的主要是打開流，做出某種程度的數(shù)據(jù)過濾/映射，然后返回一個新的流，交給下一個操作使用
filter()
終結操作：一個流只能有一個終結操作，當這個操作執(zhí)行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作
forEach()
Stream流的常見生成方式
Collection體系的集合可以使用默認方法stream()生成流
default Stream<E> stream()
Map體系的集合間接的生成流
數(shù)組可以通過Stream接口的靜態(tài)方法of(T…values)生成流
public class StreamDemo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); Stream<String> listStream = list.stream(); Set<String> set = new HashSet<String>(); Stream<String> setStream = set.stream(); Map<String, Integer> map = new HashMap<String, Integer>(); Stream<String> keyStream = map.keySet().stream(); Stream<Integer> valueStream = map.values().stream(); Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream(); String[] strArray = {"hello", "world", "java"}; Stream<String> strArrayStream = Stream.of(strArray); Stream<String> strArrayStream2 = Stream.of("hello", "world", "java"); Stream<Integer> strArrayStream3 = Stream.of(10, 20, 30); } }
1.3 Stream流的常見中間操作方法
Stream filter(Predicate predicate)：用于對流中的數(shù)據(jù)進行過濾
Predicate接口中的方法：boolean test(T t):對給定的參數(shù)進行判斷，返回一個布爾值
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("張飛"); list.add("張三豐"); list.add("張三"); list.add("李四"); list.add("孫悟空"); list.add("張一飛"); list.stream().filter(s -> s.startsWith("張")).forEach(System.out::println); System.out.println("----------------------"); list.stream().filter(s -> s.length() == 3).forEach(System.out::println); System.out.println("----------------------"); list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length() == 3).forEach(System.out::println); } }
Stream limit(long maxSize)：返回此流中的元素組成的流，截取前指定參數(shù)個數(shù)的數(shù)據(jù)
Stream skip(long n)：跳過指定參數(shù)個數(shù)的數(shù)據(jù)，返回由該流的剩余元素組成的流
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("張飛"); list.add("張三豐"); list.add("張三"); list.add("李四"); list.add("孫悟空"); list.add("張一飛"); //取前三個數(shù)據(jù)在控制臺輸出 list.stream().limit(3).forEach(System.out::println); System.out.println("-----------------------------"); //跳過2個元素，把剩下的元素在控制臺上輸出 list.stream().skip(2).forEach(System.out::println); System.out.println("-----------------------------"); //跳過2個元素并將剩下元素的前兩個元素在控制臺上輸出 list.stream().skip(2).limit(2).forEach(System.out::println); } }
Stream Stream concat(Stream a,Stream b)：合并a和b兩個流為一個流
Stream distinct：返回由該流的不同元素（根據(jù)Objectequals(Object)）組成的流
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("張飛"); list.add("張三豐"); list.add("張三"); list.add("李四"); list.add("孫悟空"); list.add("張一飛"); //需求1：取前4個數(shù)據(jù)組成一個流 Stream<String> limitStream = list.stream().limit(4); //需求2：跳過2個數(shù)據(jù)組成一個流 Stream<String> skipStream = list.stream().skip(2); //需求3：合并需求1和需求2得到的流，并把結果在控制臺輸出 // Stream.concat(limitStream,skipStream).forEach(System.out::println); //需求4：合并需求1和需求2得到的流，并把結果在控制臺輸出，要求字符串元素不能重復 Stream.concat(limitStream,skipStream).distinct().forEach(System.out::println); } }
Stream sorted()：返回由此流的元素組成的流，根據(jù)自然順序排序
Stream sorted(Comparator comparator)：返回由該流的元素組成的流，根據(jù)提供的Comparator進行排序
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("zhangfei"); list.add("zhangsanfeng"); list.add("zhangsan"); list.add("lisi"); list.add("sunwukong"); list.add("zhangyifei"); //需求1：按照字母順序把數(shù)據(jù)在控制臺輸出 list.stream().sorted().forEach(System.out::println); //需求2：按照字符串長度把數(shù)據(jù)在控制臺輸出 list.stream().sorted((s1, s2) -> { int num = s1.length() - s2.length(); int num2 = num == 0 ? s1.compareTo(s2) : num; return num2; }).forEach(System.out::println); } }
Stream map(Function mapper)：返回由給定函數(shù)應用于此流的元素的結果組成的流（Function接口中的方法 R apply(T t)）
IntStream mapToInt(ToIntFunction mapper)：返回一個IntStream其中包含將給定函數(shù)應用于此流的元素的結果
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("10"); list.add("20"); list.add("30"); list.add("40"); list.add("50"); // list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println); list.stream().map(Integer::parseInt).forEach(System.out::println); list.stream().mapToInt(Integer::parseInt).forEach(System.out::println); int result = list.stream().mapToInt(Integer::parseInt).sum(); System.out.println(result); } }
1.4 Stream流的常見終結操作方法
void forEach(Consumer action)：對此流的每個元素執(zhí)行操作（Consumer接口中的方法 void accept(T t)：對給定的參數(shù)執(zhí)行此操作）
long count()：返回此流中的元素數(shù)
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("張飛"); list.add("張三豐"); list.add("張三"); list.add("李四"); list.add("孫悟空"); list.add("張一飛"); //需求1：把集合中的元素在控制臺輸出 list.stream().forEach(System.out::println); //需求2：統(tǒng)計集合中有幾個姓張的元素并在控制臺輸出 list.stream().filter(s -> s.startsWith("張")).forEach(System.out::println); } }
1.5 Stream流的練習
現(xiàn)在又兩個ArrayList集合，分別存儲6名男演員和6名女演員名稱，要求完成如下操作
男演員只要名字為3個字的前三人
女演員只要姓林的，并且不要第一個
把過濾后的男演員姓名和女演員姓名合并到一起
把上一步操作后的元素作為構造方法的參數(shù)創(chuàng)建演員對象，遍歷數(shù)據(jù)（演員類Actor已經提供，里面有一個成員變量，一個帶參構造方法，以及成員變量對應的get/set方法）
public class StreamDemo { public static void main(String[] args) { ArrayList<String> manList = new ArrayList<String>(); manList.add("周潤發(fā)"); manList.add("成龍"); manList.add("劉德華"); manList.add("吳京"); manList.add("周星馳"); manList.add("李連杰"); ArrayList<String> womanList = new ArrayList<String>(); womanList.add("林心如"); womanList.add("張曼玉"); womanList.add("林青霞"); womanList.add("柳巖"); womanList.add("林志玲"); womanList.add("王祖賢"); //男演員只要名字為3個字的前三人 Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3); //女演員只要姓林的，并且不要第一個 Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1); //把過濾后的男演員姓名和女演員姓名合并到一起 Stream<String> stream = Stream.concat(manStream, womanStream); //把上一步操作后的元素作為構造方法的參數(shù)創(chuàng)建演員對象，遍歷數(shù)據(jù) stream.map(Actor::new).forEach(p -> System.out.println(p.getName())); System.out.println("------------------------------------"); //改進 Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3), womanList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).forEach(p -> System.out.println(p.getName())); } }
1.6 Stream流的收集操作
對數(shù)據(jù)使用Stream流的方式操作完畢后，如何把流中的數(shù)據(jù)收集到集合中？
Stream流的手機方法
R collect(Collector collector)
但是這個收集方法的參數(shù)是一個Collector接口
工具類Collectors提供了具體的收集方式
public static Collector toList()：把元素收到List集合中
public static Collector toSet()：把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中
public class StreamDemo { public static void main(String[] args) { ArrayList<String> list = new ArrayList<String>(); list.add("張飛"); list.add("張三豐"); list.add("張三"); list.add("李四"); list.add("孫悟空"); list.add("張一飛"); //需求1：得到名字為3個字的流 Stream<String> listStream = list.stream().filter(s -> s.length() == 3); //需求2：把使用Stream流操作完畢的數(shù)據(jù)收集到List集合中并遍歷 List<String> collect = listStream.collect(Collectors.toList()); for (String s : collect) { System.out.println(s); } Set<Integer> set = new HashSet<Integer>(); set.add(10); set.add(20); set.add(30); set.add(33); set.add(35); //需求3：得到年齡大于25的流 Stream<Integer> integerStream = set.stream().filter(age -> age > 25); //需求4：把使用Stream流操作完畢的數(shù)據(jù)收集到Set集合中并遍歷 Set<Integer> collect2 = integerStream.collect(Collectors.toSet()); for (Integer i : collect2) { System.out.println(i); } String[] strArray = {"張飛，28", "張三豐，33", "張三，26", "李四，44"}; //需求5：得到字符串年齡中數(shù)據(jù)大于28的流 Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split("，")[1]) > 28); //需求6：把使用Stream流操作完畢的數(shù)據(jù)收集到Map集合中并遍歷，字符串的姓名作為鍵，年齡作為值 Map<String, Integer> map = stringStream.collect(Collectors.toMap(s -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1]))); Set<String> keySet = map.keySet(); for (String key : keySet) { Integer value = map.get(key); System.out.println(key + "，" + value); } } }
浙公網(wǎng)安備 33010602011771號