java8的Lambda、函数式接口、Steam流

最新推荐文章于 2023-06-06 10:56:45 发布
最新推荐文章于 2023-06-06 10:56:45 发布
阅读量193 收藏
点赞数
分类专栏： java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35876365/article/details/130034731
版权

Java8 TabTan

2020年11月1日记的笔记，迁移至此分享给需要他的人。主要介绍了java8的新特性，包含Lambda表达式、函数式接口、Stream流。

简介

oracle于2014年3月发布，java5以来最具革命性地版本。

Lambda表达式

语法

格式一：有参数，没有返回值

1.举例 (o1,o2) -> Integer.compare(o1,o2);

2.格式

  • -> ：lambda操作符 或 箭头操作符
  • -> 的左边 ：lambda形参列表（就是接口中抽象方法的形参列表）
  • -> 的右边 ：lambda体 （就是重写的抽象方法的方法体）

3.Lambda表达式的使用

@Test
public void test1(){

    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println("666");
        }
    };
    r.run();
    System.out.println("*************");
    Runnable r1 = ()-> System.out.println("Lambda 666");
    r1.run();
}
-------------------------------------------------------------------
666
*************
Lambda 666

4.lambda表达式的本质：作为函数式接口的实例

格式二：需要一个参数，没有返回值
格式三：数据类型可以省略，因为可由编译器推断出，称为“类型推断”
@Test
public void test3(){
    Consumer<String> con = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    con.accept("我是老方法");
    System.out.println("*************");
    Consumer<String> con1 = (s)-> System.out.println(s);
    con1.accept("我是lambda");

}
--------------------------------------------------------------
我是老方法
*************
我是lambda
格式四：Lambda若只需要一个参数时，参数的小括号可以省略
@Test
public void test4(){
    Consumer<String> con1 = s-> System.out.println(s);
    con1.accept("我是lambda");
}
---------------------------------------------------------------
我是lambda
格式五：lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
@Test
public void test5(){
    Comparator<Integer> c = (o1,o2) ->{
        System.out.println(o1);
        System.out.println(o2);
        return o1-o2;
    };
    System.out.println(c.compare(1, 2));
}
---------------------------------------------------------------
1
2
-1
格式六：当lambda体只有一条语句时，return与大括号若有，都可以省略 （略）

总结

  • -> 左边：lambda 形参列表的参数类型可以省略（类型推断），如果lambda形参列表只有一个参数，其一对()也可以省略
  • -> 右边：lambda 体由 { } 包裹，如果 lambda 体只有一条语句可以省略 { } 和 return 关键字

函数式（Functional）接口

简介

  • 只包含一个抽象方法的接口，称为函数式接口。
  • 在一个接口上使用 @FunctionalInterface 注解检测这个接口是否是函数式接口。
  • java.util.function 定义了很多函数式接口

四大函数式接口

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

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

举例

@Test
public void test1(){
    happyTime(500,money -> System.out.println("消费"+money+"元，芜湖，起飞！"));
}

public void happyTime(double money, Consumer<Double> consumer){
    consumer.accept(money);
}
------------------------------------------------------------------------------------
消费500.0元，芜湖，起飞！

@Test
public void test2(){
    ArrayList<String> strings = new ArrayList<>();
    strings.add("aaaaaaaaaaaaa");
    strings.add("bbbbbbbbbbbbbbb");
    strings.add("a");
    strings.add("b");
    List<String> list = filterString(strings, s -> s.length() < 3);
    for (String s : list) {
        System.out.println(s);
    }
}

public List<String> filterString(List<String> list, Predicate<String> predicate){
    ArrayList<String> filterList = new ArrayList<>(list.size());
    for (String s:list) {
        if (predicate.test(s)){
            filterList.add(s);
        }
    }
    return filterList;
}
---------------------------------------------------------------------------------------
a
b

方法引用与构造器引用

简介

  • 当要传递给lambda体的操作，已经有实现的方法了，就可以使用方法引用。
  • 方法引用就是lambda表达式，通过方法名来指向一个方法，可以认为是 lambda 的语法糖。

语法

使用格式：类（或对象）:: 方法名

具体分为如下三种情况

  • 对象 :: 非静态方法
  • 类 :: 静态方法
  • 类 :: 非静态方法
情况一 对象 :: 实例方法
@Test
public void test3(){
    Consumer<String> con = System.out::println;
    con.accept("方法引用,起飞，起飞");

}
------------------------------------------------------

方法引用,起飞，起飞

注意

方法引用使用时要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同。 （情况三除外）

情况二 类 :: 静态方法
@Test
public void test4(){
    Comparator<Integer> con = Integer::compare;
    System.out.println(con.compare(1, 2));
}
-------------------------------------------------
-1
情况三 类 :: 实例方法
@Test
public void test5(){
    Comparator<String> com = (s1,s2) -> s1.compareTo(s2);
    System.out.println(com.compare("a","b"));
    System.out.println("***********************");
    Comparator<String> com1 = String::compareTo;
    System.out.println(com1.compare("b","c"));
}
--------------------------------------------------
-1
***********************
-1

