脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java8 lambda表达式

Java8中lambda表达式的应用及一些泛型相关知识

 更新时间：2017年01月04日 09:46:33   投稿：mrr  
这篇文章主要介绍了Java8中lambda表达式的应用及一些泛型相关知识的相关资料

语法部分就不写了，我们直接抛出一个实际问题，看看java8的这些新特性究竟能给我们带来哪些便利

顺带用到一些泛型编程，一切都是为了简化代码

场景：

一个数据类，用于记录职工信息

public class Employee {
 public String name;
 public int age;
 public char sex;
 public String time;
 public int salary;
}

我们有一列此类数据

List<Employee> data = Arrays.asList(e1,e2,e3......)

现在有需求：将员工Employee按照姓名的首字母(假设均为英文名)进行分组：

那么我们要得到的结果应该是一个Map：char -> List<Employee> 这样的映射关系

public static Map<Character, List<Employee>> groupByFirstChar(
 List<Employee> data){
  Map<Character, List<Employee>> result = new HashMap<>();
  for(Employee e : data){
   Character c = e.name.charAt(0);
   List<Employee> l = result.get(c);
   if(l == null){
    l = new ArrayList<>();
    result.put(c, l);
   }
   l.add(e);
  }
  return result;
}

代码并不复杂，很快就可以完成，老板看你效率这么高，于是说，再按照工资分个组吧，5000以下的，5000~10000的 ...等

也不会太难，将key换一下，稍作逻辑处理即可

public static Map<String, List<Employee>> groupBySalary(List<Employee> data) {
 Map<String, List<Employee>> result = new HashMap<>();
 for (Employee e : data) {
  String key = separate(e.salary);
  List<Employee> l = result.get(key);
  if (l == null) {
   l = new ArrayList<>();
   result.put(key, l);
  }
  l.add(e);
 }
 return result;<br>}
private static String separate(int salary) {
 if (salary <= 5000) {
  return "5000以下";
 }
 if (salary <= 10000) {
   return "5000~10000";
 }
 if (salary <= 20000) {
  return "10000~20000";
 }
 return "20000以上"
}

然后老板又说了，按照员工的入职年份分下组吧。。。

这里就代码就不写了，稍作比较可以发现，无论怎么分组，唯一的变化是key值的选取方式，

第一次将Employee的name的第一字母作为key：

Employee e -> e.name.charAt(0)

第二次将Employee的salary按照方法separat转换为String作为key：

Employee e -> separate(e.salary):String

以此类推

Employee e -> getYear(e.time):String

事实上第一次也可以将获取首字母单独写成一个方法

Employee e -> getFirstChar(e.name):Character

为了看起来更美观，可以讲三个方法的参数都设置成Employee 方法体就不写了 这里只列出参数和返回值

Employee e -> getFirstChar(e) : Character
Employee e -> separate(e) : String
Employee e -> getYear(e) : String

->的左边为参数，:的右边为返回值，->的右边是方法的签名

那么我们自然会想到将变化的部分抽取为参数，其他不变的部分抽取为方法体，那么就可以省去那些重复的代码，显然变化的部分就是上面列出的，将Employee e转化成key的方法，但是我们知道java是不能把方法作为参数进行传递的。不过对于稍有经验的程序猿来说这并不是问题，我们可以使用接口来实现我们的目的，同时又会遇到另一个问题，以上三个方法的返回值是不同的，因此我们要用到泛型：

public static <K> Map<K, List<Employee>> groupByKey(List<Employee> data, GetKey<K> getKey){
 Map<K, List<Employee>> result = new HashMap<>();
 for(Employee e : data) {
  K key = getKey.getKey(e);
  List<Employee> l = result.get(key);
  if (l == null) {
   l = new ArrayList<>();
   result.put(key, l);
  }
  l.add(e);
 }
  return result;
}
interface GetKey<K>{
 K getKey(Employee e);
}

那么上面的第一个需求就可以这样实现

Map<Character, List<Employee>> result = groupByKey(data, new GetKey<Character>() {
   @Override
   public Character getKey(Employee e) {
    e.name.charAt(0);
   }
  });

第二个需求

Map<String, List<Employee>> result = groupByKey(list, new GetKey<String>() {
   @Override
   public String getKey(Employee e) {
    separate(e.salary);
   }
  });

可以发现，我们只需要更改泛型参数和匿名内部类的实现即可，唯一的问题恐怕是这么写实在不太好看，而且很多例行公事的代码，尤其体现在匿名内部类上。

事实上我们只关心这个匿名内部类的参数和返回值，其他部分仅仅是语法要求。

