Java8如何使用Lambda表达式简化代码详解

// @FunctionalInterface 注解说明： 
// 使用该注解来定义接口，编译器会强制检查接口是否符合函数式接口规则（有且仅有一个抽象方法），如果不符合则会报错。
@FunctionalInterface
public interface MyInterface{
 /**
 * 抽象方法（Jdk 8 以后接口类中方法可以省去 public abstract）
 */
 public abstract [返回值类型] [方法名称](参数列表);
 
 /**
 * 其它方法（Jdk 8 以后允许接口类中添加"默认方法"与"静态方法" ）
 */
 ...(略)
}

@FunctionalInterface
public interface MyCollection {
 
 void push(List list);
 
}

@FunctionalInterface
public interface Predicate<T> {
 /** abstract 方法，接收一个参数, 判断这个参数是否匹配某种规则, 然后返回布尔值结果 */
 boolean test(T t);
 
 /** default 方法，接收另外一个 Predicate<T> 类型参数进行"逻辑与"操作，返回一个新的 Predicate */
 default Predicate<T> and(Predicate<? super T> other) {
 Objects.requireNonNull(other);
 return (t) -> test(t) && other.test(t);
 }
 
 /** default 方法，接收另外一个 Predicate<T> 类型参数进行"逻辑或"操作，返回一个新的 Predicate */
 default Predicate<T> negate() {
 return (t) -> !test(t);
 }
 
 /** default 方法，返回当前 Predicate 取反操作之后的 Predicate */
 default Predicate<T> or(Predicate<? super T> other) {
 Objects.requireNonNull(other);
 return (t) -> test(t) || other.test(t);
 }

 static <T> Predicate<T> isEqual(Object targetRef) {
 return (null == targetRef)
 ? Objects::isNull
 : object -> targetRef.equals(object);
 }
}

public class PredicateExample {

 /** 这里创建一个 Prodicate，设置验证秘钥的一个逻辑，然后返回并输出验证结果 */
 public static void main(String[] args) {
 // 创建 Predicate 及 Lambda 表达式与待实现的逻辑
 Predicate<String> validation = (String secret) -> {
 return "123456".equals(secret);
 };
 // 调用 Predicate 提供的 test 方法并输出结果
 System.out.println(validation.test("123"));
 System.out.println(validation.test("123456"));
 } 
 
}

@FunctionalInterface
public interface Consumer<T> {

 /** abstract 方法，接收一个参数，执行消费逻辑 */
 void accept(T t);
 
 /** default 方法，将两个 Consumer 连接到一起，再进行消费 */
 default Consumer<T> andThen(Consumer<? super T> after) {
 Objects.requireNonNull(after);
 return (T t) -> { accept(t); after.accept(t); };
 }
 
}

/** 这里创建一个 Consumer，模拟发送消息并打印内容 */
public class ConsumerExample {

 public static void main(String[] args) {
 // 创建 Consumer 及 Lambda 表达式与待实现的逻辑
 Consumer<String> consumer = (String message) -> {
 System.out.println("发送消息内容：" + message);
 };
 // 调用 Consumer 提供的 accept 方法
 consumer.accept("测试消息");
 } 
 
}

@FunctionalInterface
public interface Function<T, R> {
 /**abstract 方法，接收一个参数进行处理，然后返回处理结果 R */
 R apply(T t);

 /** default 方法，先执行参数(Function)的，再执行调用者(Function) */
 default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
 Objects.requireNonNull(before);
 return (V v) -> apply(before.apply(v));
 }
 
 /** default 方法，先执行调用者，再执行参数，和compose相反 */
 default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
 Objects.requireNonNull(after);
 return (T t) -> after.apply(apply(t));
 }
 
 /** 返回当前正在执行的方法 */
 static <T> Function<T, T> identity() {
 return t -> t;
 }
}

/** 这里创建一个 Function，对传入的参数进行验证，如果包含 a 字符就返回1，否则返回0 */
public class FunctionExample {

 public static void main(String[] args) {
 // 创建 Function 及 Lambda 表达式与待实现的逻辑
 Function<String, Integer> function = (String str) -> {
 return str.contains("a") ? 1 : 0;
 };
 // 调用 Function 提供的 apply 方法
 System.out.println(function.apply("abcd"));
 System.out.println(function.apply("efgh"));
 }
 
}