构造器引用

@Test
    public void test6(){
        Supplier<Student> sup = () -> new Student();
        System.out.println(sup.get());
        System.out.println("****************");
        Supplier<Student> sup1 = Student::new;
        System.out.println(sup1.get());
    }

数组引用

@Test
public void test7(){
    Function<Integer,String[]> fun = length -> new String[length];
    String[] apply = fun.apply(3);
    System.out.println(apply.length);
    Function<Integer,String[]> fun1 = String[]::new;
    String[] apply1 = fun1.apply(2);
    System.out.println(apply1.length);
}
---------------------------------------------------------------------
3
2

强大的Stream API

Stram的实例化

创建一 ：通过调用Collection的接口默认方法 stream()
default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}
创建二：通过数组

数组工具类Arrays的stream方法，例如

	@Test
    public void test(){
        int[] arr = {1,2,3,4};
        IntStream stream = Arrays.stream(arr);
    }
创建三：Stream 的 of() 方法，例如
	@Test
    public void test2(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        Stream<String> stringStream = Stream.of("123");
    }
创建四：创建无限流
Stream.iterate()

Stream的中间操作

筛选与切片
filter
@Test
public void test3(){
    List<People> list = new ArrayList<>();
    list.add(new People("张三",17));
    list.add(new People("李四",22));
    list.add(new People("王五",30));
    list.add(new People("Tab Tan",18));
    Stream<People> stream = list.stream();
    Stream<People> peopleStream = stream.filter(p -> p.getAge() > 20);
    peopleStream.forEach(System.out::println);
}
------------------------------------------------------------------------
People{name='李四', age=22}
People{name='王五', age=30}
limit
@Test
public void test4(){
    List<People> list = new ArrayList<>();
    list.add(new People("张三",17));
    list.add(new People("李四",22));
    list.add(new People("王五",30));
    list.add(new People("Tab Tan",18));
    Stream<People> stream = list.stream();
    Stream<People> limit = stream.limit(3);
    limit.forEach(System.out::println);
}
---------------------------------------------------------------------------
People{name='张三', age=17}
People{name='李四', age=22}
People{name='王五', age=30}
skip
@Test
public void test5(){
    List<People> list = new ArrayList<>();
    list.add(new People("张三",17));
    list.add(new People("李四",22));
    list.add(new People("王五",30));
    list.add(new People("Tab Tan",18));
    Stream<People> stream = list.stream();
    Stream<People> skip = stream.skip(2);
    skip.forEach(System.out::println);
}
--------------------------------------------------------------------------
People{name='王五', age=30}
People{name='Tab Tan', age=18}
distinct
@Test
public void test6(){
    List<People> list = new ArrayList<>();
    list.add(new People("张三",17));
    list.add(new People("李四",22));
    list.add(new People("王五",30));
    list.add(new People("Tab Tan",18));
    Stream<People> stream = list.stream();
    // 去重
    Stream<People> distinct = stream.distinct();
    distinct.forEach(System.out::println);
}
----------------------------------------------------------------------------
People{name='张三', age=17}
People{name='李四', age=22}
People{name='王五', age=30}
People{name='Tab Tan', age=18}
映射
map(Function f)
@Test
public void test7(){
    List<String> list = Arrays.asList("a", "B", "C");
    Stream<String> stream = list.stream();
    Stream<String> stringStream = stream.map(String::toUpperCase);
    stringStream.forEach(System.out::println);
}
-------------------------------------------------------------------------------
A
B
C
mapToDouble
mapToInt
mapToLong
flatMap
排序
自然排序sorted
@Test
public void test8(){
    List<String> list = Arrays.asList("11", "22", "44", "33");
    list.stream().sorted().forEach(System.out::println);
}
---------------------------------------------------------------------------
11
22
33
44
定制排序sorted (Comparator com)
@Test
public void test9(){
    Comparator<People> comparator = Comparator.comparingInt(People::getAge);
    List<People> list = new ArrayList<>();
    list.add(new People("张三",17));
    list.add(new People("李四",22));
    list.add(new People("王五",30));
    list.add(new People("Tab Tan",18));
    Stream<People> stream = list.stream();
    stream.sorted(comparator).forEach(System.out::println);
}
-----------------------------------------------------------------------------
People{name='张三', age=17}
People{name='Tab Tan', age=18}
People{name='李四', age=22}
People{name='王五', age=30}

终止操作

