Java基础知识——lamda表达式和函数式接口

文章目录

  • 一、Lambda表达式
  • 二、函数式接口
    • 2.1 函数式接口作用
    • 2.2 常用函数式接口——Supplier接口
    • 2.3 常用函数式接口——Consumer接口
    • 2.4 常用函数式接口——Predicate接口
    • 2.5 常用函数式接口——Function接口


一、Lambda表达式

函数式接口:任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。对于函数式接口,可以通过Lambda表达式节创建该接口的对象。

使用Lambda表达式:避免匿名内部类定义过多、可以让代码看起来更简洁、去掉了一对没有意义的代码只留下了核心的逻辑

原来:

package Lambda;

public class TestLambda1 {
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}

//1、定义一个函数式接口
interface ILike{
    void lambda();
}

//2、实现类
class Like implements ILike {
    public void lambda(){
        System.out.println("I like lambda");
    }
}

通过匿名内部类简化:

package Lambda;

public class TestLambda1 {
    public static void main(String[] args) {
        ILike like = new ILike(){
            public void lambda(){
                System.out.println("I like lambda");
            }
        };
        like.lambda();
    }
}

//1、定义一个函数式接口
interface ILike{
    void lambda();
}



通过Lambda表达式进一步简化:

package Lambda;

public class TestLambda1 {
    public static void main(String[] args) {
       ILike like = ()->{
           System.out.println("I like lambda");
       };
       like.lambda();
    }
}

//1、定义一个函数式接口
interface ILike{
    void lambda();
}



总结:对于只包含一个抽象方法的接口,就可以用Lambda表达式简化代码创建对象

进一步省略:

  • 参数类型可以省略
  • 方法体只有一句代码的时候,可以省略大括号return和分号
  • 方法只有一个参数的时候可以省略小括号
       ILike like = ()->System.out.println("I like lambda");

二、函数式接口

函数式接口指的是有且只有一个抽象方法的接口,但是也可以有其他的方法(默认、静态、私有)。

可以添加@FunctionalInterface注解,作用是检测一个接口是否是函数式接口

2.1 函数式接口作用

函数式接口一般可以作为方法的参数和返回值类型

作为方法的参数:

package Lambda;

public class TestLambda1 {
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        show(()->System.out.println("重写接口中的方法"));
    }
}

@FunctionalInterface
interface MyFunctionalInterface{
    public void method();
}


作为方法的返回值类型:可以直接返回一个Lambda表达式

package Lambda;

import java.util.Arrays;
import java.util.Comparator;

public class TestLambda1 {
    public static Comparator getComparator(){
        return (o1,o2) -> o2.length()-o1.length();
    }
    public static void main(String[] args) {
        String[] arr = {"aaa","b","cccccc","dddddddddd"};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr,getComparator());//按照长度排序
        System.out.println(Arrays.toString(arr));
    }
}




2.2 常用函数式接口——Supplier接口

java.util.function.Supplier< T >接口仅包含一个无参的方法:T get()。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口,这也就意味着对应的Lambda表达式需要向外提供一个符合泛型类型的对象数据。这个接口被称为生产型接口,即指定接口的泛型是什么类型,那么接口中的get方法就会产生什么类型的数据。

样例:

package Lambda;

import java.util.function.Supplier;

public class DemoSupplier {
    public static String getString(Supplier sup){
        return sup.get();
    }

    public static void main(String[] args) {
        String s = getString(()->"胡歌");
        System.out.println(s);
    }
}

练习:使用Supplier接口作为方法参数类型,通过Lambda表达式求出int数组中的最大值。

package Lambda;

import java.util.function.Supplier;

public class DemoSupplier {
    public static int getMax(Supplier sup){
        return sup.get();
    }

    public static void main(String[] args) {
        int[] arr = {100,0,0-50,88,99,33,-30};
        int maxValue = getMax(()->{
          int max = arr[0];
          for(int i :arr){
              if(i > max)
                  max = i;
          }
          return max;
        });
        System.out.println(maxValue);
    }
}

2.3 常用函数式接口——Consumer接口

java.util.function.consumer< T >接口正好与Supplier接口相反,它消费一个数据,其数据类型由泛型决定。它包含抽象方法void accept(T t),意为消费一个指定泛型的数据。

accept()方法的使用:

package Lambda;

import java.util.function.Consumer;

public class DemoConsumer {
    public static void method(String name , Consumer con){
        con.accept(name);
    }

