stream+函数式

系统管理员 2023-02-21 09:24 119阅读 0赞

# 最核心的东西 #

## 函数编程的写法 ##

更多参考：  
[函数式+stream【dim】][stream_dim]

无参的

@FunctionalInterface
    public interface FunInteface { 
    /** Consumer<T>: 消费型接口，接收数据并处理【无返回值】 */
    void test();			//使用时：
    
    /** Predicate<T>: 断言型接口，检测入参是否符合条件（符合则返回true）【返回类型为boolean】 */
    boolean test(int a,T t);  //(x,y)-> x>y;
    }
    /** Function<T, R>: 函数型接口，接收参数，返回结果【有返回类型】 */
    int test(int a,T t);   //FunInteface<Integer> ft=(x,y)-> x-y; int res= ft.test(1,5);
    
    /** Supplier<T>: 供给型接口，对外提供数据【给什么就返回什么】 */
     T test(int a,T t); // FunInteface<Integer> ft=(x,y)-> x-y; int res= ft.test(1,5);
    
    
    //------------------------------------
    @Test
        public void test5Fun(){ 
           FunInteface ft=()-> System.out.println("无参");
           ft.test();
        }

多参的，多语句的

@FunctionalInterface
    public interface FunInteface<T> { 
        void test(int a,T t);
    }
    @Test
        public void test5Fun(){ 
           FunInteface<Integer> ft=(x,y)-> { Integer b=x-y;System.out.println(b);};
           ft.test(1,5);
        }

四大核心函数接口的用法如下：

/** * @author gc * 方法引用：若lambda体中的内容有方法已经实现了，我们可以使用“方法引用” * （可以理解为方法引用是lambda表达式的另外一种表达形式） * 主要有三种语法格式： * 对象::实例方法名 * 类::静态方法名 * 类::实例方法名 * 注意： * 1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的参数列表和返回值类型一致 * 2.若lambda参数列表 中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用className::method * * 二、构造器引用 * 格式： * ClassName::new Function<String,Employee> fun=Employee::new; //构造方法的参数最多1个 BiFunction<String,Integer,Employee> funm=Employee::new; //构造方法的参数最多2个 */
    public class TestMethodRef { 
    
     //--------消费类型的 
        //对象::实例方法名
        @Test
        public void test() { 
            Consumer<String> consuemr = (x) -> System.out.println(x);
            consuemr.accept("aaaa");
            
            PrintStream ps = System.out;
            Consumer<String> consumer2 = ps::println;
            consumer2.accept("asdf");
        }
        //-----供应者类型
        @Test
        public void test2() { 
            User user= new User("gc",20,200000);
            //这里是无参，所以左边使用了()
            Supplier<String> sup = () -> user.getName();
            System.out.println(sup.get());
            
            //这里对lambda表达式进行了省略。() -> user.getAge() == user::getAge
            Supplier<Integer> sup2 = user::getAge;
            System.out.println(sup2.get());
        }
        //-----函数类型
        //类::静态方法名
        public void test3() { 
            Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
            
            //这里因为入参和lambda实现方法要调用的入参一样。所以两边都省略了
            Comparator<Integer> com1 = Integer::compare;
        }
        //------断言类型
        //类::实例方法名
        public void test4() { 
            BiPredicate<String, String> bp = (x,y) -> x.equals(y);
            
            //这里是两个入参，而且满足第一个参数是新方法调用者，第二个参数是入参的情况
            //理论而言都用上面的表达式即可，看起来比较简单，但是不能避免别人不会使用简写方式，看不懂岂不是很尴尬
            BiPredicate<String, String> bp2 = String::equals;
        }
        
        @Test
        public void test5() { 
            //函数式接口生产数据的方式是new User();
            Supplier<User> sup = () -> new User();
            //这里功能同上，简写方式
            Supplier<User> sup2 = User::new;      //----方法引用：注意由于是Supplier所以参数类型和返回类型要一致
            System.out.println(sup2.get());
        }
    }

## 举例子 ##

在编写过滤器里面经常用到这个方式

