Java8 lambda使用总结－结合实例介绍

最新推荐文章于 2024-05-16 19:36:07 发布
最新推荐文章于 2024-05-16 19:36:07 发布
阅读量1w 收藏 25
点赞数 5
分类专栏： javaEE
摘要: 1.Java8 新特性介绍 2.项目中应用

1.Java8 新特性介绍

原文链接 https://my.oschina.net/chenxiaobian/blog/704421

写java的同学对java8肯定知道 那么java8到底有哪些特性呢，总结如下：

Lambda表达式
函数式接口
Stream
Optional
Predicate
Function
Consumer
Filter
Map-Reduce
新的Date API

最核心的当然是函数式编程了，写代码非常简单，请看下面详细例子介绍

2.Java8 lambda使用总结－结合实例介绍

很多同学一开始接触Java8可能对Java8 Lambda表达式有点陌生，下面我将结合实例介绍Java8的使用 并与Java7进行比较：

基础类

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    private int id;
    private String name;
    private String address;


}

1.List操作

public class ExampleList {
    private static List<String> items = new ArrayList<>();

    static {
        items.add("A");
        items.add("BC");
        items.add("C");
        items.add("BD");
        items.add("E");
    }

    public static void main(String[] args) {
        //Java8之前操作List
        for(String item:items){
            System.out.println(item);
        }

        //Java8 lambda遍历list
        items.forEach(c-> System.out.println(c));

        items.forEach(item->{
            if("C".equals(item)){
                System.out.println(item);
            }
        });

        System.out.println("--------");

        //先过滤
        items.stream().filter(s->s.contains("B")).forEach(c1-> System.out.println(c1));

    }
}

2.Map操作

public class ExampleMap {

    private static Map<String, Integer> items = new HashMap<>();

    static {
        items.put("A", 10);
        items.put("B", 20);
        items.put("C", 30);
        items.put("D", 40);
        items.put("E", 50);
        items.put("F", 60);
    }

    public static void main(String[] args) {

        //Java8之前遍历是这样遍历map
        for(Map.Entry<String,Integer> entry:items.entrySet()){
            System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());
        }

        //Java8遍历map
        items.forEach((key,value)-> System.out.println("key:" + key + " value:" + value));


    }


}

3.Groupingby操作

/**
 * 
 *Java8 Collectors.groupingBy and Collectors.mapping example
 */
public class ExampleMapping {

    private static List<Person> personList = Lists.newArrayList();

    static {
        personList.add(Person.builder().id(10).address("apple").address("shanghai").build());
        personList.add(Person.builder().id(12).address("apple").address("wuhan").build());
        personList.add(Person.builder().id(16).address("apple").address("nanjing").build());
    }

    public static void main(String[] args) {
        //分组
        Map<String, List<Person>> collect = personList.stream().collect(Collectors.groupingBy(c -> c.getAddress()));
        System.out.println(collect);
    }
}

4.List转换为Map

public class ExampleListConvertMap {

    private static List<Person> personList = Lists.newArrayList();

    static{
        personList.add(Person.builder().id(20).name("zhangsan").address("shanghai").build());
        personList.add(Person.builder().id(30).name("lisi").address("nanjing").build());
    }

    public static void main(String[] args) {
        //Java8 List转换Map
        Map<Integer,Person> map_ = personList.stream().collect(Collectors.toMap((key->key.getId()),(value->value)));
        map_.forEach((key,value)-> System.out.println(key + ":" + value));
        
        Map<Integer, Person> mappedMovies = personList.stream().collect(  
            Collectors.toMap(Person::getRank, Person::getData)); 

    }
}

 

5.FilterMap操作

public class ExampleFilterMap {

    private static Map<Integer,String> map_ = Maps.newHashMap();

    static{
        map_.put(1, "linode.com");
        map_.put(2, "heroku.com");
        map_.put(3, "digitalocean.com");
        map_.put(4, "aws.amazon.com");
    }

    public static void main(String[] args) {
        //before java iterator map
        String result = null;
        for(Map.Entry<Integer,String> entry:map_.entrySet()){
            if("heroku.com".equals(entry.getValue())){
                result = entry.getValue();
            }
        }

        System.out.println("Before Java 8 :" + result);

        //Java8 Map->Stream->Filter->String
        result =  map_.entrySet().stream().
                filter(map->"heroku.com".equals(map.getValue()))
                .map(map->map.getValue())
                .collect(Collectors.joining());
        System.out.println("Java 8 :" + result);

       Map<Integer,String> collect =  map_.entrySet().stream()
                .filter(c->c.getKey()==2)
                .collect(Collectors.toMap(p->p.getKey(),p->p.getValue()));
        System.out.println(collect);

    }
}