    public static void main(String[] args) {
        method("赵丽颖",(String name)->{
            //消费方式:把字符串进行翻转输出
            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

Java基础知识——lamda表达式和函数式接口_第1张图片

Consumer接口中的默认方法andThen:如果一个方法的参数和返回值都是Consumer类型,那么就可以实现消费数据的时候,首先做一个操作,然后再做一个操作,实现组合。这个方法就是由andThen实现的。要向实现组合,需要两个或者多个Lambda表达式即可,而andThen语义正是一步接一步操作。例如:

Consumer con1
Consumer con2
String s = "hello";
con1.accept(s);
con2.accept(s);

可以用andThen来进行连接,再进行消费,谁写前面谁先消费,所以下面是con1先进行消费:
con1.andThen(con2).accept(s);

第一种方式:

第一种方式:
package Lambda;

import java.util.Locale;
import java.util.function.Consumer;

public class DemoConsumer {
    public static void method(String s , Consumer con1 , Consumer con2){
        con1.accept(s);
        con2.accept(s);
    }

    public static void main(String[] args) {
        method("hello",
                (t)->{
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    System.out.println(t.toLowerCase());
                });

    }
}


第二种方式:用andThen进行连接

package Lambda;

import java.util.Locale;
import java.util.function.Consumer;

public class DemoConsumer {
    public static void method(String s , Consumer con1 , Consumer con2){
        con1.andThen(con2).accept(s);
    }

    public static void main(String[] args) {
        method("hello",
                (t)->{
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    System.out.println(t.toLowerCase());
                });

    }
}

练习:下面的字符串数组中存有多条信息,请按照格式“姓名:XX,性别:XX”的格式将信息打印出来,要求将打印姓名的动作作为第一个Consumer接口的Lambda实例,将打印性别的动作作为第二个Consumer接口的Lambda实例,将两个Consumer接口按照顺序拼接到一起:

package Lambda;

import java.util.Locale;
import java.util.function.Consumer;

public class DemoConsumer {
   public static void printInfo(String[] arr , Consumer con1 , Consumer con2){
       for(String message : arr){
           con1.andThen(con2).accept(message);
       }
   }

    public static void main(String[] args) {
        String[] arr = {"迪丽热巴,女","古力娜扎,女","马尔扎哈,男"};

        printInfo(arr,(message)->{
            String name = message.split(",")[0];
            System.out.print("姓名:"+name+",");
        },(message)->{
            String gender = message.split(",")[1];
            System.out.println("性别:"+gender);
        });
    }
}

Java基础知识——lamda表达式和函数式接口_第2张图片

2.4 常用函数式接口——Predicate接口

有时候我们需要对某种数据的类型进行判断,从而得到一个boolean值结果。这是可以用java.util.function.Predicate< T >接口。

抽象方法test():

package Lambda;

import java.util.function.Predicate;

public class DemoPredicate {
    public static boolean checkString(String s , Predicate pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        String s = "abcdef";
        //对参数传递的字符串进行判断,判断字符串长度是否大于5
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}

既然是条件判断,那么就会存在与或非三种逻辑。

与逻辑:默认方法and()

package Lambda;

import java.util.function.Predicate;

public class DemoPredicate {
   /*
        定义一个方法,方法的参数,传递一个字符串,两个Predicate接口
            一个用于判断字符串长度是否大于5
            一个用于判断字符串中是否包含a
            两个条件必须同时满足
    */
    public static boolean checkString(String s , Predicate pre1 , Predicate pre2){
        return pre1.and(pre2).test(s);
    }

    public static void main(String[] args) {
        String s = "bcdeff";

        boolean b = checkString(s,(String str)->{
            return str.length()>5;
        },(String str)->{
            return str.contains("a");
        });
        System.out.println(b);
    }
}

或逻辑:默认方法or()

package Lambda;

import java.util.function.Predicate;

public class DemoPredicate {
   /*
        定义一个方法,方法的参数,传递一个字符串,两个Predicate接口
            一个用于判断字符串长度是否大于5
            一个用于判断字符串中是否包含a
            满足一个条件即可
    */
    public static boolean checkString(String s , Predicate pre1 , Predicate pre2){
        return pre1.or(pre2).test(s);
    }

    public static void main(String[] args) {
        String s = "bcdeff";

        boolean b = checkString(s,(String str)->{
            return str.length()>5;
        },(String str)->{
            return str.contains("a");
        });
        System.out.println(b);
    }
}

非逻辑:negate()

package Lambda;

import java.util.function.Predicate;

public class DemoPredicate {
   /*
        定义一个方法,方法的参数,传递一个字符串,一个Predicate接口
           如果字符串长度大于5,则返回false
           如果字符串长度不大于5,则返回true
    */
    public static boolean checkString(String s , Predicate pre){
        return pre.negate().test(s);
    }

    public static void main(String[] args) {
        String s = "bcdeff";

        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}

2.5 常用函数式接口——Function接口

java.util.function.Function< T , R >接口用来根据一个类型的数据得到另一个类型的数据,前者称为前置条件,后者称为后置条件。将T的数据类型转换为R的数据类型

抽象方法R apply(T t),根据类型T的参数获取类型R的结果

package Lambda;

import java.util.function.Function;

public class DemoFunction {
    /*
        定义一个方法
        方法的参数传递一个字符串类型的证书
        方法的参数传递一个Function接口,泛型使用
        使用Function接口中的方法apply,把字符串类型的整数转换为Integer类型
     */
    public static void change(String s , Function fun){
        int in = fun.apply(s);
        System.out.println(in);
    }

    public static void main(String[] args) {
        String s = "1234";
        change(s,str->Integer.parseInt(s));
    }
}

默认方法andThen:进行组合操作

package Lambda;

import java.util.function.Function;

public class DemoFunction {
    /*
        需求:把String类型的“123”转换为Integer类型,把转换后的结果加10
            把增加之后的Integer类型的数据转换为String类型

        分析:转换了两次
            第一次是Function fun1:
                Integer i = fun1.apply("123")+10
            第二次是Function fun2:
                String s = fun2.apply(i)
            我们可以使用andThen方法将两次转换组合在一起使用
                String s = fun1.andThen(fun2).apply("123")

     */
    public static void change(String s , Function fun1 , Function fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        String s = "123";
        change(s,str->Integer.parseInt(str)+10,i->i+"");
    }
}

你可能感兴趣的:(Java学习笔记,java,开发语言,后端,函数式编程,lambda)