Lambda结合函数式接口的使用

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

• 案例1：函数式接口作为方法的参数

#自定义函数式接口
package FunctionInterface;
public interface MyFunctionInterface {
    public abstract void method();
}

public class functionDemo {
    public static void show(MyFunctionInterface myFunctionInterface) {
        myFunctionInterface.method();
    }

public static void main(String[] args) {
     // 方式1
    // 调用show方法,参数是一个接口，可以传递接口的匿名内部类
        show(new MyFunctionInterface(){
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写抽象方法");
            }
        });

        // 方式2
       // Lambda表达式
        show(() ->{
            System.out.println("Lambda表达式实现");
        });
}

• 函数式接口作为参数

public class functionDemo {
      public static void threadStart(Runnable run) {
        new Thread(run).start();
    }

    // 方式1：匿名内部类
  threadStart(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "启动了");
            }
        });
    // 注意：参数Runnabl 一个函数式接口，并且只有一个抽象方法(run),可以传递Lambda表达式
    //方式2: Lambda表达式
    threadStart(() -> System.out.println(Thread.currentThread().getName() + "启动了"));
}

输出：

Thread-0启动了
Thread-1启动了

• 案例2：函数式接口作为返回值

# 对字符串按照字符长度倒序

package FunctionInterface;
import java.util.Arrays;
import java.util.Comparator;

public class LambdaReturn {
    public static Comparator<String> getComparator(){
        //方式1:方法的返回值类型是一个接口，我们可以返回这个接口的匿名内部类
/*
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // 按照字符串的降序排列
                return o2.length() - o1.length();
            }
        };
*/
  
        // 方式1: Lambda表达式
        return (String o1, String o2) -> {
            // 按照字符串的降序排列
            return o2.length() - o1.length();
        };

        // Lambda优化
        // return (o1, o2) -> o2.length() - o1.length();
  }

 public static void main(String[] args) {
        // 函数式接口作为返回值
        String[] strList = {"abc", "bcd", "wudy", "petwr", "world"};
        System.out.println("排序前=" + Arrays.toString(strList));
        Arrays.sort(strList, getComparator());
        System.out.println("排序后=" + Arrays.toString(strList));
    }
}

输出：

排序前=[abc, bcd, wudy, petwr, world]
排序后=[petwr, world, wudy, abc, bcd]

• 案例3: Lambda延迟执行
• 有些场景的代码执行后，结果一定会被使用，从而造成性能浪费，而Lambda是延迟执行的，正好可以作为解决方案
  性能浪费的日志案例：对日志消息进行拼接后，在满足条件的情况下进行打印输出

package FunctionInterface;

public class LambdaDelay {
    public static void main(String[] args) {
        String msg1 = "hello";
        String msg2 = "world";
        String msg3 = "java";
        showLog(2, msg1 + msg2 + msg3);
    }

    public static void showLog(int level, String msg) {
        if (level == 1) {
            System.out.println("日志级别等于1" + msg);
        }
    }

注意： 上述代码存在的问题： 拼接的字符串在level != 1 的时候并没有用到，存在性能浪费

• 优化如下：
• 使用Lambda优化日志案例
  特点：延时加载, 定义一个显式日志的方法，方法的参数传递日志的等级和MessageBuilder接口
  使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
  只有满足条件（日志等级是1），才会调用接口MessageBuilder中的方法messageBuilder
  如果不满足条件，日志的等级不是1，那么接口MessageBuilder中的方法messageBuilder不会执行
  所以拼接字符串的代码也不会执行所以不会存在性能的浪费

package FunctionInterface;
@FunctionalInterface
public interface MessageBuilder {
    // 定义一个拼接消息的抽象方法, 返回被拼接的消息
    public abstract String builderMessage();
}

package FunctionInterface;

public class LambdaDelay {
    public static void main(String[] args) {
        String msg1 = "hello";
        String msg2 = "world";
        String msg3 = "java";
        showLog(1, () -> {
            return msg1 + msg2 + msg3;
        });
    }

