乐趣区

关于code:简化业务代码开发看Lambda表达式如何将代码封装为数据

摘要:在云服务业务开发中,长于应用代码新个性,往往能让开发效率大大晋升,这里简略介绍下 lambad 表达式及函数式接口个性。

在云服务业务开发中,长于应用代码新个性,往往能让开发效率大大晋升,这里简略介绍下 lambad 表达式及函数式接口个性。

1.Lambda 表达式

Lambda 表达式也被称为箭头函数、匿名函数、闭包。他容许把函数作为一个办法的参数(函数作为参数传递到办法中),体现出轻量级函数式编程思维。

为什么引入 lambda?

Model Code as Data,编码及数据,尽可能轻量级的将代码封装为数据。

解决方案:接口 & 实现类(匿名外部类)

存在问题:语法冗余,this 关键字、变量捕捉、数据管制等

public static void main (String[] args){
    // 1. 传统模式下,新线程的创立
    new Thread (new Runnable() {
        @Override 
        public void run() {System.out.println("threading..." + Thread.currentThread().getId())
        }
    }).start();
     // 2. lambda 表达式优化线程模式
    new Thread(()->{System.out.println("lambda threading..." + Thread.currentThread().getId());
    })
    
}
复制代码
  1. 不是解决未知问题的新技术
  2. 对现有问题的语义化优化
  3. 须要依据理论需要思考性能问题

2. 函数式接口(Functional Interface)

函数式接口就是 Java 类型零碎中的接口,是只蕴含一个形象办法的非凡接口(能够有很多非形象办法)。

语言化检测注解:@FunctionalInterface 检测合法性

java1.8 反对接口内蕴含:形象办法、默认接口办法、动态接口办法、来自 Object 继承的办法

/**
 * 用户身份认证标记接口
 */
@FunctionalInterface
public interface IUserCredential {
 
    /**
     * 通过用户账号,验证用户身份信息的接口
     * @param username 要验证的用户账号
     * @return 返回身份信息[系统管理员、用户管理员、普通用户]
     */
    String verifyUser(String username);
    
    default String getCredential(String username) {if ("admin".equals(username)) {return "admin + 系统管理员用户";} else if("manager".equals(username)){return "manager + 用户管理员用户";} else {return "commons + 一般会员用户";}    }    String toString();     /**     * 音讯合法性验证办法     * @param msg 要验证的音讯     * @return 返回验证后果     */    static boolean verifyMessage(String msg) {if (msg != null) {return true;}        return false;    }}   // 匿名外部类,实现接口的形象办法        IUserCredential ic = new IUserCredential() {            @Override
          public String verifyUser(String username) {return "admin".equals(username)?"管理员":"会员";            }        };        // lambda 表达式是函数式接口的一种简略实现               IUserCredential ic2 = (username) -> {return "admin".equals(username)?"lbd 管理员": "lbd 会员";        };
复制代码

JDK 1.8 之前已有的函数式接口:

  •  java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • more

JDK 1.8 新减少的函数接口:

  • java.util.function

    /*
        java.util.function 提供了大量的函数式接口
        Predicate 接管参数 T 对象,返回一个 boolean 类型后果
        Consumer 接管参数 T 对象,没有返回值
        Function 接管参数 T 对象,返回 R 对象
        Supplier 不承受任何参数,间接通过 get()获取指定类型的对象
        UnaryOperator 接口参数 T 对象,执行业务解决后,返回更新后的 T 对象
        BinaryOperator 接口接管两个 T 对象,执行业务解决后,返回一个 T 对象
         */
       Predicate<String> pre = (String username) -> {return "admin".equals(username);
        };
        System.out.println(pre.test("manager"));
     
        Consumer<String> con = (String message) -> {System.out.println("要发送的音讯:" + message);
        };
        con.accept("lambda expression.");
     
        Function<String, Integer> fun = (String gender) -> {return "male".equals(gender)?1:0;
        };
        System.out.println(fun.apply("male"));
     
        Supplier<String> sup = () -> {return UUID.randomUUID().toString();};
        System.out.println(sup.get());
    
         UnaryOperator<String> uo = (String img)-> {img += "[100x200]";
            return img;
        };
        System.out.println(uo.apply("原图 --"));
    
        BinaryOperator<Integer> bo = (Integer i1, Integer i2) -> {return i1 > i2? i1: i2;};
        System.out.println(bo.apply(12, 13));
    复制代码