6.Optional操作可以防止NullPointException

Optional<String> optional = Optional.of("hello");
System.out.println(optional.isPresent());//true
System.out.println(optional.get());//hello
System.out.println(optional.orElse("false"));
optional.ifPresent((s)-> System.out.println(s.charAt(0)));//h

 

7.给出一个详细的例子

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Employee {

    private String name;
    private int salary;
    private String office;
}


public class ExampleEmployee {

    private static List<Employee> employeeList = Lists.newArrayList();

    static{
        employeeList.add(Employee.builder().name("Matt").salary(5000).office("New York").build());
        employeeList.add(Employee.builder().name("Steve").salary(6000).office("London").build());
        employeeList.add(Employee.builder().name("Carrie").salary(20000).office("New York").build());
        employeeList.add(Employee.builder().name("Peter").salary(7000).office("New York").build());
        employeeList.add(Employee.builder().name("Pat").salary(8000).office("London").build());
        employeeList.add(Employee.builder().name("Tammy").salary(29000).office("Shanghai").build());
    }

    public static void main(String[] args) {
        //anyMatch
        boolean isMatch = employeeList.stream().anyMatch(employee -> employee.getOffice().equals("London"));
        System.out.println(isMatch);

        //返回所有salary大于6000
        boolean matched = employeeList.stream().allMatch(employee -> employee.getSalary()>4000);
        System.out.println(matched);

        //找出工资最高
        Optional<Employee> hightestSalary = employeeList.stream().max((e1,e2)->Integer.compare(e1.getSalary(),e2.getSalary()));
        System.out.println(hightestSalary);

        //返回姓名列表
        List<String> names = employeeList.stream().map(employee -> employee.getName()).collect(Collectors.toList());
        System.out.println(names);

        //List转换成Map
        Map<String,Employee> employeeMap = employeeList.stream().collect(Collectors.toMap((key->key.getName()),(value->value)));
        employeeMap.forEach((key,value)-> System.out.println(key + "=" + value));

        //统计办公室是New York的个数
        long officeCount = employeeList.stream().filter(employee -> employee.getOffice().equals("Shanghai")).count();
        System.out.println(officeCount);

        //List转换为Set
        Set<String> officeSet = employeeList.stream().map(employee -> employee.getOffice()).distinct().collect(Collectors.toSet());
        System.out.println(officeSet);

        //查找办公室地点是New York的员工
        Optional<Employee> allMatchedEmployees = employeeList.stream().filter(employee -> employee.getOffice().equals("New York")).findAny();
        System.out.println(allMatchedEmployees);

        //按照工资的降序来列出员工信息
        List<Employee> sortEmployeeList =  employeeList.stream().sorted((e1,e2)->Integer.compare(e2.getSalary(),e1.getSalary())).collect(Collectors.toList());
        //按照名字的升序列出员工信息
        List<Employee> sortEmployeeByName = employeeList.stream().sorted((e1,e2)->e1.getName().compareTo(e2.getName())).collect(Collectors.toList());
        System.out.println(sortEmployeeList);
        System.out.println("按照名字的升序列出员工信息:" + sortEmployeeByName);

        //获取工资最高的前2条员工信息
        List<Employee> top2EmployeeList= employeeList.stream()
                .sorted((e1,e2)->Integer.compare(e2.getSalary(),e1.getSalary()))
                .limit(2)
                .collect(Collectors.toList());
        System.out.println(top2EmployeeList);

        //获取平均工资
        OptionalDouble averageSalary = employeeList.stream().mapToInt(employee->employee.getSalary()).average();
        System.out.println("平均工资:" + averageSalary);

        //查找New York
        OptionalDouble averageSalaryByOffice = employeeList.stream().filter(employee -> employee.getOffice()
                .equals("New York"))
                .mapToInt(employee->employee.getSalary())
                .average();
        System.out.println("New York办公室平均工资:" + averageSalaryByOffice);

    }
}

 

8.Java8常见操作


public class EmployeeTest {

    public static List<Employee> generateData() {
        return Arrays.asList(new Employee("Matt", 5000, "New York"),
                new Employee("Steve", 6000, "London"),
                new Employee("Carrie", 10000, "New York"),
                new Employee("Peter", 7000, "New York"),
                new Employee("Alec", 6000, "London"),
                new Employee("Sarah", 8000, "London"),
                new Employee("Rebecca", 4000, "New York"),
                new Employee("Pat", 20000, "New York"),
                new Employee("Tammy", 9000, "New York"),
                new Employee("Fred", 15000, "Tokyo"));
    }