static void a(String str,Predicate<Boolean>predicate, Consumer<String>consumer){ 
            if (predicate.test(!str.isEmpty())){ 
                consumer.accept(str);
            }
        }
        static String b(String str,Predicate<Boolean>predicate, Supplier<String> supplier){ 
            if (predicate.test(!str.isEmpty())){ 
               return supplier.get();
            }
            return "";
        }
        //第一个String是入参类型，第二个String是返回类型
        static String c(String str, Function<String,String> function){ 
           return function.apply(str);
        }
    //测试========================
    
    a("aa",s->s,x-> System.out.println(x));
    b("aa",s->s,() -> "haha");
    c("one",x->x+x);

函数式：好好看看这篇文章写的很好：https://www.algerfan.cn/articles/2018/11/18/1542474535012.html

//牢记一下几点
    1. 中间操作（过滤，排序）
    2. 收集操作（类型转换，求和，分类....）
    3. 函数式编程

Java8新特性学习-函数式编程(Stream/Function/Optional/Consumer)  
https://blog.csdn.net/icarusliu/article/details/79495534

//默认都是自然排序， list.stream().sorted((x,y)->x-y); //这个也是自然排序
    
    参数为list的mybatis的用法
    https://www.cnblogs.com/coderzhw/p/11094300.html  
    
    stream分组聚合求最大值
    
    
    //mybaits-plus使用查询之后的结果
            // 查无此人返回列表则（list=0）；
            // 查无此人返回对象则（obj=null）；

# 常见lomda表达式的写法： #

使用optional巧判空

Integer num=null;
            //如果num为空，则赋初值为6。【注意：执行完改代码后num仍未空，initNum为6】
            Integer initNum = Optional.ofNullable(num).orElse(6);
            //先判断initNum为空否？不为空的话，做加操作并输出
            Optional.ofNullable(initNum).ifPresent(s->{ s+=s;System.out.println(s);});

原子变量的使用

//定义原子变量，保证并发下的变量的set，get线程安全
            AtomicReference<Integer> atomicInt = new AtomicReference<>();
            atomicInt.set(10);
            Integer integer = atomicInt.get(); //结果为10，并发下

1.  数组遍历

list.foreach(System.out::println);

1.  对象根据属性排序

studentList.sort(Student x,Student y)->{ return x-y};  //自然排序，y-x非自然排序

# 四大函数类型接口 #

一般不会这样写：

//gateway里面有自定义过滤器，其中过滤得规则用到了函数式接口
    
    //spring security在适当得时候就会调用到自定义拦截器得apply方法，到时候就会传入ServerWebExchange exchange, GatewayFilterChain chain
    @Service
    public class AuthenticationGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> { 
    @Override
        public GatewayFilter apply(Object config) { 
        //这个参数的类型在GatewayFilter得filter里面定义如下：
        /** public interface GatewayFilter extends ShortcutConfigurable { String NAME_KEY = "name"; String VALUE_KEY = "value"; Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain); } */
           return (exchange, chain) -> chain.filter(exchange).then(Mono.fromRunnable(() -> { 
                    List<String> accountInfo = exchange.getResponse().getHeaders().get("AccountInfo");
                    exchange.getResponse().getHeaders().remove("AccountInfo");//移除包头中的用户信息不需要返回给客户端
                    if(accountInfo != null && accountInfo.size() > 0) { 
                        String gmAccountInfoJson = accountInfo.get(0);//获取header中的用户信息
                        //将信息放在session中，在后面认证的请求中使用
                        exchange.getSession().block().getAttributes().put("AccountInfo", gmAccountInfoJson);
                    }
                    logger.debug("登陆返回信息:{}",accountInfo);
            }));
    	}
    }

简单例子【正常写代码不会这样写，但是在编写框架得时候就可能用到】

@FunctionalInterface
    interface Ddd { 
        Integer test(String a,String b,String c);
    }
    puclic class tes{ 
      void aa(){ 
        Ddd d = d();
        Integer test = d.test("a", "b", "c");
      }
      static Ddd d(){ return (a,b,c)->{ return a.length()+b.length()+c.length();};}
    }

[stream_dim]: https://blog.csdn.net/qq_41063141/article/details/103918283