Java?函數(shù)式編程梳理

更新時(shí)間：2022年07月28日 09:51:09 作者：xuanxuan愛吃肉

這篇文章主要介紹了Java?函數(shù)式編程梳理，文章通過Lambda表達(dá)式展開詳細(xì)的內(nèi)容介紹，具有一定參考價(jià)值，需要的小伙伴可以參考一下

一、Lambda表達(dá)式

1.1 函數(shù)式編程思想概述

在數(shù)學(xué)中，函數(shù)就是有輸入量、輸出量的一套計(jì)算方案，也就是“拿數(shù)據(jù)做操作”

面向?qū)ο笏枷霃?qiáng)調(diào)“必須通過對象的形式來做事情”

函數(shù)式思想強(qiáng)調(diào)則金量忽略面向?qū)ο蟮膹?fù)雜語句：“強(qiáng)調(diào)做什么，而不是以什么形式去做”

而我們要學(xué)習(xí)的Lambda表達(dá)式就是函數(shù)式思想的體現(xiàn)

1.2 體驗(yàn)Lambda表達(dá)式

需求：啟動(dòng)一個(gè)線程，在控制臺輸出一句話：多線程程序啟動(dòng)了

方式1：

定義一個(gè)類MyRunnable接口，重寫run方法
創(chuàng)建MyRunnable類的對象
創(chuàng)建Thread類對象，把MyRunnable的對象作為構(gòu)造參數(shù)傳遞
啟動(dòng)線程

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("多線程程序啟動(dòng)了");
    }
}

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

方式2：

在方式1的基礎(chǔ)上進(jìn)行改進(jìn)，使用匿名內(nèi)部類的方式

      new Thread(new Runnable() {
           @Override
            public void run() {
                System.out.println("多線程程序啟動(dòng)了");
            }
        }).start();

方式3：

Lambda表達(dá)式的方式改進(jìn)：

        new Thread(() -> {
            System.out.println("多線程程序啟動(dòng)了");
        }).start();

1.3 Lambda表達(dá)式的標(biāo)準(zhǔn)格式

匿名內(nèi)部類中重寫run()方法的代碼分析：

方法形式參數(shù)為空，說明調(diào)用方法時(shí)不需要傳遞參數(shù)
方法返回值類型為void，說明方法執(zhí)行沒有結(jié)果返回
方法體中的內(nèi)容，是我們具體要做的事情

      new Thread(new Runnable() {
           @Override
            public void run() {
                System.out.println("多線程程序啟動(dòng)了");
            }
        }).start();

Lambda表達(dá)式的代碼分析：

()：里面沒有內(nèi)容，可以看成是方法形式參數(shù)為空
->：用箭頭指向后面要做的事情
{}：包含一段代碼，我們稱之為代碼塊，可以看成是方法體中的內(nèi)容

        new Thread(() -> {
            System.out.println("多線程程序啟動(dòng)了");
        }).start();

組成Lambda表達(dá)式的三要素：形式參數(shù)、箭頭、代碼塊

Lambda表達(dá)式的格式：

格式：（形式參數(shù)）->{代碼塊}
形式參數(shù)：如果有多個(gè)參數(shù)，參數(shù)之間用逗號隔開；如果沒有參數(shù)，留空即可
->：由英文中畫線和大于符號組成，固定寫法。代表指向動(dòng)作
代碼塊：是我們具體要做的事情，也就是以前我們寫的方法體內(nèi)容

1.4 Lambda表達(dá)式的練習(xí)

Lambda表達(dá)式的使用前提

有一個(gè)接口
接口中有且僅有一個(gè)抽象方法

練習(xí)1：

定義一個(gè)接口(Eatable)，里面定義一個(gè)抽象方法：void eat();
定義一個(gè)測試類（EatableDemo）,在測試類中提供兩個(gè)方法：
- 一個(gè)方法是：useEatable(Eatable e)
- 一個(gè)方法是主方法，在主方法中調(diào)用useEatable方法

