关于Lambda表达式与Stream（抄袭）

最新推荐文章于 2024-08-13 19:45:55 发布
最新推荐文章于 2024-08-13 19:45:55 发布
阅读量409 收藏 1
点赞数
原文链接：https://blog.csdn.net/Duingold/article/details/81748513
版权

关于Lambda表达式与Stream

说明

在网上看到一个人写的总结，挺好，因此全量摘抄下来，以便理解和查阅

Lambda 表达式

Lambda 语法

Lambda 表达式在Java中引入了一个新的语法元素和操作符 -> ,它将Lambda分成两个部分:
左侧 ：指定Lambda表达式需要的所有参数
右侧 ：指定了Lambda体，即Lambda表达式要执行的功能

语法格式一: 无参,无返回值,Lambda体只需要一条语句
package com;

public class Test1 {

    public static void main(String[] args) {

        // 不用lambda
        /*Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("I'm run");
            }
        };*/

        Runnable runnable = () -> System.out.println("I'm run");
        runnable.run();
    }
}
语法格式二: Lambda有一个参数，且无返回值
package com;

import java.util.function.Consumer;

public class Test2 {
    public static void main(String[] args) {
        //不用lambda
        /*Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };*/

        Consumer<String> consumer = (s)-> System.out.println(s);
        
        consumer.accept("hi,coulson");
    }
}
语法格式三: Lambda有一个参数，参数的小括号可以省略
package com;

import java.util.function.Consumer;

public class Test3 {

    public static void main(String[] args) {

        Consumer<String> com = x-> System.out.println(x);
        com.accept("hi");
    }
}
语法格式四:Lambda需要两个参数，并且有返回值，多条语句时必须加上{}
package com;

import java.util.function.BinaryOperator;

public class Test4 {

    public static void main(String[] args) {

        BinaryOperator<Integer> bi = (x,y) ->{
            System.out.println("加法");
            return x+y;
        };
        Integer apply = bi.apply(6,4);
        System.out.println(apply);
    }
}
语法格式五：当lambda体只有一条语句时，return 与与大括号可以省略
package com;

import java.util.function.BinaryOperator;

public class Test5 {

    public static void main(String[] args) {
        BinaryOperator<Integer> bi = (x,y) -> x+y;
        int result = bi.apply(34,43);
        System.out.println(result);

    }
}
语法格式六:Lambda的参数列表的类型可以不写，因为jvm编译器可以通过上下文进行"类型推断"
package com;

import java.util.function.BinaryOperator;

public class Test6 {

    public static void main(String[] args) {
        BinaryOperator<Integer> bi = (x,y) -> x+y;
        int result = bi.apply(51,52);
        System.out.println(result);

    }
}

类型推断

上述Lambda表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型，程序依然可以编译,这是因为javac根据程序的上下文,在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的"类型推断"

函数式接口

只包含一个抽象方法的接口，成为函数式接口。
可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式跑出一个受检异常,那么该异常需要在目标解耦的抽象方法上进行声明）。
我们可以在任意函数式接口上使用@FunctionalInterface注解，这样可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

package com;

@FunctionalInterface
public interface TestFunction {
    
    String getValue(String str);
}

package com;

@FunctionalInterface
public interface TestFunction2<T,R> {
    
    R getValue(T t1, T t2);
}

作为参数传递Lambda表达式

package com;

public class Test6 {

    /**
     * 数据处理方法
     * @param str
     * @param function
     * @return
     */
    public String strHandler(String str, TestFunction function) {

        return function.getValue(str);
    }

    public static void main(String[] args) {
        
        // 自定义函数式接口，并使用Lambda表达式
        String result = new Test6().strHandler("abcd", x->x.toUpperCase());
        System.out.println(result);
    }
}

package com;

public class Test7 {

    public void op(Integer num1, Integer num2, TestFunction2<Integer, Integer> tf) {
        System.out.println(tf.getValue(num1, num2));
    }

    public void test3() {
        op(20,30,(x,y) -> x+y);
    }

    public static void main(String[] args) {
        new Test7().test3();
    }
}