@FunctionalInterface
public interface Supplier<T> {
 /** abstract 方法，设置业务逻辑，获取逻辑中创建的对象 */
 T get();
}

/** 这里创建一个 Supplier，用于生成随机ID，通过 get 方法获取生成的随机ID值 */
public class SupplierExample {

 public static void main(String[] args) {
 // 创建 Supplier 及 Lambda 表达式与待实现的逻辑
 Supplier<String> supplier = () -> {
 return UUID.randomUUID().toString();
 };
 // 调用 Supplier 提供的 get 方法
 System.out.println(supplier.get());
 }

}

// 可以看到 UnaryOperator 继承了 Function 接口
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
 /** static 方法，接收一个参数，然后对其处理后再返回 */
 static <T> UnaryOperator<T> identity() {
 return t -> t;
 }
}

/** 这里创建一个 UnaryOperator，接收一个字符串进行加工处理后返回新字符串 */
public class UnaryOperatorExample {
 
 public static void main(String[] args) {
 // 创建 UnaryOperator 及 Lambda 表达式与待实现的逻辑
 UnaryOperator<String> unaryOperator = (String str) -> {
 return "[" + str + "]";
 };
 // 调用 UnaryOperator 继承的 Function 提供的 apply 方法
 System.out.println(unaryOperator.apply("hello"));
 }

}

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
 /** abstract 方法，通过比较器Comparator来比较两个元素中较小的一个作为返回值返回 */
 public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
 Objects.requireNonNull(comparator);
 return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
 }
 
 /** 通过比较器Comparator来比较两个元素中较大的一个作为返回值返回 */
 public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
 Objects.requireNonNull(comparator);
 return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
 }
}

/** 这里创建一个 BinaryOperator，比较传入的两个参数哪个值最大，返回最大值 */
public class BinaryOperatorExample {

 public static void main(String[] args) {
 // 创建 BinaryOperator 及 Lambda 表达式与待实现的逻辑
 BinaryOperator<Integer> binaryOperator = (Integer t1, Integer t2) -> {
 return t1 > t2 ? t1 : t2;
 };
 // 调用 BinaryOperator 继承的 BiFunction 提供的 apply 方法
 System.out.println(binaryOperator.apply(1, 2));
 }

}

() -> System.out.println("测试");

(x) -> System.out.println(x);

x -> System.out.println(x);

Comparator<Integer> comparator = (x, y) -> {
 System.out.println("测试");
 return Integer.compare(x,y);
};

Comparator<Integer> Comparator = (x, y) -> Integer.compare(x, y);

(Integer x, Integer y) -> Integer.compare();

public class VariableExample {
 /** 成员变量 */
 String str1 = "成员变量";

 public void innerClass() {
 // 方法内部变量
 String str2 = "方法内部变量";
 // 使用匿名内部类创建线程
 new Thread(new Runnable() {
  // 匿名内部类内部变量
  String str3 = "匿名内部类内部变量";
  @Override
  public void run() {
  /* 访问变量 */
  System.out.println("匿名内部类输出：" + str1);
  System.out.println("匿名内部类输出：" + str2);
  System.out.println("匿名内部类输出：" + str3);
  /* 修改变量 */
  str1 = "修改访问成员变量";
  // str2 = "修改访问方法内部变量"; // 不能进行修改，默认推导变量的修饰符 final
  str3 = "修改访问匿名内部类内部变量";
  /* 在匿名内部类中定义和类外部变量一样名称的变量 */
  String str1 = "重新命名成员变量";
  String str2 = "重新命名方法内部变量";
  }
 }).start();
 }
 
 /** Main 方法 */
 public static void main(String[] args) {
 VariableExample variableExample = new VariableExample();
 // 匿名内部类
 variableExample.innerClass();
 }

}

public class VariableExample {
 /** 成员变量 */
 String str1 = "成员变量";
 
 public void lambdaExpression() {
 // 方法内部变量
 String str2 = "方法内部变量";
 new Thread(()->{
  // Lambda 内部变量
  String str3 = "Lambda 内部变量";
  /* 访问变量 */
  // 访问成员变量
  System.out.println("Lambda 表达式输出：" + str1);
  // 访问方法内部变量
  System.out.println("Lambda 表达式输出：" + str2);
  // 访问匿名内部类内部变量
  System.out.println("Lambda 表达式输出：" + str3);
  /* 修改变量 */
  str1 = "修改访问成员变量";
  // str2 = "修改访问方法内部变量"; // 不能进行修改，默认推导变量的修饰符 final
  str3 = "修改访问匿名内部类内部变量";
  /* 在 Lambda 中定义和类外部变量一样名称的变量 */
  String str1 = "重新命名成员变量";
  // String str2 = "重新命名方法内部变量"; // 不能命名，lambda 不支持变量隐藏
 }).start();
 }

