用集合模拟数据：

List<User> users = Arrays.asList(
                           new User(1,"吴一",12,5403.83),
                           new User(2, "程二", 18,4504.342),
                           new User(3,"张三",20,12010.21),
                           new User(4,"李四",16,8763.21),
                           new User(5,"王五",19,6091.2));

需求：

• 获取集合中的年龄大于18的员工信息
• 获取集合中工资大于6000的员工信息

传统解决方式：对两个需要用两个方法解决

//条件查询类
public class CommonMethod {
       //1，查询年龄大于18的方法
       public List<User> filterAgeUser(List<User> users){
             List<User> agelist = new ArrayList();
             for(User u:users) {
                    if(u.age>18) {
                           agelist.add(u);
                    }}
             return agelist;
       }
       
       //2，查询工资大于6000的方法
       public List<User> filterMoneyUser(List<User> users){
             List<User> agelist = new ArrayList();
             for(User u:users) {
                    if(u.money>6000.0) {
                           agelist.add(u);
                    }}
             return agelist;
       }
}

这个方式是最常规的解决办法，但每一种查询条件都需要兴建一个方法，有点麻烦

① 优化一：使用策略设计模式

//1，接口
public interface MyPredicate<T> {
       public boolean test(T t);
       }
 
//2，判断age的类
public class FilterUserByAge implements MyPredicate<User> {
       @Override
       public boolean test(User user) {
             // TODO Auto-generated method stub
             return user.age>18;
       }
}
 
//3，判断money的类
public class FilterUserByMoney implements MyPredicate<User>{
       @Override
       public boolean test(User user) {
       
             return user.money>5000.0;
       }
}
 
//4，具体调用的类
public class filter{
       
       public List<User> filterUser(List<User> users,MyPredicate<User> filter){
             
             List<User> lists = new ArrayList<>();
             
             for(User u: users ) {
                    if(filter.test(u)){
                           lists.add(u);
                    }
             }
             return lists;
       }
}

用面向对象的方式将行为方式抽象成类，在具体调用的类中传入相应的操作类就会完成相应的操作

• 优点：增加了拓展性，之后如果有新的需求，只需要实现MyPredicate接口，实现对应的逻辑即可
• 缺点：每一种条件判断需求都需要新建实现MyPredicate接口的类，代码很冗余

②优化二：匿名内部类

这是对策略优化的进一步优化，这样每一种条件判断需求就不需要新建实体类，而是在内部类进行逻辑判断

//1，接口
public interface MyPredicate<T> {
       public boolean test(T t);
       }
 
//2，具体调用的类
public class filter{
       
       public List<User> filterUser(List<User> users,MyPredicate<User> filter){
             
             List<User> lists = new ArrayList<>();
             
             for(User u: users ) {
                    if(filter.test(u)){
                           lists.add(u);
                    }
             }
             return lists;
       }
}
 
//3，测试
       public static void main(String[] args) {
             
             List<User> users = Arrays.asList(
                           new User(1,"吴一",12,5403.83),
                           new User(2, "程二", 18,4504.342),
                           new User(3,"张三",20,12010.21),
                           new User(4,"李四",16,8763.21),
                           new User(5,"王五",19,6091.2));
             
             List<User> l = new filter().filterUser(users, new MyPredicate<User>() {
                    @Override
                    public boolean test(User t) { //匿名内部类
                           return t.age>18;
                    }
             });
             for(User u:l) {
                    System.out.print(u);
             }}

③ 优化三：Lambda表达式

Lambda表达式简化匿名内部类的写法

1和2没有变
3，测试
       public static void main(String[] args) {
             
             List<User> users = Arrays.asList(
                           new User(1,"吴一",12,5403.83),
                           new User(2, "程二", 18,4504.342),
                           new User(3,"张三",20,12010.21),
                           new User(4,"李四",16,8763.21),
                           new User(5,"王五",19,6091.2));
             
             List<User> l = new filter().filterUser(users, (user) -> user.age>18);
             for(User u:l) {
                    System.out.print(u);
             }}

④ 优化四：Stream流

Stream java8中颠覆性的功能，它将很多繁琐的操作直接一行式完成

public static void main(String[] args) {
             
             List<User> users = Arrays.asList(
                           new User(1,"吴一",12,5403.83),
                           new User(2, "程二", 18,4504.342),
                           new User(3,"张三",20,12010.21),
                           new User(4,"李四",16,8763.21),
                           new User(5,"王五",19,6091.2));
 
             users.stream() //三行代码直接搞定，不需要什么策略模式和类方法设计，
                     .filter((e) -> e.getAge()>18)
                     .forEach(System.out::println);}

Stream是一把利器但有其的使用场景局限性，大多数集合数据操作可以使用它来完成，但宏观的架构和优化还是需要设计模式和类方法设计

() -> System.out.print("无返回值")

(x) -> System.out.print(x)

x -> System.out.print(x)