定義一個(gè)接口：

public interface Eatable {
    void eat();
}

方式一：傳統(tǒng)接口實(shí)現(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：匿名內(nèi)部類

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表達(dá)式

public class EatableDemo{
    public static void main(String[] args) {
        useEatable(()->{
            System.out.println("一日三餐，必不可少");
        });
    }
    private static void useEatable(Eatable eatable){
        eatable.eat();
    }
}

運(yùn)行結(jié)果均相同

練習(xí)2：

定義一個(gè)接口（Flyable），里面定義一個(gè)抽象方法：void fiy(String s)；
定義一個(gè)測試類（FlyableDemo）,在測試類中提供兩個(gè)方法
- 一個(gè)方法是：useFlyable(Flyable f)
- 一個(gè)方法是主方法，在主方法中調(diào)用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("飛機(jī)可以起飛");
            }
        });
        System.out.println("--------------------");
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println("飛機(jī)可以起飛");
        });
    }
    private static void useFlyable(Flyable flyable){
        flyable.fly("風(fēng)和日麗，晴空萬里");
    }
}

練習(xí)3：

定義一個(gè)接口（Addable），里面定義一個(gè)抽象方法：int add(int x,int y);
定義一個(gè)測試類（AddableDemo）,在測試類中提供兩個(gè)方法
- 一個(gè)方法是：useAddable(Addable a)
- 一個(gè)方法是主方法，在主方法中調(diào)用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表達(dá)式的省略模式

省略規(guī)則：

參數(shù)類型可以省略。如果有多個(gè)參數(shù)的情況下，不能只省略一個(gè)
如果參數(shù)有且僅有一個(gè)，那么小括號可以省略
如果代碼塊的語句只有一條，可以省略大括號和分號，甚至?xí)rreturn

public class LambdaDemo5 {
    public static void main(String[] args) {
        //參數(shù)類型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        System.out.println("------------------------");
        //如果只有一個(gè)參數(shù)，小括號也可以省略
        useFlyable(s -> {
            System.out.println(s);
        });
        System.out.println("------------------------");
        //如果代碼塊的語句只有一條，可以省略大括號和分號(有return時(shí)要把return也去掉)
        useFlyable(s ->
            System.out.println(s)
        );
        useAddable((x,y)->x+y);
    }
    private static void useFlyable(Flyable flyable) {
        flyable.fly("風(fēng)和日麗，晴空萬里");
    }
    private static void useAddable(Addable addable) {
        int sum = addable.add(10, 20);
        System.out.println(sum);
    }
}

接口類參考1.4

1.6 Lambda表達(dá)式的注意事項(xiàng)

注意事項(xiàng)：

使用Lambda必須要有接口，并且要求接口中有且僅有一個(gè)抽象的方法
必須有上下文環(huán)境，才能推導(dǎo)出Lambda對應(yīng)的接口
- 根據(jù)局部變量的賦值得知Lambda對應(yīng)的接口：Runnable r =() ->System.out.println(“Lambda表達(dá)式”);
- 根據(jù)調(diào)用方法的參數(shù)得知Lambda對應(yīng)的接口：new Thread(()->System.out.println(“Lambda表達(dá)式”)).start();

public interface Inter {
    void show();
}

public class LambdaDemo6 {
    public static void main(String[] args) {
        useInter(()->
                System.out.println("Lambda表達(dá)式")
        );
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名內(nèi)部類");
            }
        }).start();
        Runnable r = () -> System.out.println("Lambda表達(dá)式");
        new Thread(r).start();

        new Thread(()->
            System.out.println("Lambda表達(dá)式")
        ).start();
    }
    private static void useInter(Inter inter){
        inter.show();
    }
}

1.7 Lambda表達(dá)式和匿名內(nèi)部類的區(qū)別

所需類型不同：

