常用Lambda函数式接口

常用Lambda函数式接口

1-概述

有且只有一个抽象方法，为Lambda准备的接口

都是由@FunctionalInterface进行的注解

2-函数式接口作为方法的参数

创建线程，用的最多且经典的Lambda使用

/**
 * @author Object（object_hui@sina.com）
 * @description Lambda创建线程
 * @date 2020/9/22
 */
public class Demo01 {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用内部类创建了一个线程！");
            }
        }).start();

        new Thread(() -> System.out.println("省略写法的Lambda创建的线程类")).start();

    }
}

3-函数式接口作为方法的返回值

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * @author Object（object_hui@sina.com）
 * @description 函数式接口作为方法的返回值
 * @date 2020/9/22
 */
public class Demo02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("111");
        list.add("333");
        list.add("555");
        list.add("222");
        list.add("666");
        list.add("888");
        System.out.println("调用排序前");
        System.out.println(list);
        System.out.println("调用排序后");
        //调用集合排序方法，传入集合和比较器
        Collections.sort(list,getCompartor());
        System.out.println(list);


    }

    public static Comparator<String> getCompartor(){
        //两种写法等价,通过Lambda实现函数式接口返回一个比较器
//        return (o1, o2) -> o1.compareTo(o2);
        return String::compareTo;
    }
}

4-常用的函数式接口

4.1-Supplier

生产接口，我们通常用这个接口来获取一个可操作的数据

import java.util.function.Supplier;

/**
 * @author Object（object_hui@sina.com）
 * @description Supplier测试类
 * @date 2020/9/22
 */
public class SupplierDemo {
    public static void main(String[] args) {
        //使用生产者接口获取一个Integer类型的数
        Integer integer = getInteger(() -> 1314);
        System.out.println(integer);

        //使用生产者接口获取一个String类型的数
        String str = getString(() -> "1314");
        System.out.println(str);
        //使用生产者接口返回一个数组中的最大值
        int[] arr = {45,78,22,63};
        Integer max1 = 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(max1);
    }

    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static Integer getMax(Supplier<Integer> sup){
        return sup.get();
    }


}

4.2-Consumer

消费者接口，对一些数据进行操作，不需要进行返回

import java.util.function.Consumer;

/**
 * @author Object（object_hui@sina.com）
 * @description 消费函数lambda
 * @date 2020/9/23
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        //消费两次，进行打印输出
        runConsumer("伊利丹.怒风",s -> System.out.println(s),s -> System.out.println(s));
        //使用引用替代
        runConsumer("伊利丹.怒风",System.out::println,System.out::println);
    }
    //将字符串name进行消费，先由con1消费，再由con2消费
    private static void runConsumer(String name, Consumer<String> con1,Consumer<String> con2){
        con1.andThen(con2).accept(name);
    }
}

• 小应用：使用Consumer将数组中的内容按照指定的格式输出

import java.util.function.Consumer;

/**
 * @author Object（object_hui@sina.com）
 * @description 使用Consumer将字符串数组按规定输出
 * @date 2020/9/23
 */
public class ConsumerDemo02 {
    public static void main(String[] args) {
        String[] arr = {"伊利丹.怒风,102","卡尔萨斯,88","安吉娜,78"};
        runConsumer(arr,s -> System.out.print("姓名："+s.split(",")[0]+"\t"),
                s -> System.out.println("\t年龄："+s.split(",")[1]));
    }
    public static void runConsumer(String[] arr, Consumer<String> con1,Consumer<String> con2){
        for (String s:arr
             ) {
            con1.andThen(con2).accept(s);
        }
    }
}

4.3-Predicate

用于判断是否满足指定的条件的函数

import java.util.function.Predicate;

/**
 * @author Object（object_hui@sina.com）
 * @description Predicate小测试
 * @date 2020/9/23
 */
public class PredicateDemo {
    public static void main(String[] args) {
        //判断名字的长度是否大于2
        System.out.println(runPredicate("伊利丹.怒风",s -> s.length()>2));

    }
    //使用Predicate函数接口，对字符串进行判断
    public static boolean runPredicate(String name, Predicate<String> pre){
       return pre.test(name);
       //非的写法
//        return pre.negate().test(name);
    }
}

• 小案例：筛选名字长度大于4，且年龄大于100的数据

  
  import java.util.ArrayList;
  import java.util.function.Predicate;
  
  /**
   * @author Object（object_hui@sina.com）
   * @description 使用Predicate将字符串数组按规定输出
   * @date 2020/9/23
   */
  public class ConsumerDemo02 {
      public static void main(String[] args) {
          String[] arr = {"伊利丹.怒风,102","卡尔萨斯,88","安吉娜,78","格罗姆·地狱咆哮,103","沃金,133"};
          //条件1：名字长度大于4，条件2：年龄大于100
          ArrayList<String> list = runConsumer(arr, s -> s.split(",")[0].length() > 4,
                  s -> Integer.parseInt(s.split(",")[1]) > 100);
          System.out.println(list);
      }
      
      public static ArrayList<String> runConsumer(String[] arr, Predicate<String> pre1, Predicate<String> pre2){
          ArrayList<String> list = new ArrayList<>();
          for (String s:arr) {
              //满足两个条件则加入集合
              if (pre1.and(pre2).test(s))
                  list.add(s);
          }
          return list;
      }
  }
  

4.4-Function

加工函数

Function<T,R>：用于参数转换，把T加工成R

import java.util.function.Function;

/**
 * @author Object（object_hui@sina.com）
 * @description Function测试类,将String类型加工成Integer类型
 * @date 2020/9/24
 */
public class FunctionDemo {
    public static void main(String[] args) {
        //使用lambda表达式
        System.out.println(runFunction("1314",s -> Integer.parseInt(s)));
        //使用引用替代
        System.out.println(runFunction("1314",Integer::parseInt));
    }

    public static Integer runFunction(String s,Function<String,Integer> fun){
        return fun.apply(s);
    }
}