java8特性,lambda表达式,简写的演变及应用

简介: 虽然可以使用Lambda表达式对某些接口进行简单的实现,但是并不是所有的接口都可以用Lambda表达式来实现,要求接口中定义的必须要实现的抽象方法==只能是一个==在JAVA8中 ,对接口加了一个新特性:default可以使用default对接口方法进行修饰,被修饰的方法在接口中可以默认实现
🍬 博主介绍
👨‍🎓 博主主页: chad_chang的主页
✨主攻领域:【大数据】【java】【python】【面试分析】

@[toc]

lambda表达式

1.1.简介

1.1.1.什么是Lambda?

Lambda是JAVA 8添加的新特性,说白了,Lambda是一个匿名函数

1.1.2.为什么使用Lambda

使用Lambda表达式可以对一个接口的方法进行非常简洁的实现

1.1.3.Lambda对接口的要求

虽然可以使用Lambda表达式对某些接口进行简单的实现,但是并不是所有的接口都可以用Lambda表达式来实现,要求接口中定义的必须要实现的抽象方法==只能是一个==
在JAVA8中 ,对接口加了一个新特性:default
可以使用default对接口方法进行修饰,被修饰的方法在接口中可以默认实现

1.1.4.@FunctionalInterface

修饰函数式接口的,接口中的抽象方法只有一个

1.2.基本语法

1.2.1.语法格式

(parameters) -> expression

(parameters) -> { statements; }
() 用来描述参数列表
{} 用来描述方法体 有时可以省略
-> lambda运算符

1.2.2.准备工作: 创建接口

/**
 * 无参数无返回值接口
 */
@FunctionalInterface
interface LambdaNoneReturnNoneParmeter {

    void test();
}

/**
 * 无返回值有单个参数
 */
@FunctionalInterface
interface LambdaNoneReturnSingleParmeter {

    void test(int n);
}

/**
 * 无返回值 多个参数的接口
 */
@FunctionalInterface
interface LambdaNoneReturnMutipleParmeter {

    void test(int a,int b);
}

/**
 * 有返回值 无参数接口
 */
@FunctionalInterface
interface LambdaSingleReturnNoneParmeter {

    int test();
}

