// @FunctionalInterface 注解說明： 
// 使用該注解來定義接口，編譯器會強(qiáng)制檢查接口是否符合函數(shù)式接口規(guī)則（有且僅有一個(gè)抽象方法），如果不符合則會報(bào)錯(cuò)。
@FunctionalInterface
public interface MyInterface{
 /**
 * 抽象方法（Jdk 8 以后接口類中方法可以省去 public abstract）
 */
 public abstract [返回值類型] [方法名稱](參數(shù)列表);
 
 /**
 * 其它方法（Jdk 8 以后允許接口類中添加"默認(rèn)方法"與"靜態(tài)方法" ）
 */
 ...(略)
}

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

@FunctionalInterface
public interface Predicate<T> {
 /** abstract 方法，接收一個(gè)參數(shù), 判斷這個(gè)參數(shù)是否匹配某種規(guī)則, 然后返回布爾值結(jié)果 */
 boolean test(T t);
 
 /** default 方法，接收另外一個(gè) Predicate<T> 類型參數(shù)進(jìn)行"邏輯與"操作，返回一個(gè)新的 Predicate */
 default Predicate<T> and(Predicate<? super T> other) {
 Objects.requireNonNull(other);
 return (t) -> test(t) && other.test(t);
 }
 
 /** default 方法，接收另外一個(gè) Predicate<T> 類型參數(shù)進(jìn)行"邏輯或"操作，返回一個(gè)新的 Predicate */
 default Predicate<T> negate() {
 return (t) -> !test(t);
 }
 
 /** default 方法，返回當(dāng)前 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 {

 /** 這里創(chuàng)建一個(gè) Prodicate，設(shè)置驗(yàn)證秘鑰的一個(gè)邏輯，然后返回并輸出驗(yàn)證結(jié)果 */
 public static void main(String[] args) {
 // 創(chuàng)建 Predicate 及 Lambda 表達(dá)式與待實(shí)現(xiàn)的邏輯
 Predicate<String> validation = (String secret) -> {
 return "123456".equals(secret);
 };
 // 調(diào)用 Predicate 提供的 test 方法并輸出結(jié)果
 System.out.println(validation.test("123"));
 System.out.println(validation.test("123456"));
 } 
 
}

@FunctionalInterface
public interface Consumer<T> {

 /** abstract 方法，接收一個(gè)參數(shù)，執(zhí)行消費(fèi)邏輯 */
 void accept(T t);
 
 /** default 方法，將兩個(gè) Consumer 連接到一起，再進(jìn)行消費(fèi) */
 default Consumer<T> andThen(Consumer<? super T> after) {
 Objects.requireNonNull(after);
 return (T t) -> { accept(t); after.accept(t); };
 }
 
}

/** 這里創(chuàng)建一個(gè) Consumer，模擬發(fā)送消息并打印內(nèi)容 */
public class ConsumerExample {

 public static void main(String[] args) {
 // 創(chuàng)建 Consumer 及 Lambda 表達(dá)式與待實(shí)現(xiàn)的邏輯
 Consumer<String> consumer = (String message) -> {
 System.out.println("發(fā)送消息內(nèi)容：" + message);
 };
 // 調(diào)用 Consumer 提供的 accept 方法
 consumer.accept("測試消息");
 } 
 
}

@FunctionalInterface
public interface Function<T, R> {
 /**abstract 方法，接收一個(gè)參數(shù)進(jìn)行處理，然后返回處理結(jié)果 R */
 R apply(T t);

 /** default 方法，先執(zhí)行參數(shù)(Function)的，再執(zhí)行調(diào)用者(Function) */
 default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
 Objects.requireNonNull(before);
 return (V v) -> apply(before.apply(v));
 }
 
 /** default 方法，先執(zhí)行調(diào)用者，再執(zhí)行參數(shù)，和compose相反 */
 default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
 Objects.requireNonNull(after);
 return (T t) -> after.apply(apply(t));
 }
 
 /** 返回當(dāng)前正在執(zhí)行的方法 */
 static <T> Function<T, T> identity() {
 return t -> t;
 }
}

