Java8中Lambda表达式的理解与应用

// Java8之前：旧的写法
Runnable runnable = new Runnable() {
 @Override
 public void run() {
   System.out.println("old run");
}
};
Thread t = new Thread(runnable);

// Java8之后：新的写法
Runnable runnable1 = ()->{
 System.out.println("lambda run");
};
Thread t1 = new Thread(runnable1);

@FunctionalInterface
public interface FunctionInterfaceDemo {
   void abstractFun();
   default void fun1(){
       System.out.println("fun1");    
  }
   default void fun2(){
       System.out.println("fun2");
  }  
}

// 编译器会报错，Multiple non-overriding abstract methods found in XXX
@FunctionalInterface
public interface NoFunctionInterfaceDemo extends FunctionInterfaceDemo{
 void abstractFun2();
}

new Thread(() -> System.out.println("run")).start();

public static String processFile() throws IOException {
   // Java7新增的语法，try(){}，可自动关闭资源，减少了代码的臃肿
   try( BufferedReader bufferedReader =
       new BufferedReader(new  FileReader("./test.txt"))){
       return bufferedReader.readLine();
  }
}

@FunctionalInterface
interface FileReadInterface{
// 这里接受一个BufferedReader对象，返回一个String对象
   String process(BufferedReader reader) throws IOException;
}

// 读取一行
FileReadInterface fileReadInterface = reader -> reader.readLine();
// 读取两行
FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine();

// 参数为第二步我们自己手写的函数式接口
public static String processFile(FileReadInterface fileReadInterface) throws IOException {
       try( BufferedReader bufferedReader =
                new BufferedReader(new FileReader("./test.txt"))){
// 这里我们不再自己定义行为，而是交给函数式接口的抽象方法来处理，然后通过lambda表达式的传入来实现多个行为
         return fileReadInterface.process(bufferedReader);
      }
  }

public class FileReaderDemo {
   public static void main(String[] args) throws IOException {
// 第三步：
    // lambda表达式1 传给 函数式接口：只读取一行
    FileReadInterface fileReadInterface = reader -> reader.readLine();
// lambda表达式2 传给 函数式接口：只读取两行
    FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine();
    // 最后一步： 不同的函数式接口的实现，表现出不同的行为
       String str1 = processFile(fileReadInterface);
       String str2 = processFile(fileReadInterface2);
       System.out.println(str1);
       System.out.println(str2);
  }
// 第四步： 读取文件方法，接受函数式接口作为参数
   public static String processFile(FileReadInterface fileReadInterface) throws IOException {
       try( BufferedReader bufferedReader =
                new BufferedReader(new FileReader("./test.txt"))){
// 调用函数式接口中的抽象方法来处理数据
         return fileReadInterface.process(bufferedReader);
      }
  }
// 第一步：
 public static String processFile() throws IOException {
       try( BufferedReader bufferedReader =
                new BufferedReader(new FileReader("./test.txt"))){
         return bufferReader.readLine();
      }
  }


}

// 第二步： 我们手写的函数式接口
@FunctionalInterface
interface FileReadInterface{
   String process(BufferedReader reader) throws IOException;
}

@FunctionalInterface
public interface Function<T, R> {
// 都是接受一个参数，返回另一个参数
 R apply(T t);
}

// 简化前
Function<Cat, Integer> function = c->c.getAge();
// 简化后
Function<Cat, Integer> function2 = Cat::getAge;

public class ReferenceDemo {
   public static void main(String[] args) {
       // 第一种:引用对象的实例方法
       Cat cat = new Cat(1);
       Function<Cat, Integer> methodRef1 = cat::getSum;
       // 第二种:引用类的静态方法
       Supplier<Integer> methodRef2 = Cat::getAverageAge;
       // 第三种：引用类的实例方法
       Function<Cat, Integer> methodRef3 = Cat::getAge;
  }
}
class Cat {
   int age;

   public Cat(int age) {
       this.age = age;
  }

   // 获取猫的平均年龄
   public static int getAverageAge(){
       return 15;
  }
   // 获取两只猫的年龄总和
   public int getSum(Cat cat){
       return cat.getAge() + this.getAge();
  }

   public int getAge() {
       return age;
  }    public void setAge(int age) {
       this.age = age;
  }
}

// 这里调用 new Cat()
Supplier<Cat> constructRef1 = Cat::new;
// 这里调用 new Cat(Integer)
Function<Integer, Cat> constructRef2 = Cat::new;

public static void main(String[] args) {
 String str = "javalover.cc";
 Runnable runnable = ()->{
   str = "1";// 这里会报错，因为修改了str引用的指向
   System.out.println(str);
}
}

// 重点代码
public class ComposeDemo {
   public static void main(String[] args) {
       List<Dog> list = Arrays.asList(new Dog(1,2), new Dog(1, 1));
       // 1. 先按年龄排序（默认递增）
    // Dog::getAge, 上面介绍的方法引用
    // comparingInt, 是Comparator的一个静态方法，返回Comparator<T>
    Comparator<Dog> comparableAge = Comparator.comparingInt(Dog::getAge);
       // 2. 如果有相同的年龄，则年龄相同的再按体重排序（如果年龄已经比较出大小，则下面的体重就不会再去比较）
       Comparator<Dog> comparableWeight = Comparator.comparingInt(Dog::getWeight);;
       // 3. 调用list对象的sort方法排序，参数是Comparator<? super Dog>
       list.sort(comparableAge.thenComparing(comparableWeight));
       System.out.println(list);
  }
}
// 非重点代码
class Dog{
   private int age;
   private int weight;

   public Dog(int age, int weight) {
       this.age = age;
       this.weight = weight;
  }

   public int getAge() {
       return age;
  }

   public void setAge(int age) {
       this.age = age;
  }

   public int getWeight() {
       return weight;
  }

   public void setWeight(int weight) {
       this.weight = weight;
  }

   @Override
   public String toString() {
       return "Dog{" +
               "age=" + age +
               ", weight=" + weight +
               '}';
  }
}