/**
 * 有返回值 有单个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnSingleParmeter {

    int test(int n);
}

/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnMutipleParmeter {

    int test(int a,int b);
}

1.2.3.创建类Demo

import org.junit.Test;

public class Demo {

    @Test
    public void test01() {

        LambdaSingleReturnMutipleParmeter lambda1 = new LambdaSingleReturnMutipleParmeter() {
            @Override
            public int test(int a, int b) {
                return a + b;
            }
        };

        int result = lambda1.test(1, 2);
        System.out.println(result);
    }
}

==注意==:运行,会出现以下错误
在这里插入图片描述
==解决方法==
修改工作空间
修改工作空间,路径为:.idea --> workspace.xml

找到标签 。在标签里加一行:

<property name="dynamic.classpath" value="true" />

如下图:
在这里插入图片描述
此刻可以顺利运行,但是这不是我们的重点;
重点是==lambda的学习==。

1.3语法精简

1.3.1. lambda写法

在这里插入图片描述
在Demo类中继续写以下代码:

    @Test
    public void test02(){
        LambdaSingleReturnMutipleParmeter lambda2 = (int a, int b) -> {
                return a + b;
        };

        int result2 = lambda2.test(1, 2);
        System.out.println(result2);
    }
}

1.3.2. 参数类型精简

因为在接口的方法中, 已经定义类参数的类型, 所以在lambda表达式中参数的类型可以省略
    @Test
    public void test02(){
        LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> {
                return a + b;
        };

        int result2 = lambda2.test(1, 2);
        System.out.println(result2);
    }
}

1.3.3. 参数小括号精简

如果参数列表中, 参数的个数只有==一个==, 此时小括号可以省略;

    @Test
    public void test03(){
    //一个参数一个返回值
        LambdaSingleReturnSingleParmeter lambda3 = a -> {return 10;};

        int result3 = lambda3.test(1);
        System.out.println(result3);
    }

1.3.4.方法大括号精简

如果方法中只有==一条语句==, 此时大括号也可以省略

1.3.5.大括号精简补充

如果方法体中唯一的一条语句是一个返回结果语句,
则省略大括号的同时 也必须省略return关键字

    @Test
    public void test04(){
    //无参一个返回值
        LambdaSingleReturnNoneParmeter lambda4 =()  -> 10;

        int result4 = lambda4.test();
        System.out.println(result4);
    }

1.4.语法进阶

1.4.1.方法引用(静态方法和普通方法)

1.4.1.1.why

在实际应用过程中, 一个接口在很多地方都会调用同一个实现, 例如

LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
LambdaSingleReturnMutipleParmeter lambdab = (a, b) -> a * b;

这样一来每次都要写上具体的实现方法, 如果需求变更, 则每一处都需要更改, 基于这种情况, 可以将后续的实现更改为自定义的方法, 需要时直接调用即可.

1.4.1.2.what

方法引用:
可以快速的将一个lambda表达式的实现指向一个已经实现的方法
方法的隶属者 如果是静态方法, 隶属者就是一个类, 其他的话都是隶属对象
语法: ==方法的隶属者::方法名==
注意:

1 引用的方法中, 参数的个数和类型一定要和接口中定义的方法一致
2 返回值的类型也一定要和接口中的方法一致

1.4.1.3.how

1.4.1.3.1.静态方法
package stream.lambda.cn.itcast.b;

public class Demo {
    public static void main(String[] args) {
        // 精简前
        LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
        LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> a * b;

        // 精简后
        LambdaSingleReturnMutipleParmeter lambda3 = (a, b) -> MyStaticClass.add(a, b);
        LambdaSingleReturnMutipleParmeter lambda4 = MyStaticClass::multiplication;
    }


}

// 静态方法类
class MyStaticClass {
    public static int add(int x, int y) {
        return x + y;
    }

    public static int multiplication(int x, int y) {
        return x * y;
    }
}


/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnMutipleParmeter {

    int test(int a, int b);
}
1.4.1.3.2.非静态普通方法
package stream.lambda.cn.itcast.c;

public class Demo {
    public static void main(String[] args) {
        // 精简前
        LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
        LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> a * b;

        // 精简后
        MyNotStaticClass myNotStaticClassObj = new MyNotStaticClass();
        LambdaSingleReturnMutipleParmeter lambda3 = (a, b) -> myNotStaticClassObj.add(a, b);
        LambdaSingleReturnMutipleParmeter lambda4 = myNotStaticClassObj::multiplication;
        int result3 = lambda3.test(10, 20);
        int result4 = lambda4.test(10, 20);
        System.out.println("result3 = " + result3);
        System.out.println("result4 = " + result4);
    }
}

// 自定义非静态类
class MyNotStaticClass {
    public int add(int x, int y) {
        return x + y;
    }

    public int multiplication(int x, int y) {
        return x * y;
    }
}

/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnMutipleParmeter {
    int test(int a, int b);
}
目录
相关文章
|
10天前
|
安全 算法 Java
Java CAS原理和应用场景大揭秘:你掌握了吗?
CAS(Compare and Swap)是一种乐观锁机制,通过硬件指令实现原子操作,确保多线程环境下对共享变量的安全访问。它避免了传统互斥锁的性能开销和线程阻塞问题。CAS操作包含三个步骤:获取期望值、比较当前值与期望值是否相等、若相等则更新为新值。CAS广泛应用于高并发场景,如数据库事务、分布式锁、无锁数据结构等,但需注意ABA问题。Java中常用`java.util.concurrent.atomic`包下的类支持CAS操作。
41 2
|
23天前
|
存储 Java 开发者
什么是java的Compact Strings特性,什么情况下使用
Java 9引入了紧凑字符串特性,优化了字符串的内存使用。它通过将字符串从UTF-16字符数组改为字节数组存储,根据内容选择更节省内存的编码方式,通常能节省10%至15%的内存。
|
1月前
|
存储 Java 数据挖掘
Java 8 新特性之 Stream API:函数式编程风格的数据处理范式
Java 8 引入的 Stream API 提供了一种新的数据处理方式,支持函数式编程风格,能够高效、简洁地处理集合数据,实现过滤、映射、聚合等操作。
56 6
|
2月前
|
缓存 Java 开发者
Java多线程并发编程:同步机制与实践应用
本文深入探讨Java多线程中的同步机制,分析了多线程并发带来的数据不一致等问题,详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用,结合代码示例展示了如何有效解决竞态条件,提升程序性能与稳定性。
152 6
|
1月前
|
监控 Java 数据库连接
Java线程管理:守护线程与用户线程的区分与应用
在Java多线程编程中,线程可以分为守护线程(Daemon Thread)和用户线程(User Thread)。这两种线程在行为和用途上有着明显的区别,了解它们的差异对于编写高效、稳定的并发程序至关重要。
35 2
|
1月前
|
Java API 开发者
Java中的Lambda表达式与Stream API的协同作用
在本文中,我们将探讨Java 8引入的Lambda表达式和Stream API如何改变我们处理集合和数组的方式。Lambda表达式提供了一种简洁的方法来表达代码块,而Stream API则允许我们对数据流进行高级操作,如过滤、映射和归约。通过结合使用这两种技术,我们可以以声明式的方式编写更简洁、更易于理解和维护的代码。本文将介绍Lambda表达式和Stream API的基本概念,并通过示例展示它们在实际项目中的应用。
|
1月前
|
安全 Java API
Java中的Lambda表达式:简化代码的现代魔法
在Java 8的发布中,Lambda表达式的引入无疑是一场编程范式的革命。它不仅让代码变得更加简洁,还使得函数式编程在Java中成为可能。本文将深入探讨Lambda表达式如何改变我们编写和维护Java代码的方式,以及它是如何提升我们编码效率的。
|
2月前
|
安全 Java API
Java中的Lambda表达式与Stream API的高效结合####
探索Java编程中Lambda表达式与Stream API如何携手并进,提升数据处理效率,实现代码简洁性与功能性的双重飞跃。 ####
28 0
|
8天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
10天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。