Java8之边学边记

一、lambda表达式

1.lambda表达式采用的是函数式编程的概念：

() -> {}

2.lambda表达式代替的是匿名函数，并且只能用在函数式接口（有且只有一个抽象方法），在Java提供的类库中，函数式接口上都有@FunctionalInterface注解。lambda表达式中的{}就是对函数式接口里抽象方法的实现

//例子1：
//函数式接口：
@FunctionalInterface
public interface Employee{
    public void getSalary(){
        
    }
}

public static void main(String[] agrs) {
//匿名函数
    Employee employee = new Employee(){
        @Override
        public void getSalary(){
            System.out.println("111");
        }
    };
}

public static void main(String[] agrs) {
//lambda表达式代替匿名类
    Employee employee = () -> {System.out.println("111");};
}





//例子2：
@FunctionalInterface
public interface MyFunctionalInterface {
    public void single(String msg);
}
 
/**
 * 需要单个参数
 */
public static void testOnePar(MyFunctionalInterface myFunctionalInterface){
    myFunctionalInterface.single("msg");
}
/**
 * 一个参数，可以省略参数的括号
 */
@Test
public void testOneParameter(){
    testOnePar(x-> System.out.println(x));
}

ps:lambda表达式可以代替匿名类：new FunctionalInterface(){},也可代替 FuntionalInterface functionInterface

3. lambda一些小规则：

//情况1
onlyOneParam -> onlyOneExpression;
 
//情况2
onlyOneParam -> onlyOneStatement;

//情况3
(param1,param2) -> {
                        String param = param1 + param2;
                        return param;
                   }

4.java8提供的常用函数式接口：

 四大函数式接口：

1.函数型接口Function<T,R>

        提供任意一种类型的参数，返回另外一个任意类型返回值。 R apply(T t);

public class FunctionInterface {
    public static void main(String[] args) {
        /**
         * testFunction方法中传递的第二个参数是函数型接口Function<String, String>的实例，使用lambda表达式生成
         * 分析(name) -> name + "Li"
         *    (name): 为传递的参数
         *    name + "Li"：为实现的方法体
         *    result 为返回值
         */
        String result = testFunction("Tim", (name) -> name + "Li");
        System.out.println("result = " + result);
    }

    /**
     * description: 函数型接口，有输入，有输出
     *
     * @param name
     * @param function
     * @return java.lang.String
    */
    private static String testFunction(String name, Function<String, String> function) {
        // apply()方法为函数型接口Function<String, String>的唯一抽象方法
        return function.apply(name);
    }
}

2.消费性接口Consumer<T>

        提供任意一种类型的参数，返回空值。 void accept(T t);

public class FunctionInterface {
    public static void main(String[] args) {
        /**
         * description: testConsumer()方法中第二个参数传递的是消费性接口Consumer<T>的实例
         * 分析x -> System.out.println("传入的数字为:" + x)
         *    x：为传递的参数
         *    System.out.println("传入的数字为:" + x)相当于抽象方法accept()的方法体
         *    testConsumer 没有返回
         * @param args
         * @return void
        */
       testConsumer(2, x -> System.out.println("传入的数字为:" + x));
    }

    /**
     * description: 消费性接口有输入，但是没有返回值
     *
     * @param x
     * @param consumer
     * @return void
    */
    private static void testConsumer(int x, Consumer<Integer> consumer) {
        // accept()方法为消费性接口Consumer<Integer>的唯一抽象方法
        consumer.accept(x);
    }
}

3. 供给型接口Supplier<T>

参数为空，得到任意一种类型的返回值。T get();

public class FunctionInterface {
    public static void main(String[] args) {
        /**
         * testSupplier()方法的参数是供给型接口Supplier<T>的实例
         * 分析() -> "hello Supplier"
         *    ()中为空说明不需要传参
         *    "hello Supplier"相当于唯一抽象方法get()的方法体
         *    得到返回值result为 "result Supplier"
         */
       String result = testSupplier(() -> "hello Supplier");
        System.out.println("result = " + result);
    }

    /**
     * description: 供给型接口，无输入有输出
     *
     * @param supplier
     * @return java.lang.String
    */
    private static String testSupplier(Supplier<String> supplier) {
        // get()方法为供给型接口Supplier<T>的唯一抽象方法
        return supplier.get();
    }
}

4. 断言型接口Predicate<T> 

提供任意一种类型的参数，返回boolean返回值。boolean test(T t);

public class FunctionInterface {
    public static void main(String[] args) {
        /**
         * testPredicate()方法中的第二个参数为断言型接口Predicate<T>的实例
         * 分析str -> str.equals("a")
         *    str: 为传递的参数
         *    str.equals("a")：相当于唯一抽象方法test()的方法体
         *    testPredicate 返回true或false
         */
       Boolean result = testPredicate("b", str -> str.equals("a"));
        System.out.println("result = " + result);
    }

    /**
     * description:断言型接口，有输入，输出为Boolean
     *
     * @param str
     * @param predicate
     * @return java.lang.Boolean
    */
    private static Boolean testPredicate(String str, Predicate<String> predicate) {
        // test()方法为断言型接口Predicate<T>的唯一抽象方法
        return predicate.test(str);
    }
}

二、方法引用

同lambda表达式，方法引用也可替代函数式接口，使代码更整洁。

方法引用主要有如下三种使用情况

     （1）. 类：：实例方法

e.g. 

String::compareToIgnoreCase 等同于 (x,y)->x.compareToIgnoreCase(y)

     （2）. 类：：静态方法

     （3）. 对象：：实例方法

（2）和（3）等同于lambda表达式，e.g.

System.out::println 等同于(x)->System.out.println(x)
Math::pow 等同于(x,y)->Math.pow(x,y).

此外，方法引用还可以使用this::methodName及super::methodName表示该对象或者其父类对象中的方法

还有构造器、自由变量就先不在此赘述了，以后有机会可以看：java8之lambda表达式入门 - 【兰陵笑笑生】 - 博客园

二、 Stream