注意：
作为参数传递Lambda表达式：为了将Lambda表达式作为参数传递，接受Lambda表达式的参数类型必须是与该Lambda表达式兼容的函数式接口的类型

Java8内置四大核心函数式接口

函数式接口参数类型返回类型用途
Consumer消费类型接口Tvoid对类型为T的对象应用操作,包含方法void accept(T t)
Supplier 供给型接口无T返回类型为T的对象,包含方法:T get();
Function<T,R>函数型接口TR对类型为T的对象应用操作,并返回结果。结果是R类型的对象。包含方法: R apply(T t);
Predicate断定型接口Tboolean确定类型为T的对象是否满足某约束,并返回boolean值。包含方法boolean test(T t);
package com;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

public class TestConsumer {

    public void consumer(Map<String, Double> money, Consumer<Map<String,Double>> con){

        con.accept(money);
    }

    public static void main(String[] args) {
        Map<String,Double> map = new HashMap<>();
        map.put("money",100000d);
        new TestConsumer().consumer(map,x-> x.put("money",x.get("money") - 2000d));
        System.out.println(map);
    }
}


package com;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

public class TestSupplier {

    public List<Integer> getNumList(int num, Supplier<Integer> sup) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(sup.get());
        }

        return list;
    }

    public static void main(String[] args) {
        List<Integer> list = new TestSupplier().getNumList(3, () -> {
            Random random = new Random();
            int i = random.nextInt(100);
            System.out.println("产生整数:" + i);
            return i;
        });
        System.out.println(list);
    }
}


package com;

import java.util.UUID;
import java.util.function.Function;

public class TestFunction {

    public String converString(String str, Function<String,String> function) {
        return function.apply(str);
    }

    public static void main(String[] args) {
        String name = "hello";
        String coverString = new TestFunction().converString(name, (x)->x+ UUID.randomUUID().toString());
        System.out.println(coverString);
    }
}


package com;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class TestPredicate {

    public List<String> converList(List<String> list, Predicate<String> predicate) {
        List<String> result = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (predicate.test(list.get(i))) {
                result.add(list.get(i));
            }
        }

        return result;
    }

    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("张飞","刘备","贾宝玉","赵云");
        List<String> result = new TestPredicate().converList(stringList,(x) ->x.length() > 2);
        System.out.println(result);
    }
}

其他接口

函数式接口参数类型返回类型用途
BiFunction<T,U,R>T,UR对类型为T,U参数应用操作，返回R类型的结果。包含方法为R apply(T t,U u);
UnaryOperator
(Function子接口)		TT对类型为T的对象进行意愿运算，并返回T类型的结果。包含方法为T apply(T t);
BinaryOperator
(BiFunction子接口)		T,TT对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为T apply(T t1,T t2);
BiConsumer<T,U>T,Uvoid对类型为T，U参数应用操作。包含方法为void accept(T t,U u);
ToIntFunction
ToLongFunction
ToDoubleFunction		Tint
long
double		分别计算int,long,double,值的函数
IntFunction
LongFunction
DoubleFunction
int
long
double		R参数分别为int,long,double类型的函数
方法引用与构造器引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符"::"将方法名和对象或类的名字分割开来。

如以下三种主要使用情况

对象::实例方法
类::静态方法
类::实例方法

package com;

import org.junit.Test;

import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一.方法引用:
 * 当要传递给Lambda体的操作,已经有实现的方法了，可以使用方法引用
 * 方法引用：使用操作符"::"将方法名和对象或类的名字分隔开来。
 * <p>
 * 三种情况：对象::实例方法
 * 类::静态方法
 * 类::实例方法
 * <p>
 * 注意:
 * Lambda体中调用方法的参数列表或返回值类型，必须与函数式接口中抽象方法的函数列表或返回值类型保持一致
 * 当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引用方法的第二个参数（或无参数）时：ClassName::methodName(例如:test4)
 * <p>
 * 二.构造器引用
 * 格式:ClassName::new
 * 注意:构造器参数列表要与接口中抽象方法的参数列表一致
 * 三.数据引用
 * 格式:type[]::new
 */