 /** Main 方法 */
 public static void main(String[] args) {
 VariableExample variableExample = new VariableExample();
 // 匿名内部类
 variableExample.innerClass();
 // Lambda 表达式
 variableExample.lambdaExpression();
 }

}

@FunctionalInterface
interface MyInterfaceA {
 void push(String param);
}

@FunctionalInterface
interface MyInterfaceB {
 void pull(String param);
}

public class LambdaOverloadExample {
 
 // 重载方法A
 public static void method(MyInterfaceA myInterfaceA) {
 myInterfaceA.push("hello 1");
 }
 // 重载方法B
 public static void method(MyInterfaceB myInterfaceB) {
 myInterfaceB.pull("Hello 2");
 }

 /** Main 方法*/
 public static void main(String[] args) {
 // 使用匿名内部类
 method(new MyInterfaceA() {
  @Override
  public void push(String param) {
  System.out.println(param);
  }
 });
 method(new MyInterfaceB() {
  @Override
  public void pull(String param) {
  System.out.println(param);
  }
 });
 // 使用 Lambda 表达式
 //method(param -> System.out.println(param)); // 编译器提示错误，表示无法推断使用哪个参数
 }

}

// 转换参数为 MyInterfaceA
method((MyInterfaceA)param -> System.out.println(param));
// 转换参数为 MyInterfaceB
method((MyInterfaceB)param -> System.out.println(param));

public class Person {
 /** 姓名 */
 private String name;
 /** 岁数 */
 private int age;

 public Person() {
 }
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
 }

 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 
 @Override
 public String toString() {
 return "Person{name=" + name + ",age=" + age + "}";
 }
}

public class StaticMethodExample {

 /** 测试的静态方法 */
 public static int compareAge(Person p1, Person p2) {
 return p1.getAge() - p2.getAge();
 }

 public static void main(String[] args) {
 // 创建 Person 集合
 List<Person> personList = new ArrayList<>();
 personList.add(new Person("Wangqin",26));
 personList.add(new Person("Liming",22));
 personList.add(new Person("Alisi",18));
 personList.add(new Person("Jerry",31));
 
 // 按岁数进行排序，使用静态方法引用
 personList.sort(StaticMethodExample::compareAge);
 }

}

public class PersonUtil{
 /** 测试的实例方法 */
 public int compareAge(Person p1, Person p2) {
 return p1.getAge() - p2.getAge();
 }
}

public class InstanceMethodExample {

 public static void main(String[] args) {
 // 创建 Person 集合
 List<Person> personList = new ArrayList<>();
 personList.add(new Person("Wangqin",26));
 personList.add(new Person("Liming",22));
 personList.add(new Person("Alisi",18));
 personList.add(new Person("Jerry",31));
 
 // 按岁数进行排序，
 PersonUtil personUtil = new PersonUtil();
 // 引用实例方法
 personList.sort(personUtil::compareAge);
 }

}

@FunctionalInterface
public interface PersonConstructor{
 Person initInstance(String name, int age);
}

public class LambdaConstructorMethodExample {

 public static void main(String[] args) {
 // 创建 Person 集合
 List<Person> personList = new ArrayList<>();
 personList.add(new Person("Wangqin", 26));
 personList.add(new Person("Liming", 22));
 personList.add(new Person("Alisi", 18));
 personList.add(new Person("Jerry", 31));

 // 构造方法引用
 PersonConstructor personConstructor = Person::new;
 Person person = personConstructor.initInstance("linda", 18);
 System.out.println(person);
 }
 
}

public class LambdaExample {

 public static void main(String[] args) {
 // 创建字符串集合
 List<String> strList = new ArrayList<>();
 strList.add("Jerry");
 strList.add("Mini");
 strList.add("Kary");
 strList.add("walls");
 
 // 使用集合的sort方法，按照String的compareToIgnoreCase进行排序（比较字符串hash值）
 strList.sort(String::compareToIgnoreCase);
 System.out.println(strList);
 }

}