匹配与查找
allmatch(Predicate p) 检查是否匹配所有元素
anyMatch(Predicate p) 至少一个
@Test
public void test10(){
    Comparator<People> comparator = Comparator.comparingInt(People::getAge);
    List<People> list = new ArrayList<>();
    list.add(new People("张三",17));
    list.add(new People("李四",22));
    list.add(new People("王五",30));
    list.add(new People("Tab Tan",18));
    Stream<People> stream = list.stream();
    boolean b = stream.anyMatch((e) -> e.getAge() < 20);
    System.out.println(b);
}
-------------------------------------------------------------------------------------
true
noneMatch(Predicate p) 没有
findFirst 返回第一个元素
findAny 返回当前流中的任意元素
count 返回流元素的总个数
max(Comparator c) 返回流中最大值
min(Comparator c) 返回流中最小值
forEach 懂的都懂
规约
reduce（T iden,BinaryOperator b）

可以将流中元素反复结合起来，得到一个值。返回T

@Test
public void test11(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream();
    Integer reduce = stream.reduce(0, Integer::sum);
    System.out.println(reduce);
}
-------------------------------------------------------------------------------------
15
reduce（BinaryOperator b）

可以将流中元素反复结合起来，得到一个值，返回Optional<T>

@Test
public void test12(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream();
    Optional<Integer> reduce = stream.reduce( Integer::sum);
    System.out.println(reduce);
}
-------------------------------------------------------------------------------------
Optional[15]
收集
collect（cellector c）

将流转换为其他形式，接收一个Collector接口实现，用于给Stream中元素做汇总的方法

@Test
public void test13(){
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Stream<Integer> stream = list.stream();
    List<Integer> collect = stream.skip(2).collect(Collectors.toList());
    collect.forEach(System.out::println);
}
-------------------------------------------------------------------------------------
3
4
5

Optional类

就是个容器，把你的东西给包着。

