lambda表达式，方法引用详解 函数式接口全面应用

/**
 * @auther SyntacticSugar
 * @data 2018/9/2 0002下午 3:09
 */
public class Test01 {
    public static void main(String[] args) {
        //无参有返回值
        String s = eatFood(() -> "吃饭吧");
        System.out.println(s);
    }
    public static String eatFood(Eatable eatable) {
        return eatable.eat();
    }
}

@FunctionalInterface
interface Eatable {
    String eat();
}

 

 

---

lambda作为参数传递

      条件：函数式接口

                创建方法，在main中调用方法

/**
 * @auther SyntacticSugar
 * @data 2018/9/2 0002下午 7:45
        //无参无返回值的参数
 */


public class Test02 {
    public static void main(String[] args) {
        getTest(true,()-> System.out.println("lambda 调用了函数式接口的方法"));

    }
    //方法
    public  static void getTest(boolean flag,Myfunctional myfunctional){
        //判断
        if(flag){
            myfunctional.show();
        }else {
            System.out.println("方法没有被调用");
        }
    }
}

interface Myfunctional {
    void show();
}

 

 

常见的函数式编程：

如下：

  void accept（T t） 有参无返回值。 

import java.util.function.Consumer;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 10:12
 *
 * 通过链式   andthen  写出更多
 * void   accept(T t)
 */
public class Test01 {
    public static void main(String[] args) {
//调用方法
        myMethod("北京我来了",(s)-> System.out.println(s+"方法1") ,(s)-> System.out.println(s+"方法2") );
        //使用同一个参数， 先后执行one  two   的lambda表达式
    }
    public  static void myMethod(String str, Consumer<String> one,Consumer<String> two){
            //
        one.andThen(two).accept(str);
    }
}

 

 

lambda 的拼接使用：

import java.util.function.Consumer;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 10:23
 *
 *
 * String[] strArr = {"歌神,张学友", "舞王,郭富城", "综合,刘德华", "文艺,黎明"};
 */
public class Test02 {
    public static void main(String[] args) {
        //
        String[] strArr = {"歌神,张学友", "舞王,郭富城", "综合,刘德华", "文艺,黎明"};

        printArr(strArr,(s)-> System.out.print(s.split(",")[0]),(s)-> System.out.println(s.split(",")[1]));


    }
    public  static  void printArr(String[] s, Consumer<String> one,Consumer<String> two){
        for (String s1 : s) {
        one.andThen(two).accept(s1);//遍历

        }
    }
}

 

 

• • boolean	test​(T t)	在给定的参数上评估这个谓词。

Predicate   函数式接口的test方法应用：

有参返回一个boolean 类型的方法：   使用步骤如下

①main中创建方法  method，函数式接口作为参数传递

②调用method，把lambda 传参使用

 

import java.util.function.Predicate;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 10:34
 *
 *boolean test​(T t) 在给定的参数上评估这个谓词。
 *
 */
public class Test03 {
    public static void main(String[] args) {

        printLline("sdfd",(s)->s.length()>5);
        //
        printLline("sdfdsdfdfdf",(s)->s.length()>5);


    }
    public static  void printLline(String str, Predicate<String> one){
            //test 返回一个boolean
        boolean test = one.test(str);
        System.out.println(str+"str长度大于5么"+test);

    }
}

 

 

 

and  的使用：

package Test01;

import java.util.function.Predicate;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 10:33
 * default Predicate<T> and​(Predicate<? super T> other) 返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND。
 *同步判断   string  中是否包含   s   g
 *
 * 固定步骤   ①创建方法
 * ②调用方法
 *
 */
public class Test04 {
    public static void main(String[] args) {
        //
        strContains("string",(s)-> s.contains("s"),(s)->s.contains("g"));
        //
        strContains("我是王大嘴",(s)-> s.contains("大嘴"),(s)->s.contains("怪"));
        
        /*string是否同时包含？true
        我是王大嘴是否同时包含？false*/

    }