/** 這里創(chuàng)建一個(gè) Function，對傳入的參數(shù)進(jìn)行驗(yàn)證，如果包含 a 字符就返回1，否則返回0 */
public class FunctionExample {

 public static void main(String[] args) {
 // 創(chuàng)建 Function 及 Lambda 表達(dá)式與待實(shí)現(xiàn)的邏輯
 Function<String, Integer> function = (String str) -> {
 return str.contains("a") ? 1 : 0;
 };
 // 調(diào)用 Function 提供的 apply 方法
 System.out.println(function.apply("abcd"));
 System.out.println(function.apply("efgh"));
 }
 
}

@FunctionalInterface
public interface Supplier<T> {
 /** abstract 方法，設(shè)置業(yè)務(wù)邏輯，獲取邏輯中創(chuàng)建的對象 */
 T get();
}

/** 這里創(chuàng)建一個(gè) Supplier，用于生成隨機(jī)ID，通過 get 方法獲取生成的隨機(jī)ID值 */
public class SupplierExample {

 public static void main(String[] args) {
 // 創(chuàng)建 Supplier 及 Lambda 表達(dá)式與待實(shí)現(xiàn)的邏輯
 Supplier<String> supplier = () -> {
 return UUID.randomUUID().toString();
 };
 // 調(diào)用 Supplier 提供的 get 方法
 System.out.println(supplier.get());
 }

}

// 可以看到 UnaryOperator 繼承了 Function 接口
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
 /** static 方法，接收一個(gè)參數(shù)，然后對其處理后再返回 */
 static <T> UnaryOperator<T> identity() {
 return t -> t;
 }
}

/** 這里創(chuàng)建一個(gè) UnaryOperator，接收一個(gè)字符串進(jìn)行加工處理后返回新字符串 */
public class UnaryOperatorExample {
 
 public static void main(String[] args) {
 // 創(chuàng)建 UnaryOperator 及 Lambda 表達(dá)式與待實(shí)現(xiàn)的邏輯
 UnaryOperator<String> unaryOperator = (String str) -> {
 return "[" + str + "]";
 };
 // 調(diào)用 UnaryOperator 繼承的 Function 提供的 apply 方法
 System.out.println(unaryOperator.apply("hello"));
 }

}

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
 /** abstract 方法，通過比較器Comparator來比較兩個(gè)元素中較小的一個(gè)作為返回值返回 */
 public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
 Objects.requireNonNull(comparator);
 return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
 }
 
 /** 通過比較器Comparator來比較兩個(gè)元素中較大的一個(gè)作為返回值返回 */
 public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
 Objects.requireNonNull(comparator);
 return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
 }
}

/** 這里創(chuàng)建一個(gè) BinaryOperator，比較傳入的兩個(gè)參數(shù)哪個(gè)值最大，返回最大值 */
public class BinaryOperatorExample {

 public static void main(String[] args) {
 // 創(chuàng)建 BinaryOperator 及 Lambda 表達(dá)式與待實(shí)現(xiàn)的邏輯
 BinaryOperator<Integer> binaryOperator = (Integer t1, Integer t2) -> {
 return t1 > t2 ? t1 : t2;
 };
 // 調(diào)用 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() {
 // 方法內(nèi)部變量
 String str2 = "方法內(nèi)部變量";
 // 使用匿名內(nèi)部類創(chuàng)建線程
 new Thread(new Runnable() {
  // 匿名內(nèi)部類內(nèi)部變量
  String str3 = "匿名內(nèi)部類內(nèi)部變量";
  @Override
  public void run() {
  /* 訪問變量 */
  System.out.println("匿名內(nèi)部類輸出：" + str1);
  System.out.println("匿名內(nèi)部類輸出：" + str2);
  System.out.println("匿名內(nèi)部類輸出：" + str3);
  /* 修改變量 */
  str1 = "修改訪問成員變量";
  // str2 = "修改訪問方法內(nèi)部變量"; // 不能進(jìn)行修改，默認(rèn)推導(dǎo)變量的修飾符 final
  str3 = "修改訪問匿名內(nèi)部類內(nèi)部變量";
  /* 在匿名內(nèi)部類中定義和類外部變量一樣名稱的變量 */
  String str1 = "重新命名成員變量";
  String str2 = "重新命名方法內(nèi)部變量";
  }
 }).start();
 }
 