好饿啊早知道不学java了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 8新特性之Lambda表达式，轻松编写高效代码！
**My Coding Family**
06-02 1520
Lambda表达式是一种函数式编程技术，它可以将一个未命名的代码块作为参数传递给函数或方法。在Java 8中，Lambda表达式是一种新的语言结构，它允许我们编写更加简洁的代码，并且可以更有效地利用多核CPU。
java8 函数式库_JAVA8函数式编程系列2--流（Stream）
weixin_35895994的博客
02-23 1290
Jav8中，在核心类库中引入了新的概念，流(Stream)。流使得程序媛们得以站在更高的抽象层次上对集合进行操作。今天，居士将主要介绍Steam类中对应集合上操作的几个重要的方法。1、 Steam举例对使用Java的程序媛们，当需要处理集合里的每一个数据时，通常是使用迭代，再对每个返回的元素进行处理。比如：int count = 0;ArrayList nameList = new ArrayLi...
Java函数式编程教程（五）：Java Steam API
GentelmanTsao的博客
07-07 805
Java Stream API提供了一种处理对象集合的函数式方法。 Java Stream API是在Java 8中添加的，同时还具有其他一些函数式编程功能。 本Java Stream教程将解释这些函数式流的工作方式以及使用方法。
Java基础24 Lambda表达式及省略写法 Steam流 函数式接口
Xs943的博客
02-24 685
一、jdk8&jdk9接口的特性 1.概念：在jdk1.8 之后 接口中不仅可以有抽象方法 还可以存在其他的成员方法 2.添加的方法 jdk8 增加默认方法与静态方法 jdk9 增加私有的方法 3.影响 接口中不仅只有抽象方法 还有普通的方法 缩短接口与抽象类之间的差别,接口是可以多继承的 所以以后的趋势 接口可能替代抽象类 4.默认方法 概述 默认方法就是使用 default关键字来进行修饰方法 语法： 访问修饰符 default 返回值类型 方法名称(参数列表) { 方法体 } 特点： 接口中默
JAVA Stream 中 Function＜T, R＞ 中 apply，compose， andThen 方法学习总结
最新发布
weixin_44131922的博客
06-06 2337
Stream 中的 Function 实际上解决了一个简单的问题，那就是我们在实际书写代码的时候，一个方法一般只能作为代码中的某一行函数，用于处理里面的数值，但是并不能将一个方法作为一个参数，将方法以参数的形式将方法传递到下一个方法中继续使用。compose 看内部实现，这个方法的入参也为 Function 类型，当调用时会先执行 作为入参的 Function 中的apply 方法，再将计算的结果作为原有方法的 apply 入参。apply 的作用为执行当前方法函数，t 为入参，R 为返回值类型。
Java8新特性学习-函数式编程(Stream/Function/Optional/Consumer)
热门推荐
icarusliu的专栏
03-09 8万+
Java8新引入函数式编程方式，大大的提高了编码效率。本文将对涉及的对象等进行统一的学习及记录。 首先需要清楚一个概念：函数式接口；它指的是有且只有一个未实现的方法的接口，一般通过FunctionalInterface这个注解来表明某个接口是一个函数式接口。函数式接口是Java支持函数式编程的基础。 本文目录： 1 Java8函数式编程语法入门 2 Java函数式接口 2.1 Consu...
Java中Stream流的用法及使用备忘
Zhaof_Notes
12-21 6117
Java中Steam流的用法及使用备忘
让你彻底了解 Java 8 的 Lambda、函数式接口、Stream 用法和原理
06-11 273
就在今年 Java 25周岁了，可能比在座的各位中的一些少年年龄还大，但令人遗憾的是，竟然没有我大，不禁感叹，Java 还是太小了。（难道我会说是因为我老了？） 而就在上个月，Java 15 的试验版悄悄发布了，但是在 Java 界一直有个神秘现象，那就是「你发你发任你发，我的最爱 Java 8」. 据 Snyk 和 The Java Magazine 联合推出发布的 2020 JVM 生态调查报告显示，在所有的 Java 版本中，仍然有 64% 的开发者使用 Java 8。另外一些开发者可能.
java8新特性之Steam(告别繁琐的循环遍历)
日积月累，水滴石穿
06-14 8645
目录一、什么是Stream？传统集合遍历循环存在哪些弊端？二、Stream提供更优的写法三、获取流的方式1、根据Collection获取流2、根据Map获取流3、根据数组获取流四、Stream操作常用的方法 1、forEach : 逐一处理2、count：统计个数3、filter：过滤4、limit：取用前几个5、skip：跳过前几个6、map：映射7、concat：组合五、收集Stream结果1、收集到集合中2、收集到数组中Stream的到来，也得益于lambda表达式带来函数式编程，用于解决集合类库既有
Stream Java8的集合类利器——走进Java Lambda(二)
lsmsrc的专栏
11-14 3万+
通过前面的例子，相信你已经对Lambda表达式有了一个初步了解了，前一篇主要是属性Lambda的语法，这篇我们继续。 Java8做了很多改进，以便我们少写点代码。接下来我们就来稍微了解一下，JDK自带的库文件中的一些简便工具吧。在本系列第〇篇，我就以一段“滑稽”的代码开头。说，在集合里面经常会做这种“滑稽”的处理。幸运的是，Java8给集合类提供了新技能，解决这个问题，新技能是Streams。我
Java8 Stream API介绍
weixin_34029949的博客
09-01 320
Stream API是Java8中处理集合的关键组件，提供了各种丰富的函数式操作。 Stream的创建 任何集合都可以转换为Stream： //数组 String[] strArr = new String[]{"aa","bb","cc"}; Stream<String> stre...
强大的 Stream 函数式编程
天行健，君子以自强不息；地势坤，君子以厚德载物。
07-14 333
前言Java8（又称为 Jdk1.8）是 Java 语言开发的一个主要版本。Oracle 公司于 2014 年 3 月 18 日发布 Java8，它支持函数式编程，新的 JavaScrip...
JAVA8 Function及Stream编程
blacksoil55的博客
10-26 6254
JAVA8引入函数式编程后，增加了灵活性，原来需要通过ScriptEngine调用脚本语言，现在通过Function接口即可。 方便了编码，代码也比较简洁些。 1. Function     函数式编程的格式如下集中方式：     a. 标准方式     (Type1 param1, Type2 param2, ..., TypeN paramN) -> {     statment1
java8中的stream,function包的常用方法总结
ziwenCSDN的博客
06-06 3114
由于工作需要如下是java8中的stream,function两个包中的常用方法. 一,首先定义两个List:  List javaProgrammers=new ArrayList(){             {                 add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2
Java8新特性概览——Stream特性，Lambda表达式，函数式接口Function、Predicate、Consumer，方法引用等概述
学习中
04-08 1766
概述： Java 8 新特性概述：https://www.ibm.com/developerworks/cn/java/j-lo-jdk8newfeature/index.html JAVA8 十大新特性详解：https://www.cnblogs.com/xingzc/p/6002873.html 关于lambda表达式： State of the Lambda：http://cr.openjd...
java8常用的steam函数
gejiangbo222的专栏
05-12 1336
filter filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤掉空字符串： List<String> strings = Arrays.asList("Hollis", "", "HollisChuang", "H", "hollis"); strings.stream().filter(string -> !string.isEmpty()).forEach(System.out::println); //Hollis, , Ho...
java进阶 13（Steam流 方法引用）
Ulrica_Amaris的博客
08-12 695
Stream流 1.引言： 将集合A根据条件一过滤为子集B； 然后再根据条件二过滤为子集C。 代码示例： import java.util.ArrayList; import java.util.List; public class Demo02NormalFilter { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("张无忌"); list.add
JDK8新特性Stream流使用详解
weixin_43883790的博客
09-15 981
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。 元素流在管道中经过中间操作（intermediate operation）的处理，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值