匿名內(nèi)部類：可以是接口，也可以是抽象類，還可以是具體類
Lambda表達(dá)式：只能是接口

使用限制不同：

如果接口中有且僅有一個(gè)抽象方法，可以使用Lambda表達(dá)式，也可以使用匿名內(nèi)部類
如果接口中多于一個(gè)抽象方法，只能使用匿名內(nèi)部類，而不能使用Lambda表達(dá)式

實(shí)現(xiàn)原理不同：

匿名內(nèi)部類：編譯之后，產(chǎn)生一個(gè)單獨(dú)的.class字節(jié)碼文件
Lambda表達(dá)式：編譯之后，沒有一個(gè)單獨(dú)的.class字節(jié)碼文件，對應(yīng)的字節(jié)碼會(huì)在運(yùn)行的時(shí)候動(dòng)態(tài)生成

二、接口組成更新

1.1 接口組成更新概述

接口的組成:

常量：public static final
抽象方法：public abstract
默認(rèn)方法（Java 8）
靜態(tài)方法（Java 8）
私有方法（Java 8）

1.2 接口中默認(rèn)方法

接口中默認(rèn)方法得定義格式：

格式：public default 返回值類型方法名（參數(shù)列表）{}
范例：public default void show3(){}

接口中默認(rèn)方法的注意事項(xiàng)：

默認(rèn)方法不是抽象方法，所以不強(qiáng)制被重寫。但是可以被重寫，重寫的時(shí)候去掉default關(guān)鍵字
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();
    }
}

運(yùn)行結(jié)果：

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)方法的注意事項(xiàng)：

靜態(tài)方法只能通過接口名調(diào)用，不能通過實(shí)現(xiàn)類名或者對象名調(diào)用
public可以省略，static不能省略