    public  static  void strContains(String str, Predicate<String> one,Predicate<String> two){
        boolean test = one.and(two).test(str);//
        System.out.println(str+"是否同时包含？"+test);
    }
}

 

or的使用

 

 

</>

package Test01;

import java.util.function.Predicate;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 11:03
 *
 *
 */
public class Test05 {
    public static void main(String[] args) {
        orMethod("我是你二大爷的远方表叔的堂哥的弟妹的叔叔的三连襟的同学的女朋友的前男友的朋友啊",
                (s)->s.contains("er"),(s)->s.contains("大爷"),(s)->s.length()>15);
        //这几种情况满足其中之一么？true
        
        
    }
    public static void orMethod(String str, Predicate<String> one, Predicate<String> two,Predicate<String> three){
        boolean test = one.or(two).or(three).test(str);
        System.out.println("这几种情况满足其中之一么？"+test);

    }
}

 negate的否定

package Test01;

import java.util.function.Predicate;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 11:13
 * <p>
 * default Predicate<T> negate​() 返回表示此谓词的逻辑否定的谓词。
 * <p>
 * 就是否定的     true  ---》false
 */
public class Test06 {
    public static void main(String[] args) {
        //
        String str1=null;
        String str2="   ";
        strMethod(str1,(s)->s==null||s.trim().equals("") );

        strMethod(str2,(s)->s==null||s.trim().equals("") );

    }

    public static void strMethod(String str, Predicate<String> one) {
        boolean test = one.test(str);
        System.out.println("是否为空？"+test);

        //调用 negate  方法

        boolean test1 = one.negate().test(str);
        System.out.println("调用negate 方法以后" + test1);

    }

}

 

 

 

 

 

 

 

 

集合的刷选

package Test01;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 11:28
 * String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
 * <p>
 * 名字4 个字   女的     这两个条件的合要求的字符串筛选到集合ArrayList中
 */
public class Test07 {
    public static void main(String[] args) {
        //
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女"};
        List<String> list = myMethod(array, (s) -> s.split(",")[0].length() == 4, (s) -> s.split(",")[1].equals("女"));
        System.out.println(list);//集合中切分字符串判断
        //[迪丽热巴,女, 古力娜扎,女]
    }

    public static List<String> myMethod(String[] array, Predicate<String> one, Predicate<String> two) {
        ArrayList<String> list1 = new ArrayList<>();
        for (String str : array) {
            boolean test = one.and(two).test(str);
            if (test) {
                list1.add(str);
            }

        }


        return list1;
    }
}

function的   apply  应用

 

package Test01;

import java.util.function.Function;

/**
 * @auther SyntacticSugar
 * @data 2018/9/3 0003上午 11:46
 * <p>
 * <p>
 * function  接口
 * T - 函数输入的类型
 * R - 函数结果的类型
 * <p>
 * R apply​(T t) 将此函数应用于给定的参数。
 *
 *
 * default <V> Function<T,V> andThen​(Function<? super R,? extends V> after) 返回一个组合函数，
 * 首先将该函数应用于其输入，然后将 after函数应用于结果。
 */
public class Test08 {
    public static void main(String[] args) {
        //
        Integer integer = strToInteger("10", (s) -> Integer.parseInt(s));
        int s=integer+2;
        System.out.println(s);//12

        Integer integer1 = strToInteger("10", Integer::parseInt);
        int s1=integer1+10;
        System.out.println(s1); //20

        System.out.println("-----------------------------");
        Integer integer2 = strToInteger2("20", (s3) -> Integer.parseInt(s3), (num) -> num + 10);
        System.out.println(integer2);//


    }

    public static Integer strToInteger(String str, Function<String, Integer> one) {

        Integer apply = one.apply(str);
//        System.out.println(apply);
        return apply;
    }
    public static Integer strToInteger2(String str, Function<String, Integer> one,Function<Integer, Integer> two) {

        Integer apply = one.andThen(two).apply(str);
//        System.out.println(apply);
        return apply;
    }



}