//1，类型推断
(x,y) -> system.out.print(x+"<-->"+y)
//2，写数据类型
(Integer x,Integer y) -> system.out.print(x+"<-->"+y)
//3，错误写法
(Integer x,y) -> system.out.print(x+"<-->"+y)

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before)  {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
   
    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;
    }
}

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    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 FunctionInterface {
       //1，Consumer：对传入的值进行拼接打印
       public void my_consumer(Double number,Consumer<Double> consumer) {
             consumer.accept(number);
       }
       
       //2，Supplier：产生指定个数的整数并放入集合中
       public List<Integer> my_supplier(int limit,Supplier<Integer> supplier){
             
             List<Integer> list = new ArrayList<>();
             for(int x=0;x<limit;x++) {
                    list.add(supplier.get());
             }
             return list;
       }
       
       //3，Function：处理字符串
       public String my_function(String str,Function<String,String> function) {
             
             return function.apply(str);
       }
       
       //4，Predicate：将满足条件的字符串放入集合中
       public List<String> my_prection(String[] str,Predicate<String>  predicate){
             List<String> list = new ArrayList<>();
             for(String s:str) {
                    if(predicate.test(s)) {
                           list.add(s);
                    }
             }
             return list;
       }
}

public class FunctionMain {
       public static void main(String[] args) {
       
    FunctionInterface fun = new FunctionInterface();
    
    //1,consumer
    fun.my_consumer(99.9, (x) -> System.out.println("小王花了"+x+"在阿里云上买了个.com域名"));
       
    //2,supplier：返回指定个数的随机数
    List<Integer> list = fun.my_supplier(10, () ->  (int) (Math.random() *  100));
    System.out.println(list.toString());
    
    //3,funaction：对字符串大写返回
    String y = fun.my_function("wql kxj", (x) -> x.toUpperCase());
    System.out.println(y);
    
    //4,predicate：将字符串长度大于5的加入list并返回
    List<String> l=fun.my_prection(new  String[]{"wqlfq","qwertt","tyi","wqr","dasdjkq"}, (x) -> x.length()>5);
    System.out.println(l.toString());
    
}
}

二，其他子函数式接口

三，自定义函数式接口

函数式接口的含义：指含有一个抽象方法的接口

场景：函数式接口适用于函数式编程场景。在java中函数式编程的体现就是Lambda，所以函数式接口主要适用于Lambda，一个抽象方法lambda才能顺利推导

@FunctionalInterface注解标注：

• 放在接口定义的上方，表示该接口是函数式接口
• 接口有且仅有一个抽象方法

例：

①  标准的有输入和输出

@FunctionalInterface
interface my_fundicate<T,R> { //T输入泛型，R输出泛型
       public R fun(T s);
}

② 有不同类型的输入

@FunctionalInterface
interface my_fundicate<T1,T2,R> { //T1和T2输入泛型，R输出泛型
       public R fun(T1 s1,T2 s2);
}

四，练习小例子

例1：使用自定义函数式接口和Lambda，输入一个字符串，全部转化为大写截取1-3然后输出

① 函数接口

@FunctionalInterface
interface my_fundicate<T,R> {
       public R fun(T s);
}

② 方法和测试

public class ExerciseMain {
       public static void main(String[] args) {
             
             String o =  test1("wql-kxj",(x)->x.toUpperCase().subSequence(0,3).toString());
             System.out.print(o);
       }
       
       public static String test1(String str,my_fundicate<String, String> fun) {
             
             return fun.fun(str);
       }
}

例2：使用自定义函数式接口和Lambda，输入两个Double，将它们相加再返回

① 函数接口

@FunctionalInterface
interface my_fundicate<T,R> {
       public R fun(T a1,T a2);
}

② 方法和测试

public static void main(String[] args) {

             Double o = test1(10.1,10.2,(x,y) -> x+y);

             System.out.print(o);
       }
       
       public static Double test1(Double dou1,Double dou2,my_fundicate<Double,  Double> fun) {
           
             return fun.fun(dou1,dou2);
    }

三，Lambda引用

Lambda引用是一种语法的简化，无特殊含义

//普通的调用
Consumer<String> con = (x) -> System.out.print(x);
//方法引用  --> Consumer有输入没有输出(有参数没有返回值)，System.out.print方法也只有输入没有输出，是匹配的所以能够使用这种方式
Consumer<String> con = System.out::print;
con.accept("wql");

User users = new User(1,"吴一",12,5403.83);
//普通方式获取姓名获取
 Supplier<String> sup1 = () -> users.getName();
//方法引用方式获取(Supplier和users.getName参数列表和返回值一样)
Supplier<String> sup2 = users::getName;

//普通方式比较整数大小
Comparator<Integer> com1 = (x,y) -> Integer.compare(x, y);
//方法引用的方式比较
Comparator<Integer> com2 = Integer::compare;

//普通方式两个参数值判断
BiPredicate<String, String> b1 = (x,y) -> x.equals(y);
//方法引用
BiPredicate<String, String> b2 = String::equals; //实际上也是x.equals(y)，但它也只适用于这种场景

//Lambda普通方式创建
Supplier<User> sup1 = () -> new User();
//构造方法引用方式创建
Supplier<User> sup2 = User::new;

//Lambda普通方式创建
BiFunction<Integer, String, User> bf1 = (x,y) -> new User(x,y);
//构造方法引用方式创建
BiFunction<Integer, String, User> bf2 = User::new;

//普通方式
Function<Integer,String[]> sup1 = (x) -> new String[x];
//数组引用
Function<Integer,String[]> sup2 = String[]::new;