3.lambda 表达式的根本语法

根本语法

  • 申明:就是和 lambda 表达式绑定的接口类型
  • 参数:蕴含在一对圆括号中,和绑定的接口中的形象办法中的参数个数及程序统一。
  • 操作符:->
  • 执行代码块:蕴含在一对大括号中,呈现在操作符号的右侧

[接口申明] = (参数) -> {执行代码块};

// 没有参数,没有返回值的 lambda 表达式绑定的接口
    interface ILambda1{void test();
    }
 
    // 带有参数,没有返回值的 lambda 表达式
    interface ILambda2{void test(String name, int age);
    }
 
    // 带有参数,带有返回值的 lambda 表达式
    interface ILambda3 {int test(int x, int y);
    }
ILambda1 i1 = () -> System.out.println("hello boys!");
        i1.test();
 
        ILambda2 i21 = (n,  a) -> {System.out.println(n + "say: my year's old is " + a);
        };
        i21.test("jerry", 18);
 
        ILambda2 i22 = (n, a) -> 
            System.out.println(n + "说:我往年" + a + "岁了.");
        
        i22.test("tom", 22);
 
        ILambda3 i3 = (x, y) -> {
            int z = x + y;
            return z;
        };
        System.out.println(i3.test(11, 22));
 
        ILambda3 i31 = (x, y) -> x + y;
        System.out.println(i31.test(100, 200));
复制代码

总结:

  • lambda 表达式,必须和接口进行绑定。
  • lambda 表达式的参数,能够附带 0 个到 n 个参数,括号中的参数类型能够不必指定,jvm 在运行时,会主动依据绑定的形象办法中的参数进行推导。
  • lambda 表达式的返回值,如果代码块只有一行,并且没有大括号,不必写 return 关键字,单行代码的执行后果,会主动返回。如果增加了大括号,或者有多行代码,必须通过 return 关键字返回执行后果。

变量捕捉

  • 匿名外部类型变量捕捉
  • lambda 表达式变量捕捉

     // 1. 匿名外部类型中对于变量的拜访
             String s1 = "全局变量";
             public void testInnerClass() {
                 String s2 = "局部变量";
              
                 new Thread(new Runnable() {
                     String s3 = "外部变量";
                     @Override
                     public void run() {
                         // 拜访全局变量
         //              System.out.println(this.s1);// this 关键字~ 示意是以后外部类型的对象(报错)System.out.println(s1);
              
                         System.out.println(s2);// 局部变量的拜访,不能对局部变量进行数据的批改 final
         //              s2 = "hello";
              
                         System.out.println(s3);
                        System.out.println(this.s3);
                     }
                 }).start();}
              
             // 2. lambda 表达式变量捕捉
             public void testLambda() {
                 String s2 = "局部变量 lambda";
              
                 new Thread(() -> {
                     String s3 = "外部变量 lambda";
              
                     // 拜访全局变量
    
                     // 不再建设对象域
                     System.out.println(this.s1);// this 关键字,示意的就是所属办法所在类型的对象
                     // 拜访局部变量                     System.out.println(s2);
         //          s2 = "hello";// 不能进行数据批改,默认推导变量的修饰符:final
                     System.out.println(s3);
                     s3 = "labmda 外部变量间接批改";
                     System.out.println(s3);
                }).start();}
    复制代码

总结:Lambda 表达式优化了匿名外部类类型中的 this 关键字,不再独自建设对象作用域,表达式自身就是所属类型对象的一部分,在语法语义上应用更加简洁。

类型查看

对于语法雷同的表达式,Jvm 在运行的过程中,在底层通过解释及重构,进行类型的主动推导。

  • 表达式类型查看
  • 参数类型查看

办法重载

interface Param1 {void outInfo(String info);
    }
 
    interface Param2 {void outInfo(String info);
    }
// 定义重载的办法
    public void lambdaMethod(Param1 param) {param.outInfo("hello param1 imooc!");
    }
    public void lambdaMethod(Param2 param) {param.outInfo("hello param2 imooc");
    }
