Java8 函数式接口与Lambda及其应用

1) java 8 中 四大函数接口的使用

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author 懂技术爱生活
 */
public class FunctionTester {
    public static void main(String args[]) {
        // Java 8 四大函数式接口
        // 1-Function 函数式接口
        // 提供抽象方法 : R apply(T t)
        Function<String, String> function = (par) -> par + " run!";
        String function_result = function.apply("Function");
        System.out.println(function_result);

        // 2-Predicate 断定型接口
        // 提供抽象方法 : boolean test(T t)
        Predicate<String> predicate = (str) -> {
            System.out.println(str + " run!");
            return true;
        };
        Boolean predicate_result = predicate.test("Predicate");
        System.out.println(predicate_result);

        // 3-Consumer 消费型接口
        // 提供抽象方法 : accept(T t)
        Consumer<String> consumer = (str) -> System.out.println(str);
        consumer.accept("Consumer run!");

        // 4-Supplier 供给型接口
        // 提供抽象方法 : T get()
        Supplier<String> supplier = () -> "Supplier run!";
        System.out.println(supplier.get());

        // 以 1-Function 函数式接口 为例
        // lambda是实现函数式接口的一个快捷方式,效果等价于
        Function<String, String> function2 = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s + " run!";
            }
        };
        String function_result2 = function2.apply("Function2");
        System.out.println(function_result2);

        // 使用@FunctionalInterface注解自定义函数式接口
        MyFun f = str -> System.out.println(str);
        f.say("MyFun run!");
    }
}

2) java 8 Lambda 应用

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author 懂技术爱生活
 */
public class LambdaTester {

    public static void main(String[] args) {
        // 1-集合遍历
        System.out.println("===== 1 =====");
        String[] para = {"1-para1", "1-para2", "1-para3", "0-para4", "0-para5"};
        List<String> params = Arrays.asList(para);
        // 1.1-以前的循环方式
        for (String p : params) {
            System.out.println("get : " + p);
        }
        // 1.2-使用 lambda 表达式
        params.forEach(p -> System.out.println("get : " + p));


        // 2-实现 Runnable接口
        System.out.println("===== 2 =====");
        // 2.1-以前的实现方式
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable1 run!");
            }
        };
        runnable1.run();
        // 2.2-使用 lambda 表达式
        Runnable runnable2 = () -> System.out.println("runnable2 run!");
        runnable2.run();

        // 3-集合排序
        System.out.println("===== 3 =====");
        // 3.1-以前的实现方式
        Arrays.sort(para, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        params = Arrays.asList(para);
        params.forEach(p -> System.out.println("get : " + p));
        // 3.2-使用 lambda 表达式
        Arrays.sort(para, (String o1, String o2) -> {
            return o1.compareTo(o2);
        });
        params = Arrays.asList(para);
        params.forEach(p -> System.out.println("get : " + p));

        //4-使用Lambdas和Streams
        // Stream是对集合的包装,通常和lambda一起使用。 使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等
        // filter->map->sorted->collect
        System.out.println("===== 4 =====");
        // filter
        System.out.println("filter:");
        params.stream().filter(p -> p.indexOf('0') >= 0).forEach(p -> System.out.println("get : " + p));
        // sorted
        System.out.println("sorted:");
        params.stream().sorted((String p1, String p2) -> p1.compareTo(p2)).forEach(p -> System.out.println("get : " + p));
        // map & collect
        System.out.println("map & collect1:");
        List result1 = params.stream().map(p -> p.toUpperCase()).collect(Collectors.toList());
        result1.forEach(p -> System.out.println("1 get : " + p));
        // 知识点:stream 中
        // 使用:person -> person.getAge();
        // 效果等同:Person::getAge
        // 使用:new HashMap<>()
        // 效果等同HashMap::new
        System.out.println("map & collect2:");
        List result2 = params.stream().map(String::toUpperCase).collect(Collectors.toList());
        result1.forEach(p -> System.out.println("2 get : " + p));

    }
}