Java函数式编程实例分析

蜗牛 互联网技术资讯 2022-07-28 18 0

这篇“Java函数式编程实例分析”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“Java函数式编程实例分析”文章吧。

一、Lambda表达式 

1.1 函数式编程思想概述Java

在数学中,函数就是有输入量、输出量的一套计算方案,也就是java“拿数据做操作”

面向对象思想强调“必须通过对象的形式快速来做事情”

函数式思想强调则金量忽略面向对象的复杂语句:“强调做什么,而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

1.2 体验Lambda表达式

需求:启动一个线程,在控制台教学输出一句话:多线程程序启动了

方式1:

  • 定义一个类MyRunnable接口,重写run方法

  • 创建MyRunnable类的对象

  • 创建Thread类对象,把MyRunnable的对象作为构造参数传递

  • 启动线程

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的基础上进行改进,java函数式编程讲解,使用匿名内部类的方式

      new Thread(new Runnable() {
           @Override
            public void run() {
                System.out.println("多线程程序启动了");
            }
        }).start();

方式3:

Lambda表达式的方式改进:

        new Thread(() -> {
            System.out.println("多线程程序启动了");
        }).start();

1.3 Lambda表达式的标准格式

匿名内部类中重写run()方法的代码分析:

  • 方法形式参数为空,说明调用方法时不需要传递参数

  • 方法返回值类型程序为void,说明方法执行没有结果返回

  • 方法体中的内容,是我们具体要做的事情

      new Thread(new Runnable() {
           @Override
            public void run() {
                System.out.println("多线程程序启动了");
            }
        }).start();

Lambda表达式的代码分析:

  • ():里面没有内容,可以看成是方法形式参数为空

  • ->:用箭头教学指向后面要做的事情

  • {}:包含一段代码,我们称之为代码块,可以看成是方法体中的内容

        new Thread(() -> {
            System.out.println("多线程程序启动了");
        }).start();

组成Lambda表达式的三要素:形式参数、箭头、代码块

Lambda表达式快速的格式:

  • 格式:(形式参数)->{代码块}

  • 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可

  • ->:由英文中画线和大于符号组成,java函数式编程有必要吗,java函数式编程教学,固定写法。代表指向动作

  • 代码块:是我们具体要做的事情,用java编写分段函数的程序,也就是以前我们写的方法Java体内容

1.4 Lambda表达式的练习

Lambda表达式的使用前提

  • 有一个接口

  • 接口中有且仅有一个抽象方法

练习1:

  • 定义一个接口(Eatable),java函数式编程快速入门教程,里面定义一个抽象方法:void eat();

  • 定义一个测试类(EatableDemo),在测试类中提供两个方法:

    • 一个方法是:useEatable(Eatable e)

    • 一个方法是主方法,在主方法中调用useEatable方法

定义一个接口:

public interface Eatable {
    void eat();
}

方式一:传统接口实现类

public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("一日三餐,必不可少JAVA");
    }
}
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表达式的省略模式

省略规则:

  • 参数类型可以省略。如果有多个参数的情况下,java函数式编程举例,不能只省略一个

  • 如果参数有且仅有一个,那么小括号可以省略

  • 如果代码块的语句只有一条,可以省略大括号和分号,甚至时return

public class LambdaDemo5 {
    public static void main(String[] args) {
        //参数类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        System.out.println("------------------------");
        //如果只有一个参数,小括号也可以省略
        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表达式的注意事项Java

注意事项:

  • 使用Lambda必须要有接口,并且要求接口中有且仅有一个抽象的方法

  • 必须有上下文环境,才能推导出Lambda对应的接口

    • 根据局部变量的赋值得知Lambda对应的接口:Runnable r =() ->System.out.println(“Lambda表达式”);

    • 根据调用方法的参数得知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.java7 Lambda表达式和匿名内部计算类的区别

所需类型不同:

  • 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类

  • Lambda表达式:只能是接口

使用限制不同:

  • 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类

  • 如果接口中多于一个抽象方法,java函数式编程入门,只能使用匿名内部类,而不能使用Lambda表达式

实现原理不同:

  • 匿名内部类:编译之后,产生一个单独的.class字节码文件

  • Lambda表达式:编译之后,没有一个单独的.class字节码文件,对应的字节码会在运行的时候动态生成

二、接口计算组成更新

1.1 接口例子计算组成更新概述

接口的组成:

  • 常量:public static final

  • 抽象方法:public abstract

  • 默认方法(Java 8)

  • 静态方法(Java 8)

  • 私有方法 (Java 8)

1.2 接口中默认方法

接口中默认方法得定义格式:

  • 格式:public default 返回值类型 方法名(参数列表){}

  • 范例: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 接口中静态方法实例

接口中静态编程方法的定义格式:

  • 格式:public static 返回值类型 方法名(参数列表){ }

  • 范例:JAVApublic static void show(){ }

接口中静态方法的注意事项:

  • 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用

  • public可以省略,static不能省略

public interface Inter {
    void show();
    default void method() {
        System.out.println("Inter 中的默认方法执行了");
    }
    public static void test(){
        System.out.println("Inter 中的静态方法执行了");
    }
}
public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show方法执行了");
    }
}
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允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题:当两个默认方法或者静态方法中包含一段相同分段的代码实现时,程序必然考虑将这段实现代码抽取成一个共性方法,而这个共性方法时不需要让别人使用的,因此用私有给隐藏起来,这就是Java 9增加私有方法的必然性。