test.lambdaMethod(new Param1() {
            @Override
            public void outInfo(String info) {System.out.println(info);
            }
        });
 
        test.lambdaMethod(new Param2() {
            @Override
            public void outInfo(String info) {System.out.println("------");
                System.out.println(info);
            }
        });
 
        /*
        lambda 表达式存在类型查看 -> 主动推导 lambda 表达式的指标类型
        lambdaMethod() -> 办法 -> 重载办法
                -> Param1  函数式接口
                -> Param2  函数式接口
                调用办法 -> 传递 Lambda 表达式 -> 主动推导 -> 
                   -> Param1 | Param2
         */
//               报错 Ambigus Method call
//        test.lambdaMethod((String info) -> {//            System.out.println(info);
//        });
复制代码

总结:呈现办法重载的类型中参数都是函数式接口的状况,需应用匿名外部类实现代替 lambda 表达式。

底层构建原理

public class Test{public static void main(String args[]){ITest it = (message) -> System.out.println(message);
               it.markUp("lambda!");  
        // new Test$$Lambda$1().markUp("lambda");
        } 
}
interface ITest{void markUp(String msg);
}
 
复制代码

javac Test.java

javap -p Test.class (javap 反解析工具 - p 显示所有类与成员)

  •  java -Djdk.internal.lambda.dumpProxyClasses Test

  1. 申明一个公有静态方法,对 Lambda 表达式做一个具体的办法实现
  2. 申明一个 final 外部类型并实现接口
  3. 在实现接口后的重写办法中利用外部类调用该公有静态方法

 4. 办法援用

办法援用提供了十分有用的语法,能够间接援用已有 Java 类或对象(实例)的办法或结构器。与 lambda 联结应用,办法援用能够使语言的结构更紧凑简洁,缩小冗余代码。

  • 静态方法援用
  • 实例办法援用
  • 构造方法援用

5.Stream

  • 新增加的 Stream 流—是一个来自数据源的元素队列并反对聚合操作。把真正的函数式编程格调引入到 Java 中。
  • 不存储数据,也不批改原始源。
  • Stream 应用一种相似用 SQL 语句从数据库查问数据的直观形式来提供一种对 Java 汇合运算和表白的高阶形象。
  • Stream API 能够极大进步 Java 程序员的生产力,让程序员写出高效率、洁净、简洁的代码。
  • 这种格调将要解决的元素汇合看作一种流,流在管道中传输,并且能够在管道的节点上进行解决,比方筛选,排序,聚合等。
  • 元素流在管道中通过两头操作(intermediate operation)的解决,最初由最终操作 (terminal operation) 失去后面解决的后果。

// 1. for 循环实现 List list = new ArrayList(); for (String s : list) {if (s.length() > 3) {lista.add(s); } } System.out.println(lista);

// 2. 迭代器实现
List<String> listb = new ArrayList<>();
Iterator<String> it = list.iterator();
while(it.hasNext()) {String s = it.next();
    if(s.length() > 3) {listb.add(s);
    }
}
System.out.println(listb);
 
// 3. stream 实现
List listc = list.stream().filter(s->s.length()>3)
    .collect(Collectors.toList());
System.out.println(listc);
复制代码

几者关系

  • lambda 表达式是传统办法的语法糖,简化并且革新传统外部类实现设计方案的另一种实现模式。
  • 办法援用又是 lambda 根底上的语法糖,和 Stream 没有关系,简化办法调用的。
  • Stream 是针对数据和汇合的强化优化操作,能够和 lambda 联合起来简化编码过程。

常见 API 介绍

1. 聚合操作

2.Stream 的解决流程

  • 数据源
  • 数据转换[可一到屡次转换]
  • 获取后果

3. 获取 Stream 对象

  • 从汇合或者数组中获取

Collection.stream(), 如 list.stream()

Collection.parallelstream(), 取得反对并发解决的流

Arrays.stream(T t)

  • BufferReader

BufferReader.lines()-> stream()

  • 动态工厂

java.util.stream.IntStream.range()..

java.nio.file.Files.walk()..

  • 自定构建

java.util.Spliterator

  • 更多的形式

Random.ints()

Pattern.spiltAsStream()..

4. 两头操作 API{intermediate}:

  • 操作后果是一个 Stream 对象,所以两头操作可有一个或多个间断的两头操作,须要留神的是两头操作只记录操作形式,不做具体执行,直到完结操作产生时,才做数据的最终执行。
  • 两头操作就是业务逻辑解决
  • 操作过程分为有状态和无状态

