Java基础之lambda表达式(JDK1.8新特性)

简介: Lambda表达式允许把函数作为一个方法的参数(函数作为参数传递进方法中)。函数式接口有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为lambda表达式。

Lambda表达式


Lambda表达式允许把函数作为一个方法的参数(函数作为参数传递进方法中)。函数式接口有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为lambda表达式。


各种函数式接口

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


JDK1.8 新增加的函数接口:

java.util.function


java.util.function 包下包含了很多类,用来支持Java的函数式编程

接口 &描述
BiConsumer<T,U> 代表了一个接受两个输入参数的操作,并且不返回任何结果
BiFunction<T,U,R> 代表了一个接受两个输入参数的方法,并且返回一个结果
BinaryOperaror 代表了一个作用于两个同类型操作符的操作,并且返回了操作符同类型的结果
BiPredicate<T,U> 代表了一个两个参数的boolean值方法
BooleanSupplier 代表了boolean值结果的提供方
Consumer 代表了接受一个输入参数并且无返回的操作
DoubleBinaryOperator 代表了作用于两个double值操作符的操作,并且返回了一个double值的结果
DoubleConsumer 代表了一个接受double值参数的操作,并且不返回结果
DoubleFunction 代表接受一个double值参数的方法,并且有返回值
Comparator 这个接口最主要的作用就是比较,其核心的方法是 compare(T o1, T o2),当 o1比o2小返回-1,当o1等于o2返回0,当o1大于o2返回1

Lambda的语法

(parameters) -> expression
(parameters) ->{ statements; }


可选类型声明:不需要声明参数类型,编译器可以统一识别参数值

可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号

可选的大括号:如果主体包括了一个语句,就不需要使用大括号

可选的返回关键字:如果主体只有一个表达式返回值,则编译器会自动返回值,大括号需要指明表达式返回的一个数值。

Lambda 表达实例

 

//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对象,并在控制台打印,不返回任何值
        (String s)->System.out.print(s);


举例说明

public class Java8Tester {
    public static void main(String[] args) {
   Java8Tester tester = new Java8Tester();
        //类型声明
        MathOperation addition = (int a, int b) -> a + b;
        //不用声明类型
        MathOperation subtraction = (a, b) -> a - b;
        //大括号中的返回语句
        MathOperation multipliaction = (int a, int b) -> {
            return a * b;
        };
        //没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;
        System.out.println("10+5=" + tester.operate(10, 5, addition));
        System.out.println("10-5=" + tester.operate(10, 5, subtraction));
        System.out.println("10*5=" + tester.operate(10, 5, multipliaction));
        System.out.println("10/5=" + tester.operate(10, 5, division));
        //不用括号
        GreetingService greetingService1 = message -> System.out.println("Hello " + message);
        //用括号
        GreetingService greetingService2 = (message) -> System.out.println("Hello " + message);
        greetingService1.sayMessage("Runoob");
        greetingService2.sayMessage("Google");
  }
    interface MathOperation{
        int operation(int a, int b);
    }
    interface GreetingService{
        void sayMessage(String message);
    }
    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}


变量作用域

lambda 表达式只能引用标记了final的外层局部变量,也就是说不能再lambda内部修改定义在域外的局部变量,否则会编译报错。 在lambda表达式中,只能引用值不会改变的变量。 这是因为如果在lambda表达式中改变变量,并发执行多个动作时就会不安全。对于目前为止我们看到的动作不会发生这种情况。

public class Java8Test2 {
    final static String salutation = "Hello!";
    public static void main(String[] args) {
        GreetingService greetingService = message -> System.out.println(salutation + message);
        greetingService.sayMessage("Runoob");
    }
    interface GreetingService {
        void sayMessage(String message);
    }
}


处理lambda 表达式

使用lambda表达式的重点是延迟执行。毕竟,如果想要立即执行代码,完全可以直接执行,而无需把它包装在一个

lambda表达式中。之所以希望以后执行代码,这有很多原因,如:


在一个单独的线程中运行代码:

多次运行代码;

在算法的适当位置运行代码(例如:排序中的比较操作);

发生某种情况时执行代码(如,点击了一个按钮,数据到达,等等);