public class TestMethodRef {

    /**
     * 对象::实例方法
     */
    @Test
    public void test1() {

        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("haha");

        Consumer<String> conRef = System.out::println;
        conRef.accept("hehe");
    }

    /**
     * 对象::实例方法
     */
    @Test
    public void test2() {
        Employee employee = new Employee("sky", 30);
        Supplier<String> supplier = () -> employee.getName();
        String str = supplier.get();
        System.out.println(str);

        Supplier<String> suRef = employee::getName;
        System.out.println(supplier.get());
    }

    /**
     * 类::静态方法
     */
    @Test
    public void test3() {
        Comparator<Integer> comparable = (x, y) -> Integer.compare(x, y);
        int result = comparable.compare(5, 6);
        System.out.println("result=" + result);
        Comparator<Integer> comRef = Integer::compare;
        comRef.compare(8, 9);
        System.out.println("result=" + result);
    }

    /**
     * 类::实例方法
     */
    @Test
    public void test4() {
        //当需要引用方法的第一个参数是调用对象,并且第二个参数是需要引用方法的第二个参数(或无参数)时,才能使用
        BiPredicate<String, String> bi = (x, y) -> x.equals(y);
        boolean res = bi.test("test1", "test2");
        System.out.println("res=" + res);
        BiPredicate<String, String> biRef = String::equals;
        res = biRef.test("test1", "test2");
        System.out.println("res=" + res);

        Employee employee = new Employee("tom", 20);
        Function<Employee, String> function = (e) -> e.getName();
        String strRes = function.apply(employee);
        System.out.println("strRes=" + strRes);

        Function<Employee, String> funcRef = Employee::getName;
        strRes = function.apply(employee);
        System.out.println("strRes=" + strRes);
    }

    /**
     * 构造器引用
     */
    @Test
    public void test5() {
        Supplier<Employee> supplier = () -> new Employee();
        System.out.println(supplier.get());

        Supplier<Employee> supRef = Employee::new;
        System.out.println(supRef.get());

        Function<Integer, Employee> function1 = (x) -> new Employee(x);
        Function<Integer, Employee> funcRef1 = Employee::new;
        System.out.println(funcRef1.apply(30));

        Function<String, Employee> function2 = (x) -> new Employee(x);
        Function<String, Employee> funcRef2 = Employee::new;
        System.out.println(funcRef2.apply("Ronaldo"));
    }

    /**
     * 数组引用
     */
    @Test
    public void test6() {
        Function<Integer, String[]> function = (x) -> new String[x];
        String[] ss = function.apply(5);
        System.out.println(ss.length);

        Function<Integer, String[]> funRef = String[]::new;

        ss = funRef.apply(15);
        System.out.println(ss.length);
    }
}
接口中的默认方法与静态方法

Java 8 中允许接口中包含具有具体实现的方法，该方法称为"默认方法",默认方法使用default关键修饰。

package com;

public interface ITest1 {

    default String getName() {
        return "男人";
    }

    static void show() {
        System.out.println("this is the method of interface ");
    }
}
接口默认方法"类优先"原则

若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时

package com;

public interface ITest2 {

    default String getName() {
        return "ITest2.getName";
    }
}

package com;

public interface ITest3 {

    default String getName() {
        return "ITest2.getName";
    }

    static void show() {
        System.out.println("接口中的静态方法");
    }
}

package com;

public class MyClass {

    public String getName() {
        return "MyClass.getName";
    }
}

package com;

public class SubClass extends MyClass implements ITest2,ITest3 {

    @Override
    public String getName() {
        return ITest3.super.getName();
    }

    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        System.out.println(subClass.getName());
    }
}
接口中的静态方法
public interface ITest3 {

    default String getName() {
        return "ITest2.getName";
    }