public interface Inter {
    void show();
    default void method() {
        System.out.println("Inter 中的默認(rèn)方法執(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中新增了帶方法體的私有方法，這其實(shí)在Java 8中就埋下了伏筆：Java 8允許在接口中定義帶方法體的默認(rèn)方法和靜態(tài)方法。這樣可能就會(huì)引發(fā)一個(gè)問題：當(dāng)兩個(gè)默認(rèn)方法或者靜態(tài)方法中包含一段相同的代碼實(shí)現(xiàn)時(shí)，程序必然考慮將這段實(shí)現(xiàn)代碼抽取成一個(gè)共性方法，而這個(gè)共性方法時(shí)不需要讓別人使用的，因此用私有給隱藏起來，這就是Java 9增加私有方法的必然性。

接口中私有方法的定義格式：

格式1：private 返回值類型方法名（參數(shù)列表）{ }
范例1：private void show(){ }
格式2：private static 返回值類型方法名(參數(shù)列表){ }
范例2：private static void method(){ }

接口中私有方法的注意事項(xiàng)：

默認(rèn)方法可以調(diào)用私有的靜態(tài)方法和非靜態(tài)方法
靜態(tài)方法只能調(diào)用私有的靜態(tài)方法

public interface Inter {
    default void show1(){
        System.out.println("show1開始執(zhí)行");
        method();
        System.out.println("show1結(jié)束執(zhí)行");
    }
    default void show2(){
        System.out.println("show2開始執(zhí)行");
        method();
        System.out.println("show2結(jié)束執(zhí)行");
    }
    static void method1(){
        System.out.println("method1開始執(zhí)行");
        method();
        System.out.println("method1結(jié)束執(zhí)行");
    }
    static void method2(){
        System.out.println("method2開始執(zhí)行");
        method();
        System.out.println("method2結(jié)束執(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 體驗(yàn)方法引用

通過方法引用來使用已經(jīng)存在的方案

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 方法引用符

：：該符號為引用運(yùn)算符，而它所在表達(dá)式被稱為方法引用符
Lambda表達(dá)式：usePrintable(s->System.out.println(s));

分析：拿到參數(shù)s之后通過Lambda表達(dá)式，傳遞給System.out.println方法去處理

方法引用：usePrintable(System.out::println);

? 分析：直接使用System.out中的println方法來取代Lambda，代碼更加的簡潔

推導(dǎo)與省略：

如果使用Lambda，那么根據(jù)“可推導(dǎo)就是可省略”的原則，無需指定參數(shù)類型，也無需指定的重載形式，它們都將被自動(dòng)推導(dǎo)
如果使用方法引用，也同要可以根據(jù)上下文進(jìn)行推導(dǎo)
方法引用是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表達(dá)式支持的方法引用

常見的引用方式：

引用類方法
引用對象的實(shí)例方法
引用類的實(shí)例方法
引用構(gòu)造器

1.4 引用類方法

引用類方法，其實(shí)就是引用類的靜態(tài)方法

格式：類名：：靜態(tài)方法
范例：Integer::parseInt
- Integer類的方法：public static int parsenInt(String s),將此String轉(zhuǎn)換為int類型數(shù)據(jù)
- Lambda表達(dá)式被類方法替代的時(shí)候，它的形式參數(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 引用對象的實(shí)例方法

引用對象的實(shí)例方法，其實(shí)就是引用類中的成員方法

格式：對象：：成員方法
范例：“HelloWorld"::toUpperCase
String 類中的方法：public String toUpperCase()將此String所有字符轉(zhuǎn)為大寫
Lambda表達(dá)式被對象的實(shí)例方法替代的時(shí)候，它的形式參數(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 引用類的實(shí)例方法

引用類的實(shí)例方法，其實(shí)就是引用類中的成員方法

格式：類名：：成員方法
范例：String::substring
String類中的方法：public String subString(int beginIndex,int endIndex)從beginIndex開始到endIndex結(jié)束，截取字符串。返回一個(gè)子串，字串的長度為endIndex-beginIndex
Lambda表達(dá)式被類的實(shí)例方法替代的時(shí)候，第一個(gè)參數(shù)作為調(diào)用者，后面的參數(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 引用構(gòu)造器

引用構(gòu)造器，其實(shí)就是引用構(gòu)造方法

格式：類名：：new
范例：Student：：new
Lambda表達(dá)式被構(gòu)造器代替的時(shí)候，它的形式參數(shù)全部傳遞給構(gòu)造器作為參數(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ù)式接口：有且僅有一個(gè)抽象方法的接口

Java中的函數(shù)式編程體現(xiàn)就是Lambda表達(dá)式，所以函數(shù)式接口就是可以使用于Lambda使用的接口

只有確保接口中有且僅有一個(gè)抽象方法，Java中的Lambda才能順利地進(jìn)行推導(dǎo)

如何檢測一個(gè)接口是不是函數(shù)式接口呢？

@FunctionalInterface
放在接口定義的上方：如果接口是函數(shù)接口，編譯通過；如果不是，編譯失敗

注意：

我們自己定義函數(shù)式接口的時(shí)候，@FunctionalInterface是可選的，就算我們不寫這個(gè)注解，只要保證滿足函數(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ù)是一個(gè)函數(shù)式接口，我們可以使用Lambda表達(dá)式作為參數(shù)傳遞

startThread(() -> System.out.println(Thread.currentThread().getName() + "線程啟動(dòng)了"));

public class RunnableDemo {
    public static void main(String[] args) {
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "線程啟動(dòng)了");
            }
        });

        startThread(() -> System.out.println(Thread.currentThread().getName() + "線程啟動(dòng)了"));

        startThread(()->{
            System.out.println(Thread.currentThread().getName() + "線程啟動(dòng)了");
        });
    }
    private static void startThread(Runnable runnable) {
        new Thread(runnable).start();
    }
}

1.3 函數(shù)式接口作為方法的返回值

如果方法的返回值是一個(gè)函數(shù)式接口，我們可以使用Lambda表達(dá)式作為結(jié)果返回

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包下預(yù)定了大量的函數(shù)式接口供我們使用，常用如下：

Supplier接口
Consumer接口
Predicate接口
Function接口

1.5 Supplier接口

Supplier接口

T get()：獲得結(jié)果
該方法不需要參數(shù)，它會(huì)按照某種實(shí)現(xiàn)邏輯（由Lambda表達(dá)式實(shí)現(xiàn))返回一個(gè)數(shù)據(jù)
Supplier 接口也被稱為生產(chǎn)型接口，如果我們指定了接口的泛型是什么類型，那么接口中的get方法就會(huì)生產(chǎn)什么類型的數(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();
    }
}

練習(xí)：獲取最大值

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：包含兩個(gè)方法

void accept(T t)：對給定的參數(shù)執(zhí)行此操作
default Consumer andThen(Consumer after)：返回一個(gè)組合的Consumer,依次執(zhí)行此操作，然后執(zhí)行after操作
Consumer 接口也被稱為消費(fèi)型接口，它消費(fèi)的數(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);
    }
}

練習(xí)：

字符串?dāng)?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接口

