精华内容
下载资源
问答
  • 主要介绍了Java8 lambda表达式2种常用方法代码解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java 8 lambda

    2017-10-20 15:33:11
    java 8 初次使用者学习lambda的基本手册,通过练习可以快速掌握部分lambda语法,代码更加简洁
  •  Java 8 中的 Lambda 表达式和流(Stream)受到了热烈欢迎。这是 Java 迄今为止令人激动的特征。这些新的语言特征允许采用函数式风格来进行编码,我们可以用这些特性完成许多有趣的功能。这些特性如此有趣以至于被...
  • java8 看不到源码java8-lambda-samples 伴随着我关于 Java 8 lambda 表达式的闪电演讲的代码。 可以在此处找到演示幻灯片:
  • java 8 lambda

    2017-06-06 11:14:04
    a good book for learning java8
  • java8 lambda表达式在集合中的使用,包含代码例子。
  • 主要介绍了使用Java 8 Lambda表达式将实体映射到DTO的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java8lambda表达式Demo

    2016-12-28 17:56:04
    java8lambda表达式的安卓Studio工程Demo,供初步学习使用
  • java8Lambda10个案例

    2017-11-06 21:13:42
    Lambda实用案例, 简单易懂,适合初学者,一起学习jdk8.
  • 主要介绍了Java8 Lambda表达式模板方法实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java8使用lambda实现Java的尾递归的相关资料,需要的朋友可以参考下
  • java8流源码运动测试 用于处理 AWS Kinesis 流的 Java 8 lambda 示例 先决条件 Java 8 建造 使用./gradlew build来构建项目。 这将在build/distributions/中创建一个 zip 文件,该文件可以作为 lambda 上传到 AWS。 ...
  • 主要介绍了Java8 Lambda表达式详解的相关资料,需要的朋友可以参考下
  • java 8 lambda 教程

    2014-06-20 11:16:59
    java 8 lambda Concise syntax – More succinct and clear than anonymous inner classes • Deficiencies with anonymous inner classes – Bulky, confusion re “this” and naming in general, no nonfinal var...
  • 主要介绍了java8如何通过Lambda处理List集合,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java 8 lambda表达式引入详解及实例的相关资料,需要的朋友可以参考下
  • Java8 lambda 的使用

    万次阅读 2019-06-28 16:58:22
    摘要: 1.Java8 新特性介绍 2.项目中应用 1.Java8 新特性介绍 原文链接https://my.oschina.net/chenxiaobian/blog/704421,https://www.cnblogs.com/hmdrzql/p/6354010.html 现在我们有一个需求:给一个user组成的...

    摘要: 1.Java8 新特性介绍 2.项目中应用

    1.Java8 新特性介绍

    原文链接 https://my.oschina.net/chenxiaobian/blog/704421,https://www.cnblogs.com/hmdrzql/p/6354010.html

    现在我们有一个需求:给一个user组成的list 按照user的年龄排序。实现不难,代码如下:

     UserCompare是一个实现了Comprator的类

    这种方法由于sort方法的第二个参数是Comparator 所以你要写一个实现类(我这里是UserCompare类),并且override该接口的实现方法。

    java8提供了lambda来简化,有了lambda程序员从此不加班呀~    

    刚才那个Comparator的实现类以及内部若干代码就都省了,代之以lambda表达式。

    另外,IntelliJ会提示你改成更好的写法

    实现类里有多少代码,你就省了多少行代码。

    高兴了半天,到底是什么原理呢?其实是java8新提供的语法糖。

    我们打开java1.8 Comparator的定义,发现了类定义上面多了一个@FunctionalInterface

    对,1.8多了一个概念就是FunctionalInterface,这个Comparator就是一个FunctionalInterface

    有了这个注解,原来使用实现类的地方就可以代之以lambda表达式。

     

    写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_);
     
        }
    展开全文
  • java8 Lambda表达式简介

    千次阅读 2019-12-18 10:50:53
    先阐述一下JSR(Java Specification Requests)规范,即Java语言的规范提案。是向JCP(Java Community Process)提出新增一个标准化技术规范的正式请求。任何人都可以提交JSR,可以向Java平台增添新的API和服务。JSR已...

     

           先阐述一下JSR(Java Specification Requests)规范,即Java语言的规范提案。是向JCP(Java Community Process)提出新增一个标准化技术规范的正式请求。任何人都可以提交JSR,可以向Java平台增添新的API和服务。JSR已成为Java界的一个重要标准。可以理解为JSR是Java开发者以及授权者指定的标准,而Java开发者以及授权者形成一个JCP国际组织。职能是制定Java标准,即所有的规范都是有迹可循的。

      在Java8中推出的lambda表达式(参考JSR-335,地址为https://jcp.org/en/jsr/detail?id=335),官方的描述是:扩展Java语言以支持紧凑的lambda表达式(闭包),以及相关的语言和库功能,以使JavaSE的API能够使用lambda有效表达。通俗的理解为通过lambda表达式的本质是语法糖(Syntactic sugar,在计算机语言中添加的某种语法,这种语法对语言的功能没有影响,但是更方便程序员使用。语法糖让程序更加简洁,有更高的可读性),其底层还是通过编译器自动推断并生成匿名类来实现。可以使用更少的代码来实现同样的功能,使代码简洁的同时也使得Java支持闭包的功能。详见list.stream()和java.util.function包下提供了诸多的function接口。

      lambda表达式的语法:

         (parameters) -> expression 或

         (parameters) -> { statements; },

        即() -> {},等同于 new Interface(){}

        2. 代码大览

    package com.mengyao.bigdata.lambda;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Map、List和class的lambda使用
     * lambda本质是 (parameters) -> expression; 或者 (parameters) -> { statements; }。即() -> {},等同于 new Interface(){}
     * @author mengyao
     *
     */
    public class Test1 {
    
        public static void main(String[] args) {
            // ==== 1 ==== Map的lambda示例,jdk8之前的写法就不贴出来了
            Map<String, Integer> map = new HashMap<String, Integer>() {{
                put("spark", 1);
                put("storm", 1);
                put("hadoop", 1);
                put("flink", 1);
            }};
            /**
             * parameters确定
             *         map.forEach参数为java.util.function.BiConsumer<? super String, ? super Integer> action,是一个接口的声明,
             *         实现采用的是for(Map.Entry<K, V> entry : entrySet())将entry的k和v作为参数传递到action.accept(k,v)中 验证,到此k,v参数已确定。
             * expression使用
             *         接下来是给到lambda的expression来使用
             * 所以如下3个map.forEach同理
             */
            map.forEach((k,v) -> System.out.println(k+":"+v));
            map.forEach((k,v) -> {System.out.println(k+":"+v);});
            map.forEach((k,v) -> {
                if (k.equals("spark")) {
                    System.out.println(k+":"+v);
                }
            });
            
            System.out.println("====");
            
            // ==== 2 ==== List的lambda示例
            List<String> list = new ArrayList<String>(10) {{
                add("spark");
                add("storm");
                add("hadoop");
                add("flink");
            }};
            // 与map.forEach同理
            list.forEach(System.out::println);//System.out是PrintStream的实例,::println即为调用System.out对象的println方法
            list.forEach(item -> System.out.println(item));
            list.forEach(item -> {System.out.println(item);});
            list.forEach(item -> {
                if (item.equals("spark")) {
                    System.out.println(item);
                }
            });
            
            //==== 3 ==== 自定义类的lambda使用
            // 接口类非lambda方式使用
            System.out.println("==== "+new MathService() {
                @Override
                public int plus(int a, int b) {
                    return a+b;
                }
            }.plus(1, 2));
            
            // 接口类lambda方式使用1(实现plus方法)
            MathService service = (a,b) -> a+b;
            System.out.println("==== "+service.plus(1, 2));
            // 接口类lambda方式使用2,将接口的实现作为参数
            print((a,b)->a+b);
            
        }
    
        /**
         * 使用接口作为参数,通常方法内部会调用接口的方法
         * @param service
         */
        static void print(MathService service) {
            int a =1,b=2;
            System.out.println(service.plus(a, b));
        }
        
    }
    
    interface MathService {
        //return a+b
        int plus(int a, int b);
    }

    3.lambda表达式语法格式细解;
            1)无参数,无返回值的用法 :() -> System.out.println("hello lambda");

    @Test
    	public void test1() {
    		Runnable r = new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("hello runnable");
    			}
    		};
    		r.run();
    		Runnable r1 = () -> System.out.println("hello lambda");
    		r1.run();
    	}

     2).有一个参数,无返回值的用法: (x) -> System.out.println(x); 或者 x -> System.out.println(x); 一个参数,可以省略参数的小括号

    @Test
    	public void test2(){
    		Consumer<String> con = (x) -> System.out.println(x);
    		con.accept("有一个参数,无返回值的用法(Consumer函数式接口)");
    	}

    3).有两个参数,有返回值的:(x, y) -> x + y

    public void test3() {
    		BinaryOperator<Integer> binary = (x, y) -> x + y;
    		System.out.println(binary.apply(1, 2));// 3
    	}

    4)上面的例子,函数体中,都是一行语句,最后一个语法,介绍下,lambda表达式中,多行语句,分别在无返回值和有返回值的抽象类中的用法

    @Test
    	public void test4() {
    		// 无返回值lambda函数体中用法
    		Runnable r1 = () -> {
    			System.out.println("hello lambda1");
    			System.out.println("hello lambda2");
    			System.out.println("hello lambda3");
    		};
    		r1.run();
     
    		// 有返回值lambda函数体中用法
    		BinaryOperator<Integer> binary = (x, y) -> {
    			int a = x * 2;
    			int b = y + 2;
    			return a + b;
    		};
    		System.out.println(binary.apply(1, 2));// 3
     
    	}

    可以看到,多行的,只需要用大括号{}把语句包含起来就可以了;有返回值和无返回值的,只有一个return的区别;只有一条语句的,大括号和renturn都可以不用写;

    5).lambda的类型推断

    @Test
    	public void test5() {
    		BinaryOperator<Integer> binary = (Integer x, Integer y) -> x + y;
    		System.out.println(binary.apply(1, 2));// 3
    	}

    可以看到,在lambda中的参数列表,可以不用写参数的类型,跟java7中 new ArrayList<>(); 不需要指定泛型类型,这样的<>棱形操作符一样,根据上下文做类型的推断

     

    lamabd表达式中,需要有函数式接口的支持;

    函数式接口定义:接口中只有一个抽象方法的接口,称为函数式接口;

    可以使用@FunctionalInterface注解修饰,对该接口做检查;如果接口里,有多个抽象类,使用该注解,会有语法错误

     

    1.lambda表达式
    《java8 Lambda表达式简介》

    《java8 lambda表达式,方法的引用以及构造器的引用》

    2.函数式接口
    《java8 函数式接口简介》

    《JAVA8 Function接口以及同类型的特化的接口》

    《JAVA8 Consumer接口》

    《JAVA8 Supplier接口》

    《JAVA8 UnaryOperator接口》

    《JAVA8 BiConsumer 接口》

    3.stream接口操作

    《java8 Stream接口简介》

    《 java8 Stream-创建流的几种方式》

    《JAVA8 stream接口 中间操作和终端操作》

    《JAVA8 Stream接口,map操作,filter操作,flatMap操作》

    《JAVA8 stream接口 distinct,sorted,peek,limit,skip》

    《java8 stream接口 终端操作 forEachOrdered和forEach》

    《java8 stream接口 终端操作 toArray操作》

    《java8 stream接口 终端操作 min,max,findFirst,findAny操作》

    《java8 stream接口终端操作 count,anyMatch,allMatch,noneMatch》

    《java8 srteam接口终端操作reduce操作》

    《java8 stream接口 终端操作 collect操作》

    4.其他部分

    《java8 Optional静态类简介,以及用法》

    展开全文
  • JAVA8 Lambda 使用实例

    万次阅读 多人点赞 2018-07-29 18:26:32
    在对Java8 发布的Lambda表达式进行一定了解之后,发现Lambda最核心的就是 结合Stream API对集合数据的遍历、提取、过滤、排序等一系列操作的简化,以一种函数式编程的方式,对集合进行操作。下面总结了几种常用的...

    Lambda

    在对Java8 发布的Lambda表达式进行一定了解之后,发现Lambda最核心的就是 结合Stream API对集合数据的遍历、提取、过滤、排序等一系列操作的简化,以一种函数式编程的方式,对集合进行操作。下面总结了几种常用的示例Demo;

    Lambda表达式的语法
              基本语法:
              (parameters) -> expression  或  (parameters) ->{ statements; }

    含义

    // 1. 不需要参数,返回值为 5  
    () -> 5  
      
    // 2. 接收一个参数(数字类型),返回其2倍的值  
    x -> 2 * x  
      
    // 3. 接受2个参数(数字),并返回他们的差值  
    (x, y) -> x – y  
      
    // 4. 接收2个int型整数,返回他们的和  
    (int x, int y) -> x + y  
      
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
    (String s) -> System.out.print(s)

    1.用lambda表达式实现Runnable

    lambda表达式替换了原来匿名内部类的写法,没有了匿名内部类繁杂的代码实现,而是突出了,真正的处理代码。最好的示例就是 实现Runnable 的线程实现方式了: 用() -> {}代码块替代了整个匿名类

        @Test
        public void test(){
            //old
            new Thread((new Runnable() {
                @Override
                public void run() {
                    System.out.println("匿名内部类 实现线程");
                }
            })).start();
            //lambda
            new Thread( () -> System.out.println("java8 lambda实现线程")).start();
        }

    结果:

    以下demo 使用的 Person 实体 以及 person list:

    @Data
    @ToString
    @Accessors(chain = true)
    public class Person {
        private String name;
        private int age;
        private String sex;
    }
    
    
    private List<Person> getPersonList(){
            Person p1 = new Person().setName("liu").setAge(22).setSex("male");
            Person p2 = new Person().setName("zhao").setAge(21).setSex("male");
            Person p3 = new Person().setName("li").setAge(18).setSex("female");
            Person p4 = new Person().setName("wang").setAge(21).setSex("female");
            List<Person> list = Lists.newArrayList();
            list.add(p1);
            list.add(p2);
            list.add(p3);
            list.add(p4);
            return list;
        }


    2.forEach 遍历集合

        使用 forEach方法,直接通过一行代码即可完成对集合的遍历:

        @Test
        public void test1(){
            List<Person> list = getPersonList();
            list.forEach(person -> System.out.println(person.toString()));
        }
    
    结果
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)
        Person(name=li, age=18, sex=female)
        Person(name=wang, age=21, sex=female)

     双冒号::  表示方法引用,可以引用其他方法

        @Test
        public void test2(){
            List<Person> list = getPersonList();
            Consumer<Person> changeAge = e -> e.setAge(e.getAge() + 3);
            list.forEach(changeAge);
            list.forEach(System.out::println);
        }
    
        结果:
        Person(name=liu, age=25, sex=male)
        Person(name=zhao, age=24, sex=male)
        Person(name=li, age=21, sex=female)
        Person(name=wang, age=24, sex=female)

    3.filter 对集合进行过滤

         filter 可以根据传入的 Predicate 对象,对集合进行过滤操作,Predicate 实质就是描述了过滤的条件:

        @Test
        public void test3(){
            List<Person> list = getPersonList();
            list.stream().filter(e -> e.getAge() > 20)
                         .forEach(e -> System.out.println(e.toString()));
        }
           
        结果:
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)
        Person(name=wang, age=21, sex=female)

        当需要通过 多个过滤条件对集合进行过滤时,可以采取两种方式:

           1.可以通过调用多次filter 通过传入不同的 Predicate对象来进行过滤

           2.也可以通过 Predicate 对象的 and  or 方法,对多个Predicate 对象进行 且 或 操作

        @Test
        public void test4(){
            List<Person> list = getPersonList();
    
            Predicate<Person> ageFilter = e -> e.getAge() > 20;
            Predicate<Person> sexFilter = e -> e.getSex().equals("male");
    
            //多条件过滤
            list.stream().filter(ageFilter)
                         .filter(sexFilter)
                         .forEach(e -> System.out.println(e.toString()));
            System.out.println("----------------------------");
            // Predicate : and or
            list.stream().filter(ageFilter.and(sexFilter))
                         .forEach(e -> System.out.println(e.toString()));
        }
    
    
        结果:
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)
        ----------------------------
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)

    4.limit 限制结果集的数据量

        limit 可以控制 结果集返回的数据条数:返回三条数据,返回年龄>20的前两条数据

        @Test
        public void  test5(){
            List<Person> list = getPersonList();
            list.stream().limit(3).forEach(e -> System.out.println(e.toString()));
    
            System.out.println("----------------------------");
            list.stream().limit(2).filter(e -> e.getAge() > 20)
                         .forEach(e -> System.out.println(e.toString()));
        }
    
    
        结果:
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)
        Person(name=li, age=18, sex=female)
        ----------------------------
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)

    5. sorted 排序

    通过sorted,可以按自定义的规则,对数据进行排序,可以用两种写法,分别按 年龄 和 姓名排序

        @Test
        public void test6(){
            List<Person> list = getPersonList();
            //年龄排序
            list.stream().sorted((p1,p2) -> (p1.getAge() - p2.getAge()))
                         .forEach(e -> System.out.println(e.toString()));
            //姓名排序
            System.out.println("----------------------------");
            list.stream().sorted(Comparator.comparing(Person::getName))
                         .forEach(e -> System.out.println(e.toString()));
        }
    
    
        结果:
        Person(name=li, age=18, sex=female)
        Person(name=zhao, age=21, sex=male)
        Person(name=wang, age=21, sex=female)
        Person(name=liu, age=22, sex=male)
        ----------------------------
        Person(name=li, age=18, sex=female)
        Person(name=liu, age=22, sex=male)
        Person(name=wang, age=21, sex=female)
        Person(name=zhao, age=21, sex=male)

    6.max min 获取结果中 某个值最大最小的的对象

     max min 可以按指定的条件,获取到最大、最小的对象,当集合里有多个满足条件的最大最小值时,只会返回一个对象。

    如: 返回年龄最大的人

        @Test
        public void test7(){
            List<Person> list = getPersonList();
            // 如果 最大最小值 对应的对象有多个 只会返回第一个
            Person oldest = list.stream().max(Comparator.comparing(Person::getAge)).get();
            System.out.println(oldest.toString());
        }
    
    
        结果:
        Person(name=liu, age=22, sex=male)

    7.map 与 reduce也是两个十分重要的方法,

    map:对集合中的每个元素进行遍历,并且可以对其进行操作,转化为其他对象,如将集合中的每个人的年龄增加3岁

        @Test
        public void test8(){
            List<Person> list = getPersonList();
            //将 每人的年龄 +3
            System.out.println("修改前:");
            list.forEach(e -> System.out.println(e.toString()));
            System.out.println("修改后:");
            list.stream().map(e -> e.setAge(e.getAge() + 3 ))
                         .forEach(e -> System.out.println(e.toString()));
    
        }
    
        结果:
        修改前:
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)
        Person(name=li, age=18, sex=female)
        Person(name=wang, age=21, sex=female)
        修改后:
        Person(name=liu, age=25, sex=male)
        Person(name=zhao, age=24, sex=male)
        Person(name=li, age=21, sex=female)
        Person(name=wang, age=24, sex=female)

    reduce:也是对所有值进行操作,但它是将所有值,按照传入的处理逻辑,将结果处理合并为一个

    如:将集合中的所有整数相加,并返回其总和

        @Test
        public void test9(){
            //第一个参数是上次函数执行的返回值(也称为中间结果),第二个参数是stream中的元素,
            // 这个函数把这两个值相加,得到的和会被赋值给下次执行这个函数的第一个参数。
            //要注意的是:第一次执行的时候第一个参数的值是Stream的第一个元素,第二个参数是Stream的第二个元素
    
            //将所有人的年龄加起来 求和
            List<Integer> ages = Arrays.asList(2,5,3,4,7);
            int totalAge = ages.stream().reduce((sum,age) -> sum + age).get();
    
            System.out.println(totalAge);
            //带 初始值的计算, 如果list没有元素 即stream为null 则直接返回初始值
            int totalAge1 = ages.stream().reduce(0,(sum,age) -> sum+age);
            List<Integer> initList = Lists.newArrayList();
            int initTotalAge = initList.stream().reduce(0,(sum,age) -> sum+age);
    
            System.out.println("totalAge1: "+ totalAge1 + " initTotalAge: " + initTotalAge);
        }
    
        结果:
        21
        totalAge1: 21 initTotalAge: 0
    

    8.collect方法以集合中的元素为基础,生成新的对象

        在实际中,我们经常会以集合中的元素为基础,取其中的数据,来生成新的结果集,例如 按照过滤条件,返回新的List,

    或者将集合转化为 Set 或Map等操作,通过collect方法实现是十分简便的:

        @Test
        public void test10(){
            List<Person> list = getPersonList();
            //排序过滤等一系列操作之后的元素 放入新的list
            List<Person> filterList = list.stream().filter(e -> e.getAge() >20).collect(Collectors.toList());
            filterList.forEach(e -> System.out.println(e.toString()));
    
            //将 name 属性用" , ",连接拼接成一个字符串
            String nameStr = list.stream().map(Person::getName).collect(Collectors.joining(","));
            System.out.println(nameStr);
            //将name 放入到新的 set 集合中
            Set<String> nameSet = list.stream().map(person -> person.getName()).collect(Collectors.toSet());
            nameSet.forEach(e -> System.out.print(e + ","));
    
            System.out.println();
            System.out.println("map--------");
            Map<String,Person> personMap = list.stream().collect(Collectors.toMap(Person::getName,person -> person));
            personMap.forEach((key,val) -> System.out.println(key + ":" + val.toString()));
        }
    
        结果:
        Person(name=liu, age=22, sex=male)
        Person(name=zhao, age=21, sex=male)
        Person(name=wang, age=21, sex=female)
        liu,zhao,li,wang
        wang,zhao,liu,li,
        map--------
        wang:Person(name=wang, age=21, sex=female)
        zhao:Person(name=zhao, age=21, sex=male)
        liu:Person(name=liu, age=22, sex=male)
        li:Person(name=li, age=18, sex=female)

    9.summaryStatistics 计算集合元素的最大、最小、平均等值

    IntStream、LongStream 和 DoubleStream 等流的类中,有个非常有用的方法叫做 summaryStatistics(),可以返回 IntSummaryStatistics、LongSummaryStatistics 或者 DoubleSummaryStatistics,描述流中元素的各种摘要数据
    
     @Test
        public void test11(){
            List<Integer> ages = Arrays.asList(2,5,3,4,7);
            IntSummaryStatistics statistics = ages.stream().mapToInt(e -> e).summaryStatistics();
            System.out.println("最大值: " + statistics.getMax());
            System.out.println("最小值: " + statistics.getMin());
            System.out.println("平均值: " + statistics.getAverage());
            System.out.println("总和: " + statistics.getSum());
            System.out.println("个数: " + statistics.getCount());
        }
    
        结果:
        最大值: 7
        最小值: 2
        平均值: 4.2
        总和: 21
        个数: 5

     

    以上就是我总结的,在实际使用中lambda很常用的一些实例,lambda中还有很多其他很多新的方法,值得我们学习。大家可以动手试一试

    展开全文
  • 主要介绍了Java8lambda表达式的应用及一些泛型相关知识的相关资料
  • lambda 示例 Java 8 lambda 实验
  • 精通Java 8 lambda表达式

    2014-06-10 15:07:59
    这个是专门介绍java 8 lambda表达式的一本书,目前没有中文版的,这个是英文版的。
  • java8 lambda 表达式累加

    千次阅读 2020-09-10 13:53:12
    public static void main(String[] args) { List<CardProductOrderRelation> list=new ArrayList<>(); for (int i=0;i<10;... CardProductOrderRelation r=new CardProductOrderRelation();...
    public static void main(String[] args) {
            List<CardProductOrderRelation> list=new ArrayList<>();
            for (int i=0;i<10;i++){
                CardProductOrderRelation r=new CardProductOrderRelation();
                r.setSuccessAmount(BigDecimal.valueOf(i+2));
                r.setActualAmount(BigDecimal.valueOf(i+1));
                r.setActualBalance(BigDecimal.valueOf(i));
                list.add(r);
            }
            BigDecimal successAmount = list.stream().map(CardProductOrderRelation::getSuccessAmount).reduce(BigDecimal::add).get();
            BigDecimal actualAmount = list.stream().map(CardProductOrderRelation::getActualAmount).reduce(BigDecimal::add).get();
            BigDecimal actualBalance = list.stream().map(CardProductOrderRelation::getActualBalance).reduce(BigDecimal::add).get();
            System.out.println(String.format("%s %s %s",successAmount,actualAmount,actualBalance));
        }
    
    展开全文
  • Java 8 Lambda表达式的理解与使用

    千次阅读 2019-09-16 22:25:15
    Java 8 Lambda表达式的理解与使用Java 8 Lambda表达式的理解与使用新的改变 Java 8 Lambda表达式的理解与使用 新的改变 在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿什么东西做什么事情”。相对而...
  • Java 8 Lambda 表达式被编译成了什么?

    千次阅读 2020-08-26 08:50:00
    点击上方“朱小厮的博客”,选择“设为星标”后台回复"书",获取个gui在了解了Java 8 Lambda的一些基本概念和应用后, 我们会有这样的一个问题:Lambda表...
  • 主要介绍了Java 8 Lambda 表达式比较器使用示例代码,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • Java 8支持动态语言,看到了很酷的Lambda表达式,对一直以静态类型语言自居的Java,让人看到了Java虚拟机可以支持动态语言的目标。接下来通过本文给大家介绍Java 8 动态类型语言Lambda表达式实现原理分析,需要的朋友...
  • java 8 lambda 实现 Comparator

    千次阅读 2019-04-07 16:54:49
    java 8 lambda 实现Comparator 文章目录java 8 lambda 实现Comparator代码与写法1. 正常的写法2. java8 lambda 写法3. java8 lambda 不当人写法4. 我的错 Comparator不应该写出来 究极不当人写法抄的情况 代码与写法...
  • 今日有在学习Java8的一些新特征,了解到lambda和stream之后,去importNew无意间逛到了一篇:[Java8 Lambda表达式和流操作如何让你的代码变慢5倍](http://www.importnew.com/17262.html ""),惊讶之下又去了Stack ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,592
精华内容 63,436
关键字:

java8lambda

java 订阅