java8恰好为我们提供了很好的方式来避免复杂的例行公事的方式：lambda表达式，以上实现就可以写成

Map<Character, List<Employee>> resultByFirstChar = groupByKey(list, e -> e.name.charAt(0));
Map<String, List<Employee>> resultBySalary = groupByKey(list, e -> separate(e.salary));

lambda表达式恰恰只表现出我们所关心的，参数和返回值，同时由于类型推断，可以省去参数类型，具体语法这里就不介绍了，网上可以查到很多资料

extra：

如果你对泛型有不错的了解的话，方法groupByKey还可以进一步抽象：

public static <K, E> Map<K, List<E>> groupBy(List<? extends E> data, Function<? super E, ? extends K> fun) {
 Map<K, List<E>> result = new HashMap<>();
 for(E e : data) {
  K k = fun.apply(e);<br>  List<E> l = result.get(k);
  if(l == null) {
   l = new ArrayList<>();
   result.put(k, l);
  }
  l.add(e);
 }
 return result;<br>
 }

我们将Employee这个类也抽取了，好处显而易见

Function接口是java8新加入的接口：

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

输入一个T类型 返回R类型。泛型和函数式编程结合的很不错，虽然java8的新特性被各种吐槽，但是能带来好处总是好的，这给了我们更多的选择。

有时间的话会介绍stream，java8的另一大利器

以上所述是小编给大家介绍的Java8中lambda表达式的应用及一些泛型相关知识，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！

您可能感兴趣的文章:

相关文章

  • AsyncHttpClient的TimeoutTimerTask连接池异步超时

    AsyncHttpClient的TimeoutTimerTask连接池异步超时

    这篇文章主要为大家介绍了AsyncHttpClient的TimeoutTimerTask连接池异步超时源码流程解读,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-12-12
  • 解析java.library.path和LD_LIBRARY_PATH的介绍与区别

    解析java.library.path和LD_LIBRARY_PATH的介绍与区别

    这篇文章主要介绍了java.library.path和LD_LIBRARY_PATH的介绍与区别,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2021-05-05
  • SSH框架网上商城项目第7战之整合Struts2和Json

    SSH框架网上商城项目第7战之整合Struts2和Json

    SSH框架网上商城项目第7战之整合Struts2和Json，打通EasyUI和Struts2之间的交互，感兴趣的小伙伴们可以参考一下
    2016-05-05
  • SpringBoot使用责任链模式优化业务逻辑中的if-else代码

    SpringBoot使用责任链模式优化业务逻辑中的if-else代码

    在开发过程中，我们经常会遇到需要根据不同的条件执行不同的逻辑的情况，我们可以考虑使用责任链模式来优化代码结构，使得代码更加清晰、可扩展和易于维护
    2023-06-06
  • Docker和 Containerd 的区别解析

    Docker和 Containerd 的区别解析

    containerd 是一个来自 Docker 的高级容器运行时，并实现了 CRI 规范，它是从 Docker 项目中分离出来，之后 containerd 被捐赠给云原生计算基金会（CNCF）为容器社区提供创建新容器解决方案的基础，这篇文章主要介绍了Docker和 Containerd 的区别,需要的朋友可以参考下
    2024-03-03
  • Mybatis Plus插件三种方式的逆向工程的使用

    Mybatis Plus插件三种方式的逆向工程的使用

    这篇文章主要介绍了Mybatis Plus插件三种方式的逆向工程的使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-11-11
  • 详解SpringBoot中如何使用Reactor模型

    详解SpringBoot中如何使用Reactor模型

    Reactor模型主要提供了一种在Java虚拟机上构建非阻塞应用的方式,这种方式使用了响应式编程原理,通过响应式流标准来实现,下面我们就来看看它在SpringBoot中是如何使用的吧
    2024-04-04
  • JAVA如何解决并发问题

    JAVA如何解决并发问题

    这篇文章主要介绍了JAVA如何解决并发问题的处理方法，文中讲解的非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
    2020-06-06
  • java中的分布式事务解决方式

    java中的分布式事务解决方式

    分布式事务是分布式系统中确保数据一致性的重要机制,它涉及多个数据源或参与者,要么所有操作全部成功,要么全部失败,常见的解决方案包括2PC（两阶段提交协议）、3PC（三阶段提交协议）和TCC（Try-Confirm-Cancel）,2PC虽然简单但存在单点故障等问题
    2024-09-09
  • Spring MVC中自定义拦截器的实例讲解

    Spring MVC中自定义拦截器的实例讲解

    下面小编就为大家带来一篇Spring MVC中自定义拦截器的实例讲解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-08-08

最新评论