 /** Main 方法 */
 public static void main(String[] args) {
 VariableExample variableExample = new VariableExample();
 // 匿名內(nèi)部類
 variableExample.innerClass();
 }

}

public class VariableExample {
 /** 成員變量 */
 String str1 = "成員變量";
 
 public void lambdaExpression() {
 // 方法內(nèi)部變量
 String str2 = "方法內(nèi)部變量";
 new Thread(()->{
  // Lambda 內(nèi)部變量
  String str3 = "Lambda 內(nèi)部變量";
  /* 訪問變量 */
  // 訪問成員變量
  System.out.println("Lambda 表達(dá)式輸出：" + str1);
  // 訪問方法內(nèi)部變量
  System.out.println("Lambda 表達(dá)式輸出：" + str2);
  // 訪問匿名內(nèi)部類內(nèi)部變量
  System.out.println("Lambda 表達(dá)式輸出：" + str3);
  /* 修改變量 */
  str1 = "修改訪問成員變量";
  // str2 = "修改訪問方法內(nèi)部變量"; // 不能進(jìn)行修改，默認(rèn)推導(dǎo)變量的修飾符 final
  str3 = "修改訪問匿名內(nèi)部類內(nèi)部變量";
  /* 在 Lambda 中定義和類外部變量一樣名稱的變量 */
  String str1 = "重新命名成員變量";
  // String str2 = "重新命名方法內(nèi)部變量"; // 不能命名，lambda 不支持變量隱藏
 }).start();
 }

 /** Main 方法 */
 public static void main(String[] args) {
 VariableExample variableExample = new VariableExample();
 // 匿名內(nèi)部類
 variableExample.innerClass();
 // Lambda 表達(dá)式
 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) {
 // 使用匿名內(nèi)部類
 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 表達(dá)式
 //method(param -> System.out.println(param)); // 編譯器提示錯(cuò)誤，表示無法推斷使用哪個(gè)參數(shù)
 }

}

// 轉(zhuǎn)換參數(shù)為 MyInterfaceA
method((MyInterfaceA)param -> System.out.println(param));
// 轉(zhuǎn)換參數(shù)為 MyInterfaceB
method((MyInterfaceB)param -> System.out.println(param));

public class Person {
 /** 姓名 */
 private String name;
 /** 歲數(shù) */
 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 {

 /** 測試的靜態(tài)方法 */
 public static int compareAge(Person p1, Person p2) {
 return p1.getAge() - p2.getAge();
 }

 public static void main(String[] args) {
 // 創(chuàng)建 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));
 
 // 按歲數(shù)進(jìn)行排序，使用靜態(tài)方法引用
 personList.sort(StaticMethodExample::compareAge);
 }

}

public class PersonUtil{
 /** 測試的實(shí)例方法 */
 public int compareAge(Person p1, Person p2) {
 return p1.getAge() - p2.getAge();
 }
}

public class InstanceMethodExample {

 public static void main(String[] args) {
 // 創(chuàng)建 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));
 
 // 按歲數(shù)進(jìn)行排序，
 PersonUtil personUtil = new PersonUtil();
 // 引用實(shí)例方法
 personList.sort(personUtil::compareAge);
 }

}

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

public class LambdaConstructorMethodExample {

 public static void main(String[] args) {
 // 創(chuàng)建 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));

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

public class LambdaExample {

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

}