接口中私有方法的定义格式:

  • 格式1:private 返回值类型方代码法名(参数列表){ }

  • 范例1:private void show(){ }

  • 格式2:private static 返回值类型 方法名(参数列表){ }

  • 范例2:private static void method(){ }

接口中语言私有语言方法的注意事项:

  • 默认方法可以调用快速私有的静态方法和非静态方法

  • 静态方法只能调用私有的静态方法

public interface Inter {
    default void show1(){
        System.out.println("show1开始执行");
        method();
        System.out.println("show1结束推荐执行");
    }
    default void show2(){
        System.out.println("show2开始执行");
        method();
        System.out.println("show2结束执行");
    }
    static void method1(){
        System.out.println("method1开始执行");
        method();
        System.out.println("method1结束执行");
    }
    static void method2(){
        System.out.println("method2开始执行");
        method();
        System.out.println("method2结束执行");
    }
    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));

分析:拿到参数s之后通过Lambda表达式,传递给System.out.println方法去处理

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

分析:直接使用System.out中的println方法来取代Lambda,代码更加的简洁

推导与省略:

  • 如果入门使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导

  • 如果使用方法引用,也同要可以根据上下文进行推导

  • 方法引用是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 引用类方法

引用类方法,其实就是引用类的静态方法

  • 格式:类名::静态方法

  • 范例:Integer::parseInt

    • Integer类的方法:public static int parsenInt(String s),将此String转换为int类型数据

    • Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数

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表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数

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表达式被类的实例方法替代的时候,第一个参数作为调用者,后面的参数全部传递给该方法作为参数

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表达式被构造器代替的时候,它的形式参数全部传递给构造器作为参数

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,Java函数式编程实例分析, 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());
    }
}

四、函数式接口

1.1 函数接口概述

函数式接口:有且仅有一个抽象方法的接口

Java中的函数式编程体现就是Lambda表达式,所以函数式接口就是可以使用于Lambda使用的接口

只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地编写进行推导

如何检测一个接口是不是函数式接口呢?

  • @FunctionalInterface

  • 放在接口定义的上方:如果接口是函数接口,编译通过;如果不是,编译失败

注意:

我们自己定义函数式接口的时候,@FunctionalInterface是可选的,就算我们不写这个注解,只要保证满足函数式接口定义的条件,也照样是函数式接口。但是,建议加上注解。

@FunctionalInterface
public interface MyInterface {
    void show();
}
public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface myInterface = ()-> System.out.println("函数式接口");
        myInterface.show();
    }
}

1.2 函数式接口作为方法的参数实战

如果方法的参数是一个函数式接口,我们可以编写使用Lambda表达式作为参数传递

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 函数式接口作为方法的返回值

如果方法的返回值是一个函数式接口,我们可以使用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 常用的函数式接口

Java 8 在java.util.function包下预定了大量的函数式接口供我们使用,常用如下:

  • Supplier接口

  • Consumer接口

  • Predicate接口

  • Function接口

1.5 Supplier接口

Supplier接口

  • T get():获得结果

  • 该方法不需要参数,它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

  • Supplier 接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据供我们使用

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,java编程实例大全, 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("数组中的数式最大值是:" + maxNumber);
    }

    private static int getMax(Supplier<Integer> supplier) {
        return supplier.get();
    }
}

1.6 Consumer接口

Consumer:包含两个方法

  • void accept(T t):对大全给定的参数入门执行此操作

  • default Consumer andThen(Consumer after):返回一个组合的Consumer,依次执行此操作,然后讲解执行after操作

  • Consumer 接口也被称为消费型接口,它消费的数据类型由泛型指定

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

练习:

字符串数组中又多条信息,按照:“姓名: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接口

