Lambda表达式，函数式接口

Lambda表达式

示例：

定义一个接口：

public interface Animal{
   public abstract void eat();
}

定义一个测试类

public class Test{
   public static void main(String[] args){
     fun(()->{
      System.out.println("兔子吃草");
   });
  }
   public static void fun(Animal a){
     a.eat();
    }
}

这就是一个简单的Lambda表达式

Lambda表达式_函数式编程思想_相对于面向对象的优点：

1.面向对象的方式：要制作类，并创建对象，然后作为实参传递到方法中；

2.Lambda：不需要制作类，不需要创建对象，直接传递一个方法作为实参，可以节省代码的编写。

Lambda表达式标准格式：

fun(()->{

System.out.println("兔子吃草...");

});

1.一对小括号：表示形参

2.一个右箭头：->

3.一对大括号：方法体

Lambda表达式的前提条件

1.必须要有一个接口；

2.接口中有且只能有一个抽象方法（可以定义参数、返回值）必须有、且只有一个抽象方法；其它静态方法、默认方法有没有、有多少都无所谓。

例如：

public static void main(String[] args){
   //调用方法，传递实参时----前提：方法的形参必须是接口，而且里面有且只有一个抽象方法
   fun(()->{
       System.out.println("小兔子吃草...");
 });
   //声明变量
   Animal a=()->{
            System.out.println("小兔子吃草...");}
   //作为返回值
   Aniaml animal=getAniaml();
   animal.eat();
  }
  public static void fun(Aniaml a){
     a.eat();
  } 
  public static Animal getAnimal(){
     return ()->{System.out.println("小兔子吃草...");}
  } 
}

带参数和返回值

定义一个接口，接口中抽象方法带参数和返回值

public interface MyMath{
  public abstract int calc(int a,int b);
}

调用

public class Demo{
  public static void amin(String[] args){
    fun((int m,int n)->{
       return a*b;
    },10,20);
  }
   public static void fun(MyMath myMath,int a,int b){
      int result= myMath.calc(a,b);
      System.out.println("结果是："+result);
  }
}

Lambda表达式的省略格式及省略规则

1.关于Lambda表达式的参数：   形参的“数据类型”都可以省略

         例如：

fun((a,b)->{
  return a*b;
},10,20);

2.如果只有一个形参，可以同时省略：数据类型，一对小括号；（如果省略小括号，必须省略数据类型）

   例如：

 

fun(a->{
  return a;
},10);

3.Lambda表达式的方法体 

      如果方法体中只有一句话：可以同时省略：一对大括号，return关键字，这条语句后的分号（要省全省，要用全用）

例如

fun(a->a,10);

接口在类库架构中的作用：

优点：接口和实现分离了，适于团队的协作开发，主要是为了实现松散耦合的系统，便于以后的升级，扩展。

缺点：设计艰难，在你没有写实现的时候，就得想好接口，接口一变，全部乱套，这就是所谓的设计比实现难

函数式接口

1.有，且只有一个抽象方法的接口叫函数式接口

2.通常为了使用Lambda表达式，所以经常会特意的定义一些“函数式接口”。

3.为了避免定义函数式接口错误，Java为我们提供了一个“注解”，它类似于“@Override”--重写  注解，是给编译器看的

       让编译器给我们检查这个接口是否是一个合格的函数式接口     注解名：@FactionalInterface

示例代码：

@FunctionalInterface
Public interface Animal{
    public abstract void eat();
}

函数式接口_Supplier接口（生产者接口）

1.抽样方法原型           T    get();

public class Demo{
   public static void main(String[] args){
      fun(()->"HelloWorld");
  }

//此方法需要一个Supplier的子类对象，为fun（）返回一个String对象 
  public static void fun(Supplier<String> s){
     String str=s.get();
     System.out.println(s);
  } 
}

函数式接口_Consumer接口（消费者接口）

抽象方法原型        void   accept(T  t);

public class Demo{
  public static void main(String[] args){
     fun(s->System.out.println("转换为大写输出："+s.toUpperCase()),"hello");
   }
//此方法需要一个Consumer和一个String
//此方法内会将String传给Consumer，子类决定做什么
  public static void fun(Consumer<String> c,String s){
      c.accept(s);
  }
}

默认方法           andThen()    当需要连续两次处理同一个数据时，可以使用这个方法

public class Demo{
    public static void main(String[] args){
       fun(s->System.out.println("转换为大写："+s.toUpperCase()),
            s->System.out.println("转换为小写："+s.toLowerCase()),"helloworld");
  }
    public static void fun(Consumer<String> c1,Consumer<String> c2,String str){
     /*先调用c1.accept()然后在调用c2.accept()
        c1.accept(str);
        c2.accept(str);
       */
       c1.andThen(c2).accept(str);
  }
}

函数式接口_Function接口（函数）

抽象方法原型   R apply(T,t)    接受第一个泛型类型，返回第二个泛型类型，通常是用做“转换”

默认方法        anThen   当需要将一个数据进行两次连续的转换时，可以使用此方法

public class Demo{
    public static void main(String[] args){
     fun(s->Integre.parseInt(s)+10,n->Integer.toString(n),"25");
  }
    public static void fun(Function<String,Integer> f1,Function<Integer,String> f2,String age){
     /*
        Integre intAge=f1.apply(age);
        String  str=f2.apply(intAge);  
     */
      String str=f1.andThen(f2).apply(age);
      System.out.println("字符串的结果为："+str);
  }
}

函数式接口_Predicate接口（判断接口）

抽象方法原型：  boolean test（T,t）；

示例代码：

public class Demo{
     public static void main(String[] args){
        fun(s->s.length()>5,"Hell")
  }
     public static void fun(Perdicate<String> p1,String s){
      boolean b=p.test(s);
      System.out.println("判断的结果为："+b);
  }
}

默认方法    and() 可以将两个Predicate的判断做逻辑与的判断

                   or()可以将两个Predicate的判断做逻辑或的判断

                   negate()将一个Predicate的判断取反

public class Demo{
   public static void main(String[] args){
        fun(s->s.contains("H"),s->s.contains("W"),"HelloWorld");
   }
   public static void fun(Predicate<String> p1,Predicate<String> p2,String s){
      /*boolean b1=p1.test(s);
        boolean b2=p2.test(s);
        System.out.println(b1&&b2);
                              */
      boolean b2=p1.and(p2).test(s);
  }
}