    public static Map<String, Integer> generateMapData() {
        Map<String, Integer> items = Maps.newHashMap();
        items.put("A", 10);
        items.put("B", 20);
        items.put("C", 30);
        items.put("D", 40);
        items.put("E", 50);
        items.put("F", 60);

        return items;
    }


    @Test
    public void testEmployee() {
        List<Employee> results = generateData();

        //打印出名字是Steve的员工信息
        results.forEach(c -> {
            if (c.getName().equals("Steve")) {
                System.out.println(c);
            }
        });

        System.out.println("---------");

        //找出年薪超过6000的员工
        results.stream().filter(c -> c.getSalary() >= 60000).forEach(c -> System.out.println(c));

        System.out.println("--->>>>>>----");

        //java8遍历map
        Map<String, Integer> map_ = generateMapData();
        map_.forEach((key, value) -> System.out.println("key:" + key + "," + "value:" + value));

        System.out.println("---->>>>分组>>>-----");

        //java8 分组操作
        Map<String, List<Employee>> groupMap = results.stream().collect(Collectors.groupingBy(c -> c.getOffice()));
        System.out.println(groupMap);

        System.out.println("---->>>>List转化为Map>>>----");
        //List转化Map
        Map<String, Object> map = results.stream().collect(Collectors.toMap(Employee::getName, Employee::getOffice));
        map.forEach((key, value) -> System.out.println("key:" + key + "," + "value:" + value));

        System.out.println("---->>>>>>>----");
        Map<Integer, Employee> employeeMap = results.stream().collect(Collectors.toMap((key -> key.getSalary()), (value -> value)));
        employeeMap.forEach((key, value) -> System.out.println(key + "," + value));

        System.out.println("---->>遍历map>>>----");
        //打印出值大于30的map
        Map<String, Integer> resultMap = map_.entrySet().stream().filter(c -> c.getValue() > 30).collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));
        resultMap.forEach((key, value) -> System.out.println(key + "=" + value));

        System.out.println(">>>>>>>>>>>>>>>");
        //打印key=D的map
        Map<String, Integer> mapResults = map_.entrySet().stream().filter(c -> c.getKey().equals("D")).collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));
        mapResults.forEach((key, value) -> System.out.println(key + ">>>>" + value));

        System.out.println(">>>>>>>Optional>>>>>>>");
        Optional<String> optional = Optional.of("hello");
        System.out.println(optional.isPresent());

    }

    @Test
    public void testEmployeeExample() {
        //anyMatch
        List<Employee> employeeList = generateData();
        boolean isMatch = employeeList.stream().anyMatch(employee -> employee.getOffice().equals("London"));
        System.out.println(isMatch);

        //allMatch
        boolean matched = employeeList.stream().allMatch(employee -> employee.getOffice().equals("London"));
        System.out.println(matched);

        //找出工资最高的
        Optional<Employee> employeeOptional = employeeList.stream().max((e1,e2)->Integer.compare(e1.getSalary(),e2.getSalary()));
        System.out.println(employeeOptional);

        //找出工资最少的
        Optional<Employee> employee = employeeList.stream().min((e1,e2)->Integer.compare(e1.getSalary(),e2.getSalary()));
        System.out.println(employee);

        //返回姓名列表
        List<String> names = employeeList.stream().map(c->c.getName()).collect(Collectors.toList());
        System.out.println(names);

        System.out.println(">>>>>>>>>>>");
        //List转化Map
        Map<String,Employee> employeeMap = employeeList.stream().collect(Collectors.toMap((key->key.getName()),(value->value)));
        employeeMap.forEach((key,value)-> System.out.println(key + "=" + value));

        //统计办公室是New York的个数
        long officeCount =  employeeList.stream().filter(c->c.getOffice().equals("New York")).count();
        System.out.println(officeCount);

        long salaryCount = employeeList.stream().filter(c->c.getSalary()>60000).count();
        System.out.println(salaryCount);

        //List转化为Set
        Set<String> officeSet = employeeList.stream().map(c->c.getOffice()).distinct().collect(Collectors.toSet());
        System.out.println(officeSet);

        Set<Integer> salarySet = employeeList.stream().map(c->c.getSalary()).distinct().collect(Collectors.toSet());
        System.out.println(salarySet);

        //查找办公室地点是New York的员工
        Optional<Employee> optionals = employeeList.stream().filter(c->c.getOffice().equals("New York")).findAny();
        System.out.println(optionals);

        System.out.println(">>>>>工资降序排序>>>>>");
        //按照工资的降序来列出员工信息
        List<Employee> sortSalaryEmployeeList = employeeList.stream().sorted((e1,e2)->Integer.compare(e2.getSalary(),e1.getSalary())).collect(Collectors.toList());
        System.out.println(sortSalaryEmployeeList);

        System.out.println(">>>>>姓名升序排序>>>>>");
        List<Employee> sortNameEmployeeList = employeeList.stream().sorted((e1,e2)->e1.getName().compareTo(e2.getName())).collect(Collectors.toList());
        System.out.println(sortNameEmployeeList);

        System.out.println(">>>>获取工资最高的前2条员工信息");
        List<Employee> dispaly2EmployeeList = employeeList.stream().sorted((e1,e2)->Integer.compare(e2.getSalary(),e1.getSalary())).limit(2).collect(Collectors.toList());
        System.out.println(dispaly2EmployeeList);

        System.out.println(">>>>获取平均工资");
        OptionalDouble averageSalary = employeeList.stream().mapToInt(c->c.getSalary()).average();
        System.out.println(averageSalary);

        System.out.println(">>>>获取工作地点的平均工资");
        OptionalDouble optionalDouble = employeeList.stream().filter(c->c.getOffice().equals("New York")).mapToInt(c->c.getSalary()).average();
        System.out.println(optionalDouble);

        System.out.println(">>>>>>Java8 Optional用法>>>>>>");
        Optional<String> stringOptional = Optional.of("test");
        System.out.println(stringOptional.get());

        Optional<String> isOptional = Optional.ofNullable("hello");
        System.out.println(isOptional.isPresent());
        System.out.println(isOptional.get());
        System.out.println(isOptional.orElse("0"));

        System.out.println(">>>>>>>>>>>>");
        //Optional<String> optionalVal = Optional.of(null);
        // System.out.println(optionalVal);
        Optional<String> optional = Optional.ofNullable("optional");
        System.out.println(optional);
        System.out.println(optional.isPresent());
        System.out.println(optional.get());
        System.out.println(optional.orElse("haha"));
        System.out.println(">>>>>>>>>>>>");

        Optional<Employee> employeeOptional_ = employeeList.stream().filter(c->c.getOffice().equals("New York")).findFirst();
        System.out.println(employeeOptional_);

    }

}
雨夜星辰03
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Lambda表达式&Stream
12-17
该课程基于最新的java14平台，由浅入深的详细讲解了Lambda表达式/Stream/函数式接口/Optional类的使用，本课程属于java技术的进阶课程。
Java Lambda 筛选 filter
热门推荐
03-10 4万+
Java Lambda 筛选 filter public class Menu { /** * 菜品名称 */ private String name; /** * 菜品单价 */ private Double price; /** * 菜品斤数 */ private Double kilo; /** * 菜品类型：蔬菜、水果、肉类 */ private String type; public Menu() { } public Me
Java8新特性之Lambda表达式_lamdba map(string valueof)作用(1)
最新发布
2401_84301948的博客
05-16 300
需要完整版PDF学习资源。
Java Lambda详解
weixin_68320784的博客
03-31 2万+
Lambda表达式是JDK 8开始后的一种新语法形式。 作用：简化匿名内部类的代码写法 简化格式 (匿名内部类被重写方法的形参列表) -> { 重写方法 } Lambda表达式只能简化函数式接口的匿名内部类的写法形式 什么是函数式接口？ 首先必须是接口、其次接口中有且仅有一个抽象方法的形式 通常会在接口上加上一个@FunctionalInterface注解，标记该接口必须是满足函数式接口 如何使用Lambda？ 我们将根据下面三个问题来帮助大家理解和使用Lambda 背景：我们自
Java学习——lambda表达式
qq_45944185的博客
03-04 9532
lambda表达式
java 8 lambda表达式 distinct、groupingBy、filter、forEach、map、sorted、limit、max、anyMatch、allMatch、noneMatch
努力努力，努力努力的博客
07-22 3711
java 8 lambda表达式 distinct、groupingBy、filter、forEach、map、sorted、limit、max、min、anyMatch、allMatch、noneMatch
Java8 Lambda表达式详解及实例
09-01
Java 8 的 Lambda 表达式是语言的重大更新，它引入了一种更加简洁、优雅的方式来表示函数式编程中的匿名函数。Lambda 表达式的主要目的是简化处理那些只需要一次的、短小的、无状态的代码块，特别是对于那些只需要一...
Java8 Lambda表达式模板方法实现解析
09-07
总的来说，Java8 Lambda表达式结合模板方法，使得我们可以灵活地定义和使用函数式接口，实现代码的模块化和可扩展性。同时，通过Java的注解机制，可以为Lambda表达式和函数式接口提供更多的元信息，如编译时检查、...
Java8新特性lambda表达式有什么用(用法实例)
09-04
在 Java 8 中，Lambda 表达式与接口中的默认方法（default methods）相结合，解决了现有接口向 Lambda 风格迁移的问题。默认方法允许接口在不破坏向后兼容性的前提下添加新的功能。 批量数据操作（bulk operations...
java8 lambda表达式学习总结
04-23
Java 8 还引入了 Stream API，这与 Lambda 表达式结合使用时，可以进行高效且简洁的数据处理。例如，你可以用 `Arrays.asList().stream()` 创建一个流，然后用 `filter()`, `map()`, `reduce()` 等方法对数据进行...
使用Java 8中的Lambda表达式实现工厂模式
08-30
结合Lambda表达式，我们还可以使用Java 8的Stream API来动态地创建对象，例如，如果有一系列的形状类型，我们可以构建一个Map，将形状类型映射到对应的`Supplier`： ```java Map, Supplier<Shape>> shapeSuppliers ...
常用的 Lambda 表达式案例解析，工作中都会用到
CRMEB小程序商城的博客
05-30 1100
我们日常工作中，Lambda 使用比较多的场景，就是集合类下的 Lambda 流操作，往往几行代码可以帮助我们实现复杂代码 接下来我们把 Lambda 流的常用方法用案列讲解一下。 ForEach 集合的遍历 forEach 方法 Collect 将操作后的对象转化为新的对象 Filter Filter 为过滤的意思，只要满足 Filter 表达式的数据就可以留下来，不满足的数据被过滤掉 Map map 方法可以让我们进行一些流的转化，比如原来流中的元素是 A，通过 map 操作，可以使返回的流中的元
Lambda中间操作limit
Leon_Jinhai_Sun的博客
06-11 1335
Lambda中间操作limit
Java中anyMatch()、allMatch()、noneMatch()用法详解
hkl_Forever的博客
09-03 3万+
2、allMatch() 如果取反，等效于 noneMatch() 所有元素不等于指定元素返回 true。2、noneMatch() 如果取反，等效于 allMatch() 所有元素等于指定元素返回 true。2、单元素取反，因为是单元素只有a，没有不等于 a 的元素，所以不成立返回 false。anyMatch()：匹配到任何一个元素和指定的元素相等，返回 true。allMatch()：匹配到全部元素和指定的元素相等，返回 true。输出：anyMatch()测试取反多元素结果：true。
java Stream流与Lambda表达式
weixin_45703155的博客
04-01 1973
Stream流：
Lambda表达式
qq_45661125的博客
03-05 2696
Lambda表达式背景基础语法函数式接口Lambda表达式的基本使用变量的捕获匿名类中的变量捕获Lambda中的变量捕获Lambda在集合当中的使用Lambda的优点和缺点 背景 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式可以看作是一个匿名函数。 基础语法 基本语法: (parameters)
【Java8】常用lambda表达式
daohangtaiqian的博客
08-03 958
常用lambda表达式。
Optional的详细使用
qq_48581332的博客
05-18 774
文章目录一、使用1.创建对象2.安全消费3.安全获取值4.过滤5.判断 一、使用 1.创建对象 1.1 Optional类似是包装类，可以把具体的数据封装在其中，然后使用里面封装好的方法可以有效防止空指针 一般通过Optional类中的ofNullable方法来把数据封装到Optional类 public class Test03 { public static void main(String[] args) { Author author = author();
【Java基础】Java Lambda表达式详解
yubao0723的专栏
03-01 1万+
java8 中引入的 Lambda 表达式真的是个好东西，掌握之后，写代码更简洁了，一起来看看 Lambada 表达式常见的写法，加深理解。
Java 8 lambda 表达式
09-27
3. 并行处理：lambda 表达式可以与 Java 8 引入的并行处理方式相结合，提高代码的运行效率。 Lambda 表达式的使用场景主要包括： 1. 集合的遍历：通过使用 lambda 表达式，可以简化对集合的遍历操作，提高代码的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值