    static void show() {
        System.out.println("接口中的静态方法");
    }
}
神盾局码农
关注
java8stream源码-ac2:源码抄袭检测工具
06-04
java8流源码交流电 阅读分析的分步示例以及有关如何在 AC2 中执行最常见任务的文档。 介绍 AC是一款源码抄袭检测工具。 它可以帮助教师和评分者检测用 C、C++、Java、PHP、XML、Python、ECMAScript 或 VHDL 等语言编写的一组作业中的抄袭（明文也可以，但不太精确）。 AC 结合了科学文献中的多种相似性检测算法，并允许以图形方式显示其结果。 主要作者 Manuel Freire 目前在 . AC 仍在西班牙其他大学（UAM、URJC）和国外（UTorino）中使用，尽管此列表并不完整或详尽。 通过迁移到 Github，该项目有望获得贡献者并确保未来的发展。 还有其他抄袭检测工具，例如 、 或 。 AC 是，在这种情况下 local ，并且不需要向远程服务器发送数据（不是 Moss 的情况） 健壮，用作其主要的相似性度量，但有可能整合其他额外的度量以获得更好的正在发生的事情的图片（JPlag、Moss 和 Plaggie 有硬编码分析，主要基于子字符串匹配标记化后）。 重在信息可视化。 AC 不会提供“复制百分比”； 相反，它将创建一个组内学生提交之间相
lanmbda表达式
qq_45214489的博客
02-26 2201
lanmbda表达式及应用 参考：添加链接描述 关于lanmbda函数 -1.将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。 *例如，add=lambda x, y: x+y 　　add(1,2)，输出为3。 -2.将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。 *例如，为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在...
lambda表达式
最新发布
weixin_67804833的博客
08-13 1186
便于并行处理：Lambda表达式与Java 8引入的Stream API结合使用，可以方便地进行集合的并行处理，充分发挥多核处理器的优势，提高代码的执行效率。可读性的折衷：尽管Lambda表达式可以提高代码的可读性，但在某些复杂的情况下，Lambda表达式可能变得难以理解和阅读，特别是当表达式变得过于复杂时。避免匿名内部类的繁琐语法：相比于使用匿名内部类，Lambda表达式的语法更为简洁，减少了冗余的代码，提高了编码效率。Lambda主体可以是一个表达式，表达式外的大括号，可加可不加。
别翻了，Lambda 表达式入门，看这篇就够了
沉默王二
02-09 1万+
说出来怕你们不相信，刚接到物业通知，疫情防控升级了，车辆只能出不能进，每户家庭每天可指派 1 名成员上街采购生活用品。这不是谣言，截个图自证清白，出自洛阳市湖北路街道处。 看来事态严峻，这样看似好心，但不一定办好事，去超时抢购的人会更多。不管了，只能窝在家做持久战了。趁这段时间，多分享一些原创文章给你们——有眼福了呀，多储备点知识，疫情结束后肯定能派上大用场。今天分享的主题是《Lambda 表达...
Lambda 详解
qq_41506199的博客
06-20 1万+
Lambda 入门
Lambda表达式
idpangpengcheng的博客
03-16 3185
lambda
Stream、Lambda表达式练习.doc
01-14
Stream和Lambda表达式实践 在Java中，Stream API是Java 8中引入的一种新的数据处理方式，它可以对集合进行各种操作，如过滤、映射、聚合等。Lambda表达式是Java 8中引入的一种新的函数式编程方式，它可以将函数作为...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
【Java8】Lambda表达式 和 Stream API 是Java编程语言中的两个重要创新，它们极大地提升了代码的简洁性和可读性，特别是在处理集合数据时。这里我们将深入探讨这两个特性，并结合实际示例来理解它们的工作原理。 ...
Java8 Lambda表达式与Stream API (一)：Lambda表达式
什么都不会的小菜鸟
05-09 4033
你要知道的Java8 匿名内部类、函数式接口、lambda表达式与Stream API都在这里转载请注明出处 http://www.jianshu.com/p/c832d2c6dd81本文主要讲解Java8 Stream API，但是要讲解这一部分需要匿名内部类、lambda表达式以及函数式接口的相关知识，本文将分为两篇文章来讲解上述内容，读者可以按需查阅。 Java 匿名内部类、lambda表达式
Java基础--Lambda表达式和Stream流式处理
weixin_33407107的博客
05-27 436
什么是Lambda表达式 jdk8开始支持Lambda表达式，用来让程序编写更优雅 利用Lambda可以更简洁的实现匿名内部类和函数声明与调用 基于Lambda提供stream流式处理极大简化了对集合的操作 List<String> names=Arrays.asList("peter","anna","mike","john"); //实现集合排序 Collections.sort(names,new Comparator<String>(){ @Override
详解Lambda表达式
weixin_44811903的博客
05-12 3万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、什么是面向接口编程？一、什么是Lambda表达式？1.Lambda表达式使用前提：二、使用步骤1.引入库2.读入数据1、抽象方法2、翻译为Lambda表达式标准格式3、Lambda表达式的上下文推断1、推断条件2、推断条件三、Lambda表达式的使用(1) 根据赋值语句左侧的类型来进行Lambda上下文推断(2) Lambda表达式的简便写法 前言 一、什么是面向接口编程？ 提示：这里可以添加本文要记录的大概内容： 例如：
python之lambdas函数（lambda表达式）
cnds123的专栏
03-31 2089
python之lambdas函数（lambda表达式）介绍
Python lambda函数
u011699626的博客
08-11 3780
lambda函数是一个小地匿名函数，它允许有多个自变量，但是只能有一个表达式。 所谓匿名函数（英語：Anonymous Function）是指在计算机编程中是指一类无需定义标识符（函数名）的函数或子程序。（定义来源于维基百科，如果没有VPN可能无法打开该匿名函数的超链接） ......
Lambda 表达式使用详解，一篇文章手把手教会你
m0_70325779的博客
10-11 1444
记住一句话就可以了，"有且仅有一个抽象方法的接口叫函数式接口，接口上可以添加@FunctionalInterface注解"。例如我们刚才使用的 Compartor 接口，它就是一个函数式接口，我们看一下它的源码就可以知道，如下图所示，接口上就标注有 @FunctionalInterface 注解。
python中的lambda函数
热门推荐
柳小葱的博客
04-04 6万+
最近碰见太多次lambda函数了，那就来详细解释一下该函数。 lambda函数 我们先对lambda函数进行一个简单的介绍 lambda函数是一种匿名函数，即没有名字的函数 使用lambda保留字定义，函数名是返回结果 lambda函数的函数体只是一个表达式 lambda函数用于定义简单的、能够在一行内表示的函数 lambda表达式” : “后面，只能有一个表达式，def则可以有多个。 lambda一般用来定义简单的函数，而def可以定义复杂的函数 先来看一个例子： g=lambda x:x+1 pri
【java笔记】java中的lambda表达式和双冒号（::）运算符
zuzhiang的博客
06-17 1184
一、lambda表达式 lambda表达式又称闭包，它允许把函数作为参数传递进方法中 其格式为 (parameters) -> expression 或 (parameters) ->{ statements; } 只能引用标记了 final 的外层局部变量，不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量 lambda表达式的特征： **可选类型声明：**不需要声明参数类型，编译
Java8的lambda表达式和Stream API
weixin_30456039的博客
04-07 78
一直在用JDK8 ，却从未用过Stream，为了对数组或集合进行一些排序、过滤或数据处理，只会写for循环或者foreach，这就是我曾经的一个写照。 刚开始写写是打基础，但写的多了，各种乏味，非过来人不能感同身受。今天，我就要分享一篇如何解决上述问题的新方法 - Stream API。但学习Stream之前却不得不学一下Lambda表达式。说实话，网上介绍Lambda表达式的文章很多，大...
Java Stream流的详解
流楚丶格念的博客
07-18 2574
Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。Java8中的Stream是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregateoperation)，或者大批量数据操作(bulkdataoperation)。StreamAPI借助于同样新出现的Lambda表达式，而且使用并发模式，极大的提高编程效率和程序可读性。...
Java函数式编程：Lambda表达式与Stream流解析
Stream与传统的集合操作不同，例如，`forEach()`在Stream中用于遍历执行动作，而不是像集合中的迭代器那样修改元素。`distinct()`则返回一个新的Stream，其中不包含重复元素。`filter()`和`map()`等方法则提供了对流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值