常用方法:

Java函数式编程实例分析  java 第1张

练习:判断给定的字符串是否满足要求实例

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”}

  • 字符串数组中有推荐多条信息,请通过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>两个常用方法:

Java函数式编程实例分析  java 第2张

Function<T,R>接口通常用于对参数进行处理,转换(处理逻辑由Lambda表达式实现)然后返回一个新的值

练习:

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类型的数据加上一个整数之后,转为字符编写串在控制台输出
    private static void convert(String s, Function<String, Integer> function) {
        Integer i = function.apply(s);
        System.out.println(i);
    }
    //定义一个方法,把一个int类型的数据加上一个整数之后,转为字符串在控制台输出
    private static void convert(int i, Function<Integer, String> function) {
        String s = function.apply(i);
        System.out.println(s);
    }
    //定义一个方法,把一个字符串转换为int类型,把int类型的数据加上一个整数之后,转为字符串在控制台输出
    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流

需求:按照下面的要求完成集合的创建和遍历

  • 创建一个集合,存储多个字符串元素

  • 把集合中所有以“张”开头的元素存储到一个新的集合再

  • 把长度为3的元素存储到一个新集合

  • 最后遍历上一步得到的集合

使用Stream流的方式完成过滤操作:

  • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:生成流、过滤姓氏、过滤长度为3、逐一打印

  • Stream流把真正的函数式编程风格引入到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流的使用

生成流:通过数据源(集合、数组等)生成流

list.stream();

中间操作:一个流后面可以跟随零方法个或者多个中间操作,其目的主要是打开流,做出某种程度的数据过滤/映射,然后返回一个新的流,交给下一个操作使用

filter()

终结操作:一个流只能有一个终结操作,当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作

forEach()

Stream流的常见生成方式

Collection体系的集合可以使用默认方法stream()生成流

default Stream<E> stream()
  • Map体系的集合间接的生成流实例

  • 数组可以通过Stream接口的静态方法of(T&hellip;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):用于对流中的数据进行过滤

  • Predicate接口中的方法程序:boolean test(T t):对给定的参数进行判断,返回一个布尔值

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):返回此流中的元素组成的流,截取前指定参数个数的数据

  • Stream skip(long n):跳过指定参数个数的数据,返回由该流的剩余元素组成的流

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().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:返回由该流的不同元素(根据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个数据组成一个流
        Stream<String> limitStream = list.stream().limit(4);
        //需求2:跳过2个数据组成一个流
        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():返回由此流的元素组成的流,根据自然顺序排序

  • Stream sorted(Comparator comparator):返回由该流的元素组成的流,根据提供的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:按照字母顺序把数据在控制台输出
        list.stream().sorted().forEach(System.out::println);
        //需求2:按照字符串长度把数据在控制台输出
        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):返回由给定函数应用于此流的元素的结果组成的流(Function接口中的方法 R apply(T t))

  • IntStream mapToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果

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):对此流的每个元素执行操作(Consumer接口中的方法 void accept(T t):对大全给定的参数入门执行此操作)

  • long count():返回此流中的元素数

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:统计集合中有几个姓张的元素并在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
    }
}

1.5 Stream流的练习

现在又两个ArrayList集合,分别存储6名是什么男演员和6名女演员名称,要求完成如下操作

  • 男演员只要名字为3个字的前三人

  • 女演员只要姓林的,并且不要第一个

  • 把过滤后的男演员姓名和女演员姓名合并到一起

  • 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据(演员类Actor已经提供,里面有一个成员变量,一个带参构造方法,以及成员变量对应的get/set方法)

public class StreamDemo {
    public static void main(String[] args) {
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        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);

        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
        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流的收集操作

对数据使用Stream流的方式操作完毕后,如何把流中的数据收集到集合中?

Stream流的手机方法

  • R collect(Collector collector)

  • 但是这个收集方法的参数是一个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流操作完毕的数据收集到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流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> collect2 = integerStream.collect(Collectors.toSet());
        for (Integer i : collect2) {
            System.out.println(i);
        }

        String[] strArray = {"张飞,28", "张三丰,33", "张三,26", "李四,44"};

        //需求5:得到字符串年龄中数据大于28的流
        Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        //需求6:把使用Stream流操作完毕的数据收集到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);
        }
    }
}

以上就是关于“Java函数式编程实例分析”这篇文章的内容,相信大家都有了一定的了解,希望小编分享的内容对大家有帮助,若想了解更多相关的知识内容,请关注蜗牛博客行业资讯频道。

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:niceseo99@gmail.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

评论