只在必要时才运行代码。

例如:假设你想要执行一个动作n次,将这个动作和重复次数传递到一个 repeat 方法:

repeat(10,()->System.out.println("Hello,world"))

要接受这个lambda表达式,需要选择一个函数式接口。例如,我们可以使用 Runnable 接口:

public static void repeat(int n,Runnable action){
      for(int i=0;i<n;i++){
        action.run();
      }
 }


如果要告诉动作出现在某次迭代中。

/**
     * 在某次迭代中执行动作
     * @param n
     * @param action
     */
    public static void repeat(int n, IntConsumer action) {
        for (int i = 0; i < n; i++) {
            action.accept(i);
        }
    }


变量作用域

lambda 表达式有3个部分


一个代码块;

参数;

自由变量的值,这里指非参数而且不在代码中定义的变量。

函数式接口

函数接口,是指内部只有一个抽象方法的接口。但是可以有多个非抽象方法的接口,函数式接口可以被隐式转换为lambda表达式。


使用实例1

public class PredicateTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        /**
         *
         * Predicate<Integer> dispatcher = n -> true;
         n 是一个参数传递到Predicate接口的test方法
         n 如果存在test方法返回true
         */
        System.out.println("输出所有数据:");
        //传递参数n
        eval(list, n -> true);
//        Predicate<Integer> dispatcher = n -> true;
//        n 是一个参数传递到Predicate接口的test方法
//        如果n%2为0,test方法返回true
        System.out.println("******输出所有的偶数:");
        eval(list, n -> n % 2 == 0);
//        Predicate<Integer> predicate2=n->n>3
//        n是一个参数传递到Predicate接口的test方法
//        如果n大于3 test方法返回true
        System.out.println("输出大于3的所有数字:");
        eval(list, n -> n > 3);
    }
    public static void eval(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer n : list) {
            if (predicate.test(n)) {
                System.out.println(n+" ");
            }
        }
    }
}


使用实例2

public class CompareTest {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "pear");
        compareLength("apple", "banana", (n1, n2) -> -1);
        compareLength("banana", "pear", (n1, n2) -> 1);
        compareLength("banana", "banana", (n1, n2) -> 0);
        words.sort(Comparator.comparingInt(String::length));
    }
    public static void compareLength(String n1, String n2, Comparator comparator) {
        if (comparator.compare(n1, n2) == 0) {
            System.out.println("n1==n2" + n1 + "  " + n2);
        }
        if (comparator.compare(n1, n2) > 0) {
            System.out.println("n1>n2" + n1 + "  " + n2);
        }
        if (comparator.compare(n1, n2) < 0) {
            System.out.println("n1<n2" + n1 + "  " + n2);
        }
    }
}


使用示例3(集合排序)

现在我们有一个集合list,集合的里的数据类型是HashMap。那么我们如何根据HashMap中的某个key给list排序呢?

public class ListSortTest {
    public static void main(String[] args) {
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> map1 = new HashMap<>();
        map1.put("id", 2);
        map1.put("name", "张二");
        list.add(map1);
        Map<String, Object> map2 = new HashMap<>();
        map2.put("id", 1);
        map2.put("name", "张一");
        list.add(map2);
        Map<String, Object> map3 = new HashMap<>();
        map3.put("id", 3);
        map3.put("name", "张三");
        list.add(map3);
        //升序排列
        Collections.sort(list, (o1, o2) -> {
            int o1Id = (int) o1.get("id");
            int o2Id = (int) o2.get("id");
            if (o1Id > o2Id) {
                return 1;
            } else {
                return -1;
            }
        });
        //降序排列
        Collections.sort(list, new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                int o1Id = (int) o1.get("id");
                int o2Id = (int) o2.get("id");
                if (o1Id > o2Id) {
                    return -1;
                } else {
                    return 1;
                }
            }
        });
    }
}


使用示例4(按照对象属性给list排序)

