package lambdasinaction.chap3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.function.*;
import java.util.stream.Collectors;
/**
* lambda表达式的简单示例
*/
public class Lambdas {
public static void main(String... args) throws Exception {
/*
Predicate: 谓词，Supplier：供应，Consumer：消费
>>> 常用函数式接口
函数式接口 函数描述符 原始类型初始化
Predicate<T> T->Boolean IntPredicate,LongPredicate,DoublePredicate
Consumer<T> T->void IntConsumer,LongConsumer,DoubleConsumer
Function<T,R> T->R IntFunction<R>,IntToDoubleFunction,IntToLongFunction
LongFunction<R>,LongToIntFunction,LongToDoubleFunction
DoubleFunction<R>,DoubleToIntFunction,DoubleToLongFunction
ToIntFunction<R>,ToDoubleFunction<R>,ToLongFunction<R>
Supplier<T> ()->T BooleanSupplier,IntSupplier,DoubleSupplier,LongSupplier
UnaryOperator<T> T->T IntUnaryOperator,LongUnaryOperator,DoubleUnaryOperator
BinaryOperator<T> (T,T)->T IntBinaryOperator,DoubleBinaryOperator,LongBinaryOperator
BiPredicate<L,R> (L,R)->boolean
BiConsumer<T,U> (T,U)->void ObjIntConsumer<T>,ObjLongConsumer<T>,ObjDoubleConsumer<T>
BiFunction<T,U,R> (T,U)->R ToIntBiFunction<T,U>
ToDoubleBiFunction<T,U>
ToLongBiFunction<T,U>
>>> 应用举例
使用案例 Lambda例子 对应函数式接口
1. (List<String> list)->list.isEmpty()
T->Boolean Predicate<List<String>>
2. ()->new Apple(10)
()->T Supplier<Apple>
3. (Apple apple)->System.out.println(apple.getWeight())
(T)->void Consumer<Apple>
4. (String s)->s.Length()
T->R Function<String,Integer> / ToIntFunction<String>
5. (int a, int b)->a*b
(T,T)->T BinaryOperator<Integer> / IntBinaryOperator
6. (Apple a1, Apple a2)->a1.getWeight().compareTo(a2.getWeight())
(T,T,R)-> BiFunction<Apple,Apple,Integer> / ToIntFunction<Apple,Apple> /
Comparator<Apple>
*/
Predicate<List<String>> predicate = list -> list.isEmpty(); //定义逻辑
// predicate.negate() //取反
boolean test_result = predicate.test(new ArrayList<>()); //执行逻辑
System.out.println("predicate: " + test_result);
ToIntFunction<String> toIntFunction = s -> s.length(); //这里不能写String::length
int abc_length = toIntFunction.applyAsInt("abc");
int abcd_length = getStrLength("abcd", String::length); //作为参数，String::length可以推断
System.out.println("abc: " + abc_length + ", abcd:" + abcd_length);
Callable<Integer> callable = () -> 42;
Integer callable_result = callable.call();
System.out.println("callable: " + callable_result);
List<String> list = new ArrayList<>();
//以下两个是等价的
Predicate<String> predicate1 = s -> list.add(s); //返回了一个boolean
Consumer<String> consumer = s -> list.add(s); //返回void
predicate1.test("aa");
consumer.accept("bb");
System.out.println("list: " + list);
/*
>>> 方法引用 与 类型推断
1.::方法引用只在作为参数时使用
三类方法引用：
1.指向静态方法的引用，如Integer:parseInt
2.指向任意类型实例方法的引用，如String::length
3.指向现有对象的实例方法的引用，如obj::getValue
例子：
(Apple a)->a.getWeight() Apple::getWeight
()->Thread.currentThread().dumpStack() Thread.currentThread()::dumpStack
(str, i)->str.substring(i) String::substring
(String s)->System.out.println(s) System.out::println
*/
//System.out::println的签名是：接收String，没有返回
myPrint("test_print", System.out::println); //输出test_print
String r1 = mySub2("abcdef", 2, String::substring); //"abcdef".substring(2)
System.out.println(r1);
// mySub21("abcde",2,String::substring); //不能用String::substring,因mySub21签名是：接收一个参数Integer,返回String,这里无法推断
String str = "abcdef";
String r2 = mySub21(str, 2, str::substring); //这里同上，第一个参数的作用已写出，容易自动推断第二个参数
System.out.println(r2);
String r3 = mySub22(str, "eee", str::concat); //同上. 类型推断首先参考的是参数顺序
System.out.println(r3);
// mySub22(str,"eee",s->s.concat(?)) //无法写出
// mySub3("abcdef", 2, 3, String::substring);
String r4 = mySub3(str, 2, 3, String::substring);
System.out.println(r4);
String r5 = myConcat("abcdef", "_gh", String::concat);
System.out.println(r5);
List<String> list1 = Arrays.asList("a", "b", "A", "B");
list1.sort((s1, s2) -> s1.compareToIgnoreCase(s2));
System.out.println(list1);
List<String> list2 = Arrays.asList("a", "b", "A", "B");
list2.sort(String::compareToIgnoreCase);
System.out.println(list2);
List<String> list3 = Arrays.asList("a", "b", "A", "B");
list3.sort(Comparator.comparing(s -> s.toLowerCase())); //不加toLowerCase，则是大写在前
System.out.println(list3);
/*
>>> 构造函数
*/
Supplier<Apple> appleSupplier = Apple::new; //无参构造函数
Apple apple1 = appleSupplier.get();
System.out.println(apple1);
BiFunction<Integer, String, Apple> appleBiFunction = Apple::new; //有参构造函数
Apple apple2 = appleBiFunction.apply(2, "blue");
System.out.println(apple2);
/*
>>> 复合Lambda
*/
List<Apple> appleList = Arrays.asList(new Apple(20, "blue"),
new Apple(150, "white"),
new Apple(10, "black"),
new Apple(150, "blue"));
appleList.sort(Comparator.comparing(Apple::getWeight)
.reversed()
.thenComparing(Apple::getColor));
System.out.println(appleList);
Predicate<Apple> p1 = (a) -> a.getWeight() >= 20;
Predicate<Apple> p2 = a -> a.getColor().equals("blue");
//重量大于等于20，且颜色是蓝色
Predicate<Apple> pp1 = p1.and(p2);
List<Apple> list4 = appleList.stream().filter(pp1).collect(Collectors.toList());
System.out.println(list4);
//(重量大于等于20且颜色是蓝色)或（黑色）
Predicate<Apple> pp2 = pp1.or(a -> a.getColor().equals("black"));
List<Apple> list5 = appleList.stream().filter(pp2).collect(Collectors.toList());
System.out.println(list5);
/*
>>> 复合函数
*/
Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
//g(f(x)): 先计算f, 结果参与g的计算
Function<Integer, Integer> h = f.andThen(g);
Integer rr1 = h.apply(1); //4
System.out.println(rr1);
//f(g(x))：先计算g,结果参与f的计算
Function<Integer, Integer> h2 = f.compose(g);
Integer rr2 = h2.apply(1); //3
System.out.println(rr2);
// Simple example
// Runnable拥有一个无参函数，且没有返回值
// 这里省略了匿名类和方法名, 用匿名类和下面的代码类比，相对好理解
Runnable r = () -> System.out.println("Hello!");
r.run();
// Filtering with lambdas
List<Apple> inventory = Arrays.asList(new Apple(80, "green"), new Apple(155, "green"), new Apple(120, "red"));
// [Apple{color='green', weight=80}, Apple{color='green', weight=155}]
// 接口接收Apple类型的参数，返回boolean
List<Apple> greenApples = filter(inventory, (Apple a) -> "green".equals(a.getColor()));
System.out.println(greenApples);
// Comparator 接收两个参数，返回int
Comparator<Apple> c = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
// [Apple{color='green', weight=80}, Apple{color='red', weight=120}, Apple{color='green', weight=155}]
inventory.sort(c); //排序
System.out.println(inventory);
}
/**
* 接收String,Integer，返回新的String
*/
public static String mySub2(String s, int i, BiFunction<String, Integer, String> consumer) {
return consumer.apply(s, i);
}
public static String mySub21(String s, int i, Function<Integer, String> consumer) {
return s + ": " + consumer.apply(i);
}
public static String mySub22(String s, String s2, Function<String, String> consumer) {
return s + ": " + consumer.apply(s2);
}
/**
* 接收String, Integer, Integer， 返回新的String
*/
public static String mySub3(String s, int start, int end, BiFunction3<String, Integer, Integer, String> consumer) {
return consumer.apply(s, start, end);
}
/**
* 接收String,String,返回String
*
* @param s
* @param s2
* @param consumer
* @return
*/
public static String myConcat(String s, String s2, BiFunction<String, String, String> consumer) {
return consumer.apply(s, s2);
}
/**
* 对字符串进行应用，且不返回
*
* @param s
* @param consumer
*/
public static void myPrint(String s, Consumer<String> consumer) {
consumer.accept(s);
}
public static Integer getStrLength(String str, ToIntFunction<String> toIntFunction) {
return toIntFunction.applyAsInt(str);
}
public static List<Apple> filter(List<Apple> inventory, ApplePredicate p) {
List<Apple> result = new ArrayList<>();
for (Apple apple : inventory) {
if (p.test(apple)) {
result.add(apple);
}
}
return result;
}
public static class Apple {
private int weight = 0;
private String color = "";
public Apple() {
}
public String calc(String a, String b) {
return a + "_" + b;
}
public Apple(int weight, String color) {
this.weight = weight;
this.color = color;
}
public Integer getWeight() {
return weight;
}
public void setWeight(Integer weight) {
this.weight = weight;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String toString() {
return "Apple{" +
"color='" + color + '\'' +
", weight=" + weight +
'}';
}
}
interface ApplePredicate {
public boolean test(Apple a);
}
}