无状态:即解决数据时,不受前置两头操作的影响

  • map/filter/peek/parallel/sequential/unordered
  • 有状态:即解决数据时,受前置两头操作的影响
  • distant/sorted/limit/skip

5. 终结操作 | 完结操作{Terminal}

一个 steam 对象只能有一个 Terminal 操作。这个操作不可逆,一旦产生,就会实在解决数据生成对应后果

  • 非短路操作: 以后的 Stream 对象必须解决完汇合中所有的数据,能力失去处理结果

forEach/forEachOrdered/toArray/reduce/collect/min/max/count/iterator

  • 短路操作: 以后的 Stream 对象在处理过程中,一旦满足某个条件,就能够失去后果

    anyMatch/AllMatch/noneMatch/findfirst/findAny 等

short-circuiting : 在无限大的 stream 中返回无限大的 stream 须要蕴含短路操作是有必要的

Stream 转换

 // 1. 批量数据 -> Stream 对象
          // 多个数据
          Stream stream = Stream.of("admin", "tom", "jerry");
   
          // 数组
          String [] strArrays = new String[] {"xueqi", "biyao"};
          Stream stream2 = Arrays.stream(strArrays);
   
          // 列表
          List<String> list = new ArrayList<>();
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
          Stream stream3 = list.stream();
   
          // 汇合
          Set<String> set = new HashSet<>();
          set.add("aaa");
          set.add("bbb");
          set.add("ccc");
          Stream stream4 = set.stream();   
          // Map
          Map<String, Integer> map = new HashMap<>();
          map.put("tom", 1000);
          map.put("jerry", 1200);
          map.put("shuke", 1000);
          Stream stream5 = map.entrySet().stream();   
      //2. Stream 对象对于根本数据类型的性能封装
          //int / long / double
          IntStream.of(new int[] {10, 20, 30}).forEach(System.out::println); // 只做一次拆箱装箱
          IntStream.range(1, 5).forEach(System.out::println);

          IntStream.rangeClosed(1, 5).forEach(System.out::println);  
     // 3. Stream 对象 --> 转换失去指定的数据类型
          // 数组
          Object [] objx = stream.toArray(String[]::new);
   
          // 字符串
          String str = stream.collect(Collectors.joining()).toString();
          System.out.println(str);
   
          // 列表
          //List<String> listx = (List<String>) stream.collect(Collectors.toList());
          System.out.println(listx);
   
          // 汇合
          //Set<String> setx = (Set<String>) stream.collect(Collectors.toSet());
          System.out.println(setx);
   
          // Map
          //Map<String, String> mapx = (Map<String, String>)                                               stream.collect(Collectors.toMap(x->x, y->"value:"+y));
       System.out.println(mapx);
复制代码

Stream 常见操作

// Stream 中常见的 API 操作
        List<String> accountList = new ArrayList<>();
        accountList.add("tom");
        accountList.add("jerry");
        accountList.add("apha");
        accountList.add("beta");
        accountList.add("shuke");
 
        // map() 两头操作,map()办法接管一个 Functional 接口
        accountList = accountList.stream().map(x->"name:" + x).collect(Collectors.toList());
 
        // filter() 增加过滤条件,过滤符合条件的用户
        accountList = accountList.stream().filter(x-> x.length() > 3).collect(Collectors.toList());
 
        // forEach 增强型循环
        accountList.forEach(x-> System.out.println("forEach->" + x));
 
        // peek() 两头操作,迭代数据实现数据的顺次处理过程
        accountList.stream()
                .peek(x -> System.out.println("peek 1:" + x))
                .peek(x -> System.out.println("peek 2:" + x))
                .forEach(System.out::println);// 合并多个过程 迭代只产生一次
 
        accountList.forEach(System.out::println);
 
        // Stream 中对于数字运算的反对
        List<Integer> intList = new ArrayList<>();
        intList.add(20);
        intList.add(19);
        intList.add(7);
        intList.add(8);
        intList.add(86);
        intList.add(11);
        intList.add(3);
        intList.add(20);
 
        // skip() 两头操作,有状态,跳过局部数据
        intList.stream().skip(3).forEach(System.out::println);
 
        // limit() 两头操作,有状态,限度输入数据量
        intList.stream().skip(3).limit(2).forEach(System.out::println);
 
        // distinct() 两头操作,有状态,剔除反复的数据
        intList.stream().distinct().forEach(System.out::println);
 
        // sorted() 两头操作,有状态,排序
        // max() 获取最大值
        Optional optional = intList.stream().max((x, y)-> x-y);
        System.out.println(optional.get());
        // min() 获取最小值
 
        // reduce() 合并解决数据
        Optional optional2 = intList.stream().reduce((sum, x)-> sum + x);
        System.out.println(optional2.get());