常用方法：

練習(xí)：判斷給定的字符串是否滿足要求

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);
    }
}

練習(xí)2：

String[] strArray ={“孫悟空，30”,“唐僧，36”，“沙僧，34”，“豬八戒，32”，“白骨精，5000”}
字符串?dāng)?shù)組中有多條信息，請通過Predicate接口的拼裝將符合要求的字符串篩選到集合ArrayLitst中，并遍歷ArrayLitst集合
同時(shí)滿足如下要求：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>兩個(gè)常用方法：

Function<T,R>接口通常用于對參數(shù)進(jìn)行處理，轉(zhuǎn)換（處理邏輯由Lambda表達(dá)式實(shí)現(xiàn)）然后返回一個(gè)新的值

練習(xí)：

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));

    }
    //定義一個(gè)方法，把一個(gè)int類型的數(shù)據(jù)加上一個(gè)整數(shù)之后，轉(zhuǎn)為字符串在控制臺輸出
    private static void convert(String s, Function<String, Integer> function) {
        Integer i = function.apply(s);
        System.out.println(i);
    }
    //定義一個(gè)方法，把一個(gè)int類型的數(shù)據(jù)加上一個(gè)整數(shù)之后，轉(zhuǎn)為字符串在控制臺輸出
    private static void convert(int i, Function<Integer, String> function) {
        String s = function.apply(i);
        System.out.println(s);
    }
    //定義一個(gè)方法，把一個(gè)字符串轉(zhuǎn)換為int類型，把int類型的數(shù)據(jù)加上一個(gè)整數(shù)之后，轉(zhuǎn)為字符串在控制臺輸出
    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);
    }
}

練習(xí)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 體驗(yàn)Stream流

需求：按照下面的要求完成集合的創(chuàng)建和遍歷

創(chuàng)建一個(gè)集合，存儲(chǔ)多個(gè)字符串元素
把集合中所有以“張”開頭的元素存儲(chǔ)到一個(gè)新的集合再
把長度為3的元素存儲(chǔ)到一個(gè)新集合
最后遍歷上一步得到的集合

使用Stream流的方式完成過濾操作：

直接閱讀代碼的字面意思即可完美展示無關(guān)邏輯方式的語義：生成流、過濾姓氏、過濾長度為3、逐一打印
Stream流把真正的函數(shù)式編程風(fēng)格引入到j(luò)ava中

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流改進(jìn)
        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();

中間操作：一個(gè)流后面可以跟隨零個(gè)或者多個(gè)中間操作，其目的主要是打開流，做出某種程度的數(shù)據(jù)過濾/映射，然后返回一個(gè)新的流，交給下一個(gè)操作使用

filter()

