Java_Lambda

Lambda

Lambda 表达式是JDK8开始新增的一种语法形式；作用：用于简化匿名内部类的代码写法

格式

（被重写方法的形参列表）->{
   被重写方法的方法体代码
}

注意：Lambda表达式只能简化函数式接口匿名的内部类！！！

什么是函数式接口？

有且仅有一个抽象方法的接口。
注意：将来我们见到的大部分函数式接口，上面都可能会有一个@FunctionInterface的注解，有该注解的接口就必定是函数式接口。

  public class LambdaTest1{
     public static void main(String[] args)
     {
         //目标:认识Lamdba表达式
         Animal a = new Animal()
         {
            @Override 
             public void runn()
             {
                 System.out.println("狗跑的贼快~~~");
             }
         };
         a.run();
  //注意：Lambda表达式并不是说能简化全部匿名内部类的写法，只能简化函数式接口的匿名内部类。
  //Animal a=()->{
//System.out.println("狗跑的贼快~~~")；
//}
 // a.run();    //错误
  //   }
  Swimming s= ()->{
     System.out.println("学生快乐的游泳~~~~~");
  }
 }

interface Swimming{
   void swim();
}


  abstract class Animal{
      public abstract void run();
  }

    public class LambadTest2{
       public static void main(String[] args)
       {
          //目标：使用Lambda简化的函数式借口
          double[] price ={99.8,128,100};
          Arrays.setAll(prices,new IntToDoublefunction(){
           @Override 
           public double applyAsDouble(int value)
           {
             // value =0 1 2;
               return prices[value]*0.8;
           }
          });
          Arrays.setAll(prices ,(int value)->{
             //value = 0 1 2
             return prices[value]*0.8;
             
          });
          System.out.println(Arrays.toString(prices));
 System.out.println("----------");

 Student[] students = new Student[4];
 student[0] = new Student("asdf");
 student[1] = new Student("asdf");
 student[2] = new Student("asdf");
 student[3] = new Student("asdf");
    Arrays.sort(student,new Comparator<Student>(){
      @Override 
      public int compare(Student o1,Student
       2){
      return Double.compare(o1.getHeight(),o2.getHeight())
          });
         
       }
  Arrays.sort(students,(Student o1,Student o2)->{
  
      return Double.compare(o1.getHeight(),o2.getHeight()))
  });
    }
  }
}    

Lambda表达式的省略写法

参数类型可以省略不写。

如果只有一个参数，参数类型可以省略，同时()也可以省略。
如果Lambda表达式中的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号！此时如果这行代码是return 语句，也必须要去掉不写。

 public class LambadTest2{
     public static void main(String[] args)
     {
        //目标：使用Lambda简化的函数式借口
        double[] price ={99.8,128,100};
        Arrays.setAll(prices,new IntToDoublefunction(){
         @Override 
         public double applyAsDouble(int value)
         {
           // value =0 1 2;
             return prices[value]*0.8;
         }
        });
        Arrays.setAll(prices ,(int value)->{
           //value = 0 1 2
           return prices[value]*0.8;
            
        });
 Arrays.setAll(prices,(int value)->{
   return prices[value] *0.8;
 });
 Arrays.setAll(prices,(value)->{return prices[value]*0.8});

  Arrays.setAll(prices,value->{
 
return prices[value]*0.8;

});
Arrays.setAll(prices,value->prices[value]*0.8);  

        System.out.println(Arrays.toString(prices));
System.out.println("----------");

Student[] students = new Student[4];
student[0] = new Student("asdf");
student[1] = new Student("asdf");
student[2] = new Student("asdf");
student[3] = new Student("asdf");
  Arrays.sort(student,new Comparator<Student>(){
    @Override 
    public int compare(Student o1,Student
     2){
    return Double.compare(o1.getHeight(),o2.getHeight())
        });
       
     }
Arrays.sort(students,(Student o1,Student o2)->{

    return Double.compare(o1.getHeight(),o2.getHeight()));
});

  Arrays.sort(student,(o1,o2)->{ return Double.compare(o1.getHeight(),o2.getHeight()));}
  );

Array .sort(student,(o1,o2)->Double.compare(o1.getHeight(),o2.getHeight())); 
  }
}
}    

JDK 8新类型：方法引用 进一步简化Lambda表达式 方法引用的标志性符号“：：”

静态方法引用

类名::静态方法。

使用场景

如果某个Lambda表达式里只是调用一个静态方法，并且前后的形式一致，就可以使用静态方法引用。

实例方法引用

对象名::实例方法

使用场景

如果某个Lambda 表达式里只是调用一个实例方法，并且前后参数一致。

public class Test1{
     public static void main(String [] args)
     {
         Student[] students = new Student[4];
         student[0]= new Student("蜘蛛精",169.5,23);
         student[1]= new Student("蜘蛛精",169.5,23);
         student[2]= new Student("蜘蛛精",169.5,23);
         student[3]= new Student("蜘蛛精",169.5,23);
         
    Arrays.sort(students,new Comparator<Student>(){
      @Override
      public int compare(Student o1,Studento2)
      {
         return o1.getAge() - o2.getAge();
      }
    });
     //使用Lambda简化后的形式
     //Arrays.sort(student,(o1,o2)->o1.getAge()-o2.getAge());
     Arrays.sort(student,(o1,o2)->CompareByData.compareByAge(o1,o2));
 
 //静态方法引用
 Arrays.sort(students,CompareByData::compareByAge)
  //实例方法引用
  CompareByDate compare = new CompareByDate();
  //Arrays.sort(students.(o1,o2)->compare.compareByAgeDesc(o1,o2));
  Arrays.sort(students,compare::compareByAgeDesc);

   System.out.println(Arrays.toString(students));  
     }
}

特定类型的方法应用
类型::方法
使用场景
如果某个Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。

 public class Test2{
    public static void main(String []args)
    {
      String [] names = {"boby","angela","Andy","dlei","caocao","Babo","jack","Cici"};
      //进行排序
      Arrays.sort(names);
      //要求忽略首字符大小写进行排序。
      //Arrays.sort(names,new Comparator<String>() { @Override 
      public int compare(String o1,String o2){
        //制定比较规则。o1="Andy" o2 ="angla"
        return o1.compareToIgnoreCase(o2);
      }
      });
      //Arrays.sort(names.(o1,o2)->o1.compareToIgnoreCase(o2));
      //特定类型的方法引用！
      Arrays.sort(names,String::compareToIgnoreCase);
     
     System.out.println(Arrays.toString(names));
     
    }
 }

构造器引用

类名::new

使用场景

如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用。

public class Test3{
   public static void main(String[] args)
   {
       //1、创建这个接口的匿名内部类对象。
       CreateCar cc = new CreateCar()
       {
          @Override 
          public Car create(String name,double price)
          {
             return new Car(name,price);
          }
       };
       //CreateCar cc =(name,price)->new Car(name,price);

       //构造器引用
         CreateCar cc = Car::new;
         Car c = cc.create("奔驰"，49.9)；
         System.out.println(c);
   }
}
interface CreateCar{
  Car create(String name,double price )
}