复制代码

6. 案例

问题一:将实例 List 转化为 Map

对于 List

来说,我须要将其形变为 Map<Table.id,Table>,用如下流解决代码

//Table 类
public class DmTable {
    private Integer id;
 
    private String tableName;
 
    private String tableComment;
 
    private Integer datasourceId;
 
    private Integer directoryId;
 
    private Boolean partitionFlag;
    
    private Integer columnNum;
    // ......
}
tableMap=TableList.stream().collect(Collectors.toMap(Table::getId, b -> b);
// 等效于
tableMap=TableList.stream().collect(Collectors.toMap(Table::getId, Function.identity()));// 静态方法 实现 return t -> t;
复制代码

问题二:将汇合分成若干类别

应用问题一中的 Table 类,对于 List

,我须要将其依照 partitionFlag 分类,Collector 提供两种办法 partitioningBy()、groupingBy()。前者分成满足条件与不满足条件两类,后者可按条件分成若干类别的 Map。

 Map<Boolean, List<Table>> tablePartition = tableList
          .stream().collect(Collectors.partitioningBy(item -> item.getPartitionFlag() == true));
复制代码
  • 有的时候,咱们关注的不光是元素还有元素的个数,流解决能够再进行前期解决。

    Map<Boolean, List

tablePartition = tableList .stream().collect(Collectors.partitioningBy(item -> item.getPartitionFlag() == true,Collectors.counting()));

可输入符合要求的个数。

groupingBy()可对字符串长度分组。

List<String> strings=Arrays.asList(“this”,”is”,”a”,”test”);
Map<Integer, List<String>> stringsMap = strings
        .stream().collect(Collectors.groupingBy(String::length);
复制代码

后果输入多分类的 map,key 值为字符串长度。

留神:如果是从数据库获取数据,务必将分组操作放在数据库中执行,java8 新增办法只适宜解决内存中的数据。

问题三:从 list 中失去某个特定的对象

取得 List

中 columnNum 最多的 table 对象

tableList.stream().sorted(comparingInt(Table::getColumnNum)).collect(Collectors.toList()).get(tableList.size() - 1);
复制代码

增加两头操作 reversed() 可获取最小 columnNum 的对象

问题四:失去 Map<Table,Table.columnNum> 中最大 columnNum 的 table

 List<Map.Entry<Table, Integer>> list = new ArrayList(tableMap.entrySet());
Collections.sort(list, (o1, o2) -> (o2.getValue() - o1.getValue()));
list.get(0).getKey();
复制代码

7. 性能与平安

  • 串行 Stream 的性能小于传统的 for 循环、迭代器
  • 并行 Stream 的性能与传统的 for 循环、迭代器差不多,在解决对象(简单数据类型)的状况下,并行性能最佳

    // 整数列表 List lists = new ArrayList(); // 减少数据 for (int i = 0; i < 1000; i++){lists.add(i); }

     // 串行 Stream
          List<Integer> list2 = new ArrayList<>();
          lists.stream().forEach(x->list2.add(x));
          System.out.println(lists.size());
          System.out.println(list2.size());
          // 并行 Stream  线程不平安 失落
          List<Integer> list3 = new ArrayList<>();
          lists.parallelStream().forEach(x-> list3.add(x));
          System.out.println(list3.size());
                  // collect 当并行执行时能够实例化、填充和合并多个两头后果,以放弃可变数据结构的隔离
          List<Integer> list4 = lists.parallelStream().collect(Collectors.toList());
          System.out.println(list4.size());
    复制代码

本文分享自华为云社区《如何善用函数式接口简化云服务业务代码开发》,原文作者:luanzhen。

点击关注,第一工夫理解华为云陈腐技术~

退出移动版