終結(jié)操作：一個(gè)流只能有一個(gè)終結(jié)操作，當(dāng)這個(gè)操作執(zhí)行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個(gè)操作

forEach()

Stream流的常見生成方式

Collection體系的集合可以使用默認(rèn)方法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ù)進(jìn)行過濾
Predicate接口中的方法：boolean test(T t):對給定的參數(shù)進(jìn)行判斷，返回一個(gè)布爾值

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ù)個(gè)數(shù)的數(shù)據(jù)
Stream skip(long n)：跳過指定參數(shù)個(gè)數(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("張一飛");
        //取前三個(gè)數(shù)據(jù)在控制臺輸出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("-----------------------------");
        //跳過2個(gè)元素，把剩下的元素在控制臺上輸出
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("-----------------------------");
        //跳過2個(gè)元素并將剩下元素的前兩個(gè)元素在控制臺上輸出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

Stream Stream concat(Stream a,Stream b)：合并a和b兩個(gè)流為一個(gè)流
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個(gè)數(shù)據(jù)組成一個(gè)流
        Stream<String> limitStream = list.stream().limit(4);
        //需求2：跳過2個(gè)數(shù)據(jù)組成一個(gè)流
        Stream<String> skipStream = list.stream().skip(2);
        //需求3：合并需求1和需求2得到的流，并把結(jié)果在控制臺輸出
//        Stream.concat(limitStream,skipStream).forEach(System.out::println);
        //需求4：合并需求1和需求2得到的流，并把結(jié)果在控制臺輸出，要求字符串元素不能重復(fù)
        Stream.concat(limitStream,skipStream).distinct().forEach(System.out::println);
    }
}

Stream sorted()：返回由此流的元素組成的流，根據(jù)自然順序排序
Stream sorted(Comparator comparator)：返回由該流的元素組成的流，根據(jù)提供的Comparator進(jìn)行排序

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ù)應(yīng)用于此流的元素的結(jié)果組成的流（Function接口中的方法 R apply(T t)）
IntStream mapToInt(ToIntFunction mapper)：返回一個(gè)IntStream其中包含將給定函數(shù)應(yīng)用于此流的元素的結(jié)果

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流的常見終結(jié)操作方法

void forEach(Consumer action)：對此流的每個(gè)元素執(zhí)行操作（Consumer接口中的方法 void accept(T t)：對給定的參數(shù)執(zhí)行此操作）
long count()：返回此流中的元素?cái)?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)計(jì)集合中有幾個(gè)姓張的元素并在控制臺輸出
        list.stream().filter(s -> s.startsWith("張")).forEach(System.out::println);
    }
}

1.5 Stream流的練習(xí)

現(xiàn)在又兩個(gè)ArrayList集合，分別存儲(chǔ)6名男演員和6名女演員名稱，要求完成如下操作

男演員只要名字為3個(gè)字的前三人
女演員只要姓林的，并且不要第一個(gè)
把過濾后的男演員姓名和女演員姓名合并到一起
把上一步操作后的元素作為構(gòu)造方法的參數(shù)創(chuàng)建演員對象，遍歷數(shù)據(jù)（演員類Actor已經(jīng)提供，里面有一個(gè)成員變量，一個(gè)帶參構(gòu)造方法，以及成員變量對應(yīng)的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個(gè)字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演員只要姓林的，并且不要第一個(gè)
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把過濾后的男演員姓名和女演員姓名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);

        //把上一步操作后的元素作為構(gòu)造方法的參數(shù)創(chuàng)建演員對象，遍歷數(shù)據(jù)
        stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
        System.out.println("------------------------------------");
        //改進(jìn)
        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流的手機(jī)方法

R collect(Collector collector)
但是這個(gè)收集方法的參數(shù)是一個(gè)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個(gè)字的流
        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);
        }
    }
}

到此這篇關(guān)于Java 函數(shù)式編程梳理的文章就介紹到這了,更多相關(guān)Java 函數(shù)式編程內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: