lambda表达式

函数式接口：有且仅有一个抽象方法的接口  借口中还可以包含其他的方法（默认方法  静态 私有）
语法糖  ：使用更加方便，但是 远离不变的 代码语法
格式  ：修饰符 interface 接口名称{
public abstract 返回值类型 方法名称（可选参数的信息）；
}
可以加一个@FunctionalInterface
作用：可以检测接口是一个函数式接口 是：编译成功  否：编译失败（借口中没有抽象方法或抽象方法的个数多余1个
@overdide注解检查方法是否为重写的方法
是：编译成功  否：编译失败

函数是接口的使用：一般可以作为方法的参数和返回值类型

函数式编程：
lambda延迟的执行：日志存在性能浪费的问题  调用showlog方法 传递的第二个参数是一个拼接后的字符串，先把字符串拼接好，然后再调用showLog方法 showLOg方法如果传递的日志等级不是1集那么就不会是如此拼接后的字符串了 存在浪费

Supplier接口：
Supplier<T>接口被称生产型接口，指定接口的泛型是什么类型 那么接口中的get方法就会生产什么类型的数据  T get（）
定义一个方法 方法的参数传递Supplier<T>接口，泛型执行String get方法就会返回一个string
public class 获取最大值 {
    public static int getMax(Supplier<Integer> sup){
        return sup.get();

    }
    public static void main(String[] args) {

        int[] arr ={-22,50,30,60,-56,-69,562,999,22};

        int max1 =getMax(() -> {
            int max = arr[0];
            for (int i : arr) {
                if (i > max) {
                    max = i;
                }

            }

        return max;

        });
        System.out.println(max1);

    }

}

Consumer接口：用于消费数据aaept（T t）;
package 练习;
 /*
    Consumer接口默认方法andThen
    作用：需要两个Consumer接口，可以把两个Consumer接口组合奥一起，在对数据进行消费
    例如：Consumer<String>con1
    Consumer<String>con2
    String s = "111";
    con1.accept(s)
    con2.accept(s)
    con1.andThen(con2).accept;谁写前面谁先消费
     */

import java.util.function.Consumer;

public class andThen {
    public static void method(String s, Consumer<String> con1,Consumer<String> con2){

//       con1.accept(s);
//       con2.accept(s);
        //使用andThen方法
        con1.andThen(con2).accept(s);

    }

    public static void main(String[] args) {
        method("Hellow",(t)->{
            //把t进行大写输出
            System.out.println(t.toUpperCase());

        },(t)->{
            System.out.println(t.toLowerCase());

        });

}

}

Predicate<T>接口：
对某种数据类型的数据进行判断 结果返回一个boolean值
predicate接口汇总包含一个抽象方法：
boolean test（T t）：用来对指定数据类型数据进行判断的方法
结果：符合条件 返回true
不符合条件 返回false
package 练习;

import java.util.function.Predicate;

public class Predicate类 {
    public static  boolean checkString(String s, Predicate<String> pre){
       return pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串

        String s="abcde";
        //调用cheackstring 方法对字符串进行校验 参数传递字符串和lambda表达式
//        boolean b = checkString(s,(String str)->{
//            //对参数传递的字符串进行判断  判断字符串的长度是否大于5，并吧判断的结果返回
//            return str.length()>5;
//        });
        boolean b = checkString(s,str->str.length()>5);

        System.out.println(b);
    }

}
and运算符
逻辑运算符：
&&  与运算符 有false则false
|| 或运算符 有true则true
！：相反
package 练习;

import java.util.function.Predicate;

public class lambda_name {
    public static  boolean compare(String s, Predicate<String> one,Predicate<String> two){
//        return  one.test(s) && two.test(s);
           return one.and(two).test(s);
    }

    public static void main(String[] args) {
        String m = "Hello world";
        boolean a = compare(m,(String str)->{
            return  str.length()>5;
        },(t)->t.contains("a"));
        System.out.println(a);
    }

}
or和nagate或和非
Function：用来根据与一个类型的数据得到另一个类型的数据
欠着称为前置条件 后者称为后置条件
Function类中最重要的抽象方法是R apply(T t),根据类型T的参数获取类型R的结果
使用场景：将String类型转化为Integer类型
package 练习;

import java.util.function.Function;

public class Functionlearn {
    public static  void change(String a, Function<String,Integer> fun){
        Integer num= fun.apply(a);
        //int num= fun.apply(a);->int类型的也可以
        System.out.println(num);
    }

    public static void main(String[] args) {
        String str = "1234";
        change(str,(t)->{
            //吧字符串转为Integer
            return Integer.parseInt(str);

        });

    }
}
Function中andThen：也是组和
package 练习;

import java.util.function.Function;

public class changePro {
    /*
    把String类型的“123”转换为Interter类型，吧转换后的结果+10
    把增加之后的Interger类型的数据，转换为String类型
    分析：首先创建change类 先把String转换为Integer类型

    因为Function类中有andthen方法 因此直接用

     */
    public static void change(String a, Function<String,Integer>fun1,Function<Integer,String>fun2){
      //       Integer num1=fun1.apply(a)+10;
     //  String s = fun2.apply(num1);
        String s =fun1.andThen(fun2).apply(a);
        System.out.println(s);

    }

    public static void main(String[] args) {
        String str2 ="123";
        change(str2,(t)->{
           Integer it = new Integer(str2);
           return  it;

        },(t)->{
            String str3 = String.valueOf(t);
            return  str3;
        });

    }
}

例子 详看4.14黑马