   private static void showLog2(int level, MessageBuilder messageBuilder) {
        if (1 == level) {
            System.out.println("测试啥时候进来这里啊!");
            System.out.println(messageBuilder.builderMessage());;
        }
    }

结论： 当level==2的时候，不会进入Lambda表达式中，就不会执行字符串拼接，从而节省性能

• 案例4: 使用Supplier接口作为方法参数类型

Supplier 被称之为生产型接口，指定接口的范型是什么类型，那么接口中的get方法就会生产什么类型的数据

package FunctionInterface;

import java.util.function.Supplier;
public class SupplierDemo {
    public static void main(String[] args) {
       // 调用getSupplier方法， 方法的参数Supplier是一个函数式接口，所以可以传递Lambda表达式
       String name = getSupplier(() -> {
               return "wudy";
       });

      //String name = getSupplier(() -> "wudy");
      System.out.println(name);
    }

      public static String getSupplier(Supplier<String> supplier) {
           return supplier.get();
    }
}

输出：

wudy

• Supplier接口作为方法参数类型, 通过Lambda表达式求出int数组中的最大值

package FunctionInterface;

import java.util.function.Supplier;
public class SupplierDemo {
    public static void main(String[] args) {
         Integer[] list = {88, 10, -12, -34, 0, 65, 102};
         int maxValue = getMax(() -> {
             System.out.println("second");
              int max = list[0];
              for (int i: list) {
                  if (i > max) {
                      max = i;
                  }
              }
              return max;
        });

        System.out.println(maxValue);
  }

    public static Integer getMax(Supplier<Integer> supplier) {
        System.out.println("first");
        return supplier.get();
    }
}

输出：

first
second
102

Consumer接口是一个消费型接口，范型指定什么类型，就可以使用accept方法消费什么类型的数据

• 案例5: Consumer反转字符串

package FunctionInterface;

import java.util.function.Consumer;
public class ConsumerDemo {
    public static void main(String[] args) {
        method("wudy", (String name) -> {
            // 重写accept
            // 反转字符串
            String revName = new StringBuffer(name).reverse().toString();
            System.out.println(revName);
        });
    }

      public static void method(String name, Consumer<String> consumer){
            consumer.accept(name);
    }
}

输出：

yduw

• AndThen方法: 需要两个Consumer接口，可以把两个Consumer接口组合到一起，再对数据进行消费

package FunctionInterface;
import java.util.function.Consumer;

public class ConsumerAndThen {
    public static void main(String[] args) {
        method("Hello World", (String name) -> {
            System.out.println("执行con1=" + name.toUpperCase());
        }, (String name) -> {
            System.out.println("执行con2=" + name.toLowerCase());
        });
    }

      public static void method(String s, Consumer<String> con1, Consumer<String> con2){
          // 先执行con2消费数据，再执行con1消费数据
          con2.andThen(con1).accept(s);
    }
}

输出：

执行con2=hello world
执行con1=HELLO WORLD

• AndThen方法： 格式化打印信息
• 将下面的字符串按照格式"姓名：XX。性别：XX" 的格式打印出来，要求将打印姓名的动作作为第一个Consumer接口的Lambda实例，
  将打印性别的动作作为第二个Consumer接口的Lambda实例，将两个Consumer接口按照顺序拼接到一起

package FunctionInterface;
import java.util.function.Consumer;

public class FormatPrint {

    public static void main(String[] args) {
        String[] strList = {"wudy,男","peter,女","timo,女"};

        for (String str: strList) {
            printInfo(str, (String name) -> {
                name = str.split(",")[0];
                System.out.print("姓名:" + name);
            }, (String sex) -> {
                sex = str.split(",")[1];
                System.out.println("。性别:" + sex + "。");
            });
        }
    }

    public static void printInfo(String str, Consumer<String> con1, Consumer<String> con2) {
        con1.andThen(con2).accept(str);
    }
}

输出：

姓名:wudy。性别:男。
姓名:peter。性别:女。
姓名:timo。性别:女。

• 有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果

package FunctionInterface;
import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        String str = "macBookPro";
        boolean b = checkString(str, (String s) -> s.length() >15);

        System.out.println(b);
    }

    public static boolean checkString(String str, Predicate<String> predicate) {
        return predicate.test(str);
    }
}

输出：

false