public class ListSortTest2 {
    public static void main(String[] args) {
        Student student1 = new Student(1, "张三");
        Student student2 = new Student(2, "李四");
        List<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);
        //升序
        studentList.sort((o1, o2) -> {
            int o1Id = o1.getId();
            int o2Id = o2.getId();
            if (o1Id > o2Id) {
                return 1;
            } else {
                return -1;
            }
        });
        //降序
        studentList.sort((o1, o2) -> {
            int o1Id = o1.getId();
            int o2Id = o2.getId();
            if (o1Id > o2Id) {
                return -1;
            } else {
                return 1;
            }
        });
    }


总结


本文详细介绍了lambda表达式,lambda表达式是JDK1.8最重要的特性。基本上所有的内部类都可以用lambda表达式来表示。灵活的运用lambda表达式和函数式接口可以大大的简化的程序开发。


参考

Java 8 Lambda 表达式

Java 8 函数式接口


目录
打赏
0
0
0
0
62
分享
相关文章
什么是java的Compact Strings特性,什么情况下使用
Java 9引入了紧凑字符串特性,优化了字符串的内存使用。它通过将字符串从UTF-16字符数组改为字节数组存储,根据内容选择更节省内存的编码方式,通常能节省10%至15%的内存。
|
1月前
|
jdk8新特性-详情查看文档
jdk8新特性-详情查看文档
48 7
Java 8 新特性之 Stream API:函数式编程风格的数据处理范式
Java 8 引入的 Stream API 提供了一种新的数据处理方式,支持函数式编程风格,能够高效、简洁地处理集合数据,实现过滤、映射、聚合等操作。
57 6
Java中的Lambda表达式与Stream API的协同作用
在本文中,我们将探讨Java 8引入的Lambda表达式和Stream API如何改变我们处理集合和数组的方式。Lambda表达式提供了一种简洁的方法来表达代码块,而Stream API则允许我们对数据流进行高级操作,如过滤、映射和归约。通过结合使用这两种技术,我们可以以声明式的方式编写更简洁、更易于理解和维护的代码。本文将介绍Lambda表达式和Stream API的基本概念,并通过示例展示它们在实际项目中的应用。
Java中的Lambda表达式:简洁代码的利器####
本文探讨了Java中Lambda表达式的概念、用途及其在简化代码和提高开发效率方面的显著作用。通过具体实例,展示了Lambda表达式如何在Java 8及更高版本中替代传统的匿名内部类,使代码更加简洁易读。文章还简要介绍了Lambda表达式的语法和常见用法,帮助开发者更好地理解和应用这一强大的工具。 ####
深入理解Java中的Lambda表达式
在Java 8中引入的Lambda表达式,不仅简化了代码编写,还提升了代码可读性。本文将带你探索Lambda表达式背后的逻辑与原理,通过实例展示如何高效利用这一特性优化你的程序。
探索Java中的Lambda表达式
本文将深入探讨Java 8引入的Lambda表达式,这一特性极大地简化了代码编写,提高了程序的可读性。通过实例分析,我们将了解Lambda表达式的基本概念、使用场景以及如何优雅地重构传统代码。文章不仅适合初学者,也能帮助有经验的开发者加深对Lambda表达式的理解。
探索Java中的Lambda表达式
【10月更文挑战第37天】本文将带你深入理解Java的Lambda表达式,从基础语法到高级特性,通过实例讲解其在函数式编程中的应用。我们还将探讨Lambda表达式如何简化代码、提高开发效率,并讨论其在实际项目中的应用。
|
2月前
|
Java中的Lambda表达式与函数式编程####
【10月更文挑战第29天】 本文将深入探讨Java中Lambda表达式的实现及其在函数式编程中的应用。通过对比传统方法,我们将揭示Lambda如何简化代码、提高可读性和维护性。文章还将展示一些实际案例,帮助读者更好地理解和应用Lambda表达式。 ####
这款轻量级 Java 表达式引擎,真不错!
AviatorScript 是一个高性能、轻量级的脚本语言,基于 JVM(包括 Android 平台)。它支持数字、字符串、正则表达式、布尔值等基本类型,以及所有 Java 运算符。主要特性包括函数式编程、大整数和高精度运算、完整的脚本语法、丰富的内置函数和自定义函数支持。适用于规则判断、公式计算、动态脚本控制等场景。
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等