Java学习笔记---Lambda表达式及Stream流Api

最新推荐文章于 2023-04-17 17:05:10 发布
最新推荐文章于 2023-04-17 17:05:10 发布
阅读量95 收藏
点赞数
文章标签： stream java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42946027/article/details/115753445
版权

Lambda

特性：

允许把函数作为参数传递进方法。

前置条件：

必须是函数式接口----------》【函数式接口：满足以下三条1、接口中只有一个抽象方法。2、可以有默认实现的方法。3、可以有Object的方法】

@FunctionalInterface  //注解可以没有，有可以在不符合函数式接口的情况下报编译错误
public interface DoSomeThing {
    void doAny(String name);
}
//将函数式接口作为参数
static void ToSB(DoSomeThing doSomeThing) {
        doSomeThing.doAny("狗子");
    }

java内置函数式接口

  Consumer<T>   //消费型接口【有去无回】
      void accept(T t);
  Supplier<T>   //供给型接口
      T get();
  Function<T,R> //函数型接口
      R apply(T t);
  Predicate<T>  //断言型接口
      boolean test(T t);

参数的传递：

（）->{}

参数可以省略类型

参数只有一个可以省略（）

//单个参数可以不加（）
ToSB(name -> String.format("name:%s",name));
//类型可以省略，但有多个值时有类型必须都要有不能有的有有的没有
ToSB(String name->String.format("name:%s",name));

//代码块时必须有return，单行时则可以没有
ToSB2(name->{
   String name1= name;
    return "name:" + name1;
});

方法引用

静态方法引用：【注：Lambda体中调用的方法的参数列表与返回值类型与函数式接口中抽象方法的参数列表和返回值类型保持一致】

public static void main(String[] args) {
	//非静态方法引用
    ToSB(new TestLambda()::say);
	//静态方法引用
    ToSB(TestLambda::sayHi);
}

//非静态方法：new 类::方法名
String say(String name) {
    return "hello" + name;
}

//静态方法：直接 类::方法名
static String sayHi(String name) {
    return "hi" + name;
}

构造器引用

ClassName::new

【注：引用的构造器有参无参或者是那几个参与需要调用的构造器参数列表对应的函数式接口中抽象方法的参数列表保持一致】

数组引用

Type::new

Stream

特性：

Stream不存数据！

Stream不更改数据！

Stream为一次性的，不能重复使用！

每加一个“.”之前的流会报废，产生一个新的流！

创建List流的方法：

//1、通过Collection集合提供的串行流：stream()或并行流：parallelStream()
List<User> list = new ArrayList<>();
        list.add(new User("张一",2,"red"));
        list.add(new User("张二", 3, "yellow"));
        list.add(new User("张三",4,"red"));
list.stream();


//2、通过Arrays中的静态方法stream()数组获取流
Arrays.stream(new User []{new User("张一",2,"red"),
        new User("张二",3,"yellow"),
        new User("张三",4,"red")});


//3、通过Stream中的静态方法of()获取流
Stream.of(new User("张一",2,"red"),
        new User("张二", 3, "yellow")
        ,new User("张三",4,"red"));


//4、创建无限流----迭代
Stream<Integer> stream = Stream.iterate(0,x->x+2);


//5、创建无限流----生成
Stream.generate(()->Math.radom())

Stream流分为中间节点或者终止节点，区分方式：返回为Stream的为中间节点否则为终节点,不执行终止操作只有中间操作不会其任何效果。

在这里插入图片描述

流的执行顺序：

在这里插入图片描述

数据源执行时不是整个进入而是数据源中个个体一个个进入。

//list数据见上
list.stream().peek(a-> System.out.println(a.getName()))
        .peek(a-> System.out.println(a.getCole()))
        .toArray();
//*************控制台输出**********************
/**张一
  *red
  *张二
  *yellow
  *张三
  *red
  */

Stream API

1、筛选与切片
操作作用
filter接收Lambda从流中排除某些元素
limit(n)截断流使其元素不超过给定数量n
skip(n)跳过元素返回一个去掉了前n个元素的流，若流中元素不足n个则返回空流，与limit互补
distinct筛选，通过流所生成的元素的hashCode（）和equals（）去除重复
//操作通用数据
List<User> list = Arrays.asList(
        new User("张一", 2, "大红脸"),
        new User("张二", 3, "正宗黄种人"),
        new User("张三", 4, "大红脸"),
        new User("张四", 5, "黝黑透亮?黑无常:包大神"),
        new User("张四", 6, "毫无血色?白无常:小白"));

//1、filter过滤年龄小于五的User
 list.stream()
     .filter(u -> u.getAge() < 5)
     .forEach(System.out::println);
//*******************控制台*********************
//    User(name=张一, age=2, cole=大红脸)
//    User(name=张二, age=3, cole=正宗黄种人)
//    User(name=张三, age=4, cole=大红脸)


//2、limit获取1条
list.stream()
    .limit(1)
    .forEach(System.out::println);
//*******************控制台*********************
//User(name=张一, age=2, cole=大红脸)
        

//3、skip去掉前2条取后面的
list.stream()
            .skip(2)
            .forEach(System.out::println);
//*******************控制台*********************
//User(name=张三, age=4, cole=大红脸)
//User(name=张四, age=5, cole=黝黑透亮?黑无常:包大神)
//User(name=张四, age=6, cole=毫无血色?白无常:小白)


//4、distinct去重，
 list.stream()
     .map(u->u.getCole())  //只取肤色
     .distinct()
     .forEach(System.out::println);
//*******************控制台*********************
//大红脸
//正宗黄种人
//黝黑透亮?黑无常:包大神
//毫无血色?白无常:小白


//【注】当去重的为对象，需要重写hashCode和equal
// List<User> list = Arrays.asList(
//            new User("张一", 2, "大红脸"),
//            new User("张二", 3, "正宗黄种人"),
//            new User("张三", 4, "大红脸"),
//            new User("张四", 5, "黝黑透亮?黑无常:包大神"),
//            new User("张四", 5, "黝黑透亮?黑无常:包大神"),
//            new User("张四", 5, "黝黑透亮?黑无常:包大神"),
//            new User("张四", 6, "毫无血色?白无常:小白"));
//    @Test
//    public void Test1() {
//        list.stream().distinct().forEach(System.out::println);
//    }
//*******************控制台*********************
//User(name=张一, age=2, cole=大红脸)
//User(name=张二, age=3, cole=正宗黄种人)
//User(name=张三, age=4, cole=大红脸)
//User(name=张四, age=5, cole=黝黑透亮?黑无常:包大神)
//User(name=张四, age=6, cole=毫无血色?白无常:小白)

在这里插入图片描述

2、映射
操作作用
map接受Lambda，将元素转换成其他形式或提取信息，接受一个函数作为参数，该函数会被应用到每个元素并将其映射为一个新的元素。
flatMap接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连城一个流。

map同上

flatMap处理嵌套Stream，类似于addAll，将一个List中的全部元素添加到另一个List中。
在这里插入图片描述

List<String> str = Arrays.asList("aaa","bbb","ccc");

public static Stream<Character> getStr(String s){
    List<Character> strs = new ArrayList<>();

    for (Character s1:s.toCharArray()) {
        strs.add(s1);
    }
        return strs.stream();
}

@Test
public void Test1() {
   //用map结果是Stream<Stream<Character>>
   //  Stream<Stream<Character>> streamStream =  str.stream().map(TestStream::getStr);
    
   //用flatMap结果是Stream<Character>
   // Stream<Character> characterStream ==str.stream().flatMap(TestStream::getStr);
                                            str.stream().flatMap(TestStream::getStr).forEach(System.out::println);
}
//*******************控制台*********************
// a
// a
// a
// b
// b
// b
// c
// c
// c
3、排序
操作作用
sorted()自然排序
sorted(Comparator com)定制排序

区别：sorted()按照已有的Comparable排序（eg:String中的compareTo）
在这里插入图片描述
在这里插入图片描述

sorted(Comparator com)自己写按什么排序。

//sorted()
List<String> str = Arrays.asList("ddd", "aaa", "ccc", "bbb");

  str.stream()
         .sorted()
         .forEach(System.out::println);
//*******************控制台*********************
// aaa
// bbb
// ccc
// ddd
 list.stream()
      .sorted((x,y)->{
         if (x.getAge() == y.getAge()) {   //年龄相同按姓名排
              return x.getName().compareTo(y.getName());  
         } else {
              return x.getAge().compareTo(y.getAge()); //否则按年龄排
         }
       })
       .forEach(System.out::println);
//*******************控制台*********************
//    User(name=张一, age=2, cole=大红脸)
//    User(name=张二, age=3, cole=正宗黄种人)
//    User(name=张三, age=4, cole=大红脸)
//    User(name=张四, age=5, cole=黝黑透亮?黑无常:包大神)
//    User(name=张四, age=6, cole=毫无血色?白无常:小白)
4、终止操作
操作作用
allMatch检查是否全部匹配
anyMatch检查是否至少匹配一个元素
noneMath检查是否没有匹配元素
findFirst找到第一个元素
findAny返回当前流汇中任意元素
count返回总数
max最大
min最小

【注】返回的结果为Optional的原因：返回的结果可能为空，避免空指针

 //通用数据
List<User> list = Arrays.asList(
            new User("张一", 2, "大红脸", 1),
            new User("张二", 3, "正宗黄种人", 2),
            new User("张三", 4, "大红脸", 1),
            new User("张四", 5, "黝黑透亮?黑无常:包大神", 2),
            new User("张五", 6, "毫无血色?白无常:小白", 1));
//1、allMatch是否全部人都是1（男的）
System.out.println(list.stream().allMatch(u -> u.getSex() == 1));
/*******************控制台*********************
/**   
 * false
 */


//2、anyMatch是否有人是男的
System.out.println(list.stream().anyMatch(u -> u.getSex() == 1));
/*******************控制台*********************
/**   
 * true
 */

//3、noneMatch没有人既不是男的又不是女的
System.out.println(list.stream().noneMatch(u -> u.getSex() == 3));
/*******************控制台*********************
/**   
 * true
 */

 

//【注：findxxx通常与过滤、排序共用】
//4、findFirst得到第一个
System.out.println(list.stream().findFirst());
/*******************控制台*********************
/**   
 * Optional[User(name=张一, age=2, cole=大红脸, sex=1)]
 */


//5、findAny得到第一个
System.out.println(list.stream().findAny());
/*******************控制台*********************
/**   
 * Optional[User(name=张一, age=2, cole=大红脸, sex=1)]
 */

//6、count得到总数
System.out.println(list.stream().count());
/*******************控制台*********************
/**   
 * 5
 */


//7、max最大值
System.out.println(list.stream().max(Comparator.comparing(User::getAge)));
/*******************控制台*********************
/**   
 * Optional[User(name=张五, age=6, cole=毫无血色?白无常:小白, sex=1)]
 */     


//8、min最小值
System.out.println(list.stream().min(Comparator.comparing(User::getAge)));
/*******************控制台*********************
/**   
 * Optional[User(name=张一, age=2, cole=大红脸, sex=1)]
 */
规约
操作作用
reduce(T identity,BinaryOperator b)可以将流中元素反复结合起来得到一个值，返回的是T。
reduce(BinaryOperator b)可以将流中元素反复结合起来得到一个值，返回的是Optional。
//reduce(BinaryOperator b),0作为第一次的初始值，然后每次累加后的值作为x去加y。因为初值为0不会出现空的情况不会出现空指针所以返回的是integer
 List<Integer> list2 = Arrays.asList(1,2,3,4,5,6,7);
 System.out.println(list2.stream().reduce(0, (x, y) -> x + y));
/*******************控制台*********************
/**   
 * 28
 */
     
//reduce(T identity,BinaryOperator b)
System.out.println(list.stream().map(User::getAge).reduce(Integer::sum));
/*******************控制台*********************
/**   
 * Optional[20]
 */
 */
收集
操作作用
collect将流转化为其他形式。接收一个Collector接口的实现，用于给Steam总元素做汇总的方法。----Collectors提供了很多静态方法便于创建常用收集器。
//将结果放入到某种集合中
list.stream().map(User::getName).collect(Collectors.toList());
list.stream().map(User::getName).collect(Collectors.toSet());
list.stream().map(User::getName).collect(Collectors.toCollection(HashSet::new));
                             list.stream().collect(Collectors.counting()); //总数
        list.stream().collect(Collectors.averagingDouble(User::getAge)); //平均值
        list.stream().collect(Collectors.summarizingInt(User::getAge)); //平均值
        list.stream().collect(Collectors.maxBy((x,y)->Integer.compare(x.getAge(),y.getAge()))); //最大值
        list.stream().collect(Collectors.minBy((x,y)->Integer.compare(x.getAge(),y.getAge()))); //最大值
        list.stream().collect(Collectors.groupingBy(User::getSex));//根据性别分组
        System.out.println(JSON.toJSON(list.stream().collect(Collectors.groupingBy(User::getSex, Collectors.groupingBy(u -> {
            if (u.getAge() > 3) {
                return "小孩";
            } else {
                return "老了";
            }
        })))));  //根据性别分组后再根据年龄分组
/*******************控制台（工具格式化后）*********************
        /**
         * {
         *   "1": {
         *     "小孩": [
         *       {
         *         "sex": 1,
         *         "name": "张三",
         *         "cole": "大红脸",
         *         "age": 4
         *       },
         *       {
         *         "sex": 1,
         *         "name": "张五",
         *         "cole": "毫无血色?白无常:小白",
         *         "age": 6
         *       }
         *     ],
         *     "老了": [
         *       {
         *         "sex": 1,
         *         "name": "张一",
         *         "cole": "大红脸",
         *         "age": 2
         *       }
         *     ]
         *   },
         *   "2": {
         *     "小孩": [
         *       {
         *         "sex": 2,
         *         "name": "张四",
         *         "cole": "黝黑透亮?黑无常:包大神",
         *         "age": 5
         *       }
         *     ],
         *     "老了": [
         *       {
         *         "sex": 2,
         *         "name": "张二",
         *         "cole": "正宗黄种人",
         *         "age": 3
         *       }
         *     ]
         *   }
         * }
         */
System.out.println(list.stream().collect(Collectors.partitioningBy(user -> user.getAge() > 5)));//分组（满足在true组，不满足false组）
/*******************控制台*********************
  /**
         * {false=[User(name=张一, age=2, cole=大红脸, sex=1), User(name=张二, age=3, cole=正宗黄种人, sex=2), User(name=张三, age=4, cole=大红脸, sex=1), User(name=张四, age=5, cole=黝黑透亮?黑无常:包大神, sex=2)], true=[User(name=张五, age=6, cole=毫无血色?白无常:小白, sex=1)]}
         */ 
DoubleSummaryStatistics collect = list.stream().collect(Collectors.summarizingDouble(User::getAge));//对年龄的各种操作如下图

在这里插入图片描述

        System.out.println(list.stream().map(User::getName).collect(Collectors.joining(",","----","----")));
/*******************控制台*********************
/**
 * ----张一,张二,张三,张四,张五----
 */

System.out.println(list.stream().map(User::getName).collect(Collectors.joining("大傻,")));//连接字符串

/*******************控制台*********************
//张一大傻,张二大傻,张三大傻,张四大傻,张五

开启并行流，提高效率：xxx.stream().parallel();

qq_42946027
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
lambda-notes:Lambda 表达式学习笔记
05-14
Java 8 Lambda表达式学习笔记，摘自书籍 ，笔记内只举了实例，没有进行过多的解释与剖析，可以通过IDE进入Java 8 的相关源码进行查看理解，查看主要知识储备包括： 接口定义 Java 8 default关键字 泛型 匿名内部类 ...
解决mybatis-plus3.1.1版本使用lambda表达式查询报错的方法
09-07
主要介绍了解决mybatis-plus3.1.1版本使用lambda表达式查询报错的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
compare()Java_Java Integer compare()用法及代码示例
weixin_39926014的博客
02-12 1972
java.lang包的Integer类的compare()方法比较作为参数给出的两个整数值(x，y)，如果(x == y)则返回零，如果(x y)，则返回大于零的值。用法:public static int compare(int x, int y)参数：x: the first int to comparey: the second int to compare返回：This method r...
Integer中方法compare和compareTo的区别
热门推荐
fly_fly_fly_pig的博客
09-17 2万+
从名字上我们就可以大概才出来他们的区别,compareTo的参数是一个整数,是对象的方法.相对之下compare的参数应该就是两个,是类的方法. 再来看看源码 //compareTo public int compareTo(Integer anotherInteger) { return compare(this.value, anotherInteger...
Java：Integer中的compare与compareTo
超级马里奥 的博客
11-09 2230
Java：Integer中的compare与compareTo 首先我们先来查看一波jgk1.8： 1.compareTo compareTo(Object o)方法是java.lang.Comparable<T>接口的方法； 重写compareTo方法，进行自然排序（aka整体排序、内部排序）：Collections.sort(), Array.sort()；这些排序方法默认的是升序的 实现了这个接口的的对象，就有了排序的功能，所以叫comparable--可排序的； co..
Java Integer.compareTo()具有什么功能呢？
qq_25073223的博客
08-26 960
Java Integer.compareTo()方法的功能简介说明
Java 基础：Integer 源码分析
Herishwater的博客
09-28 256
基本数据类型 int 的包装类即为 Integer，纵观 Integer、Long、Float、Double 数值类的源码，觉得 Integer 类的内容更加丰富，包含的小知识点更多，因此决定研究一下该类的源码，顺便做一下知识总结。该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。 类定义 public final ...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 【Java8】Lambda表达式 和 Stream API 详解笔记 md文档
Java8中Lambda表达式使用和Stream API详解
08-26
主要给大家介绍了关于Java8中Lambda表达式使用和Stream API的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
lamda-demo:Java8 lambda 表达式的示例
06-20
Java 8 拉姆达 使用集合 使用字符串、比较器、过滤器（比较） 使用 lambda 表达式进行设计 递归优化（递归） 资源（资源） _* 参考源 1. Java 8 lambda 的强大功能 Java 8 示例
Integer类常见方法
yl23921的博客
09-26 3728
Integer类常见方法及简单使用
Java中Integer类型的整数值的大小比较
MissOfSpring的博客
04-29 1万+
1.规则 如果Integer类型的两个数相等，如果范围在-128~127（默认），那么用“==”返回true，其余的范会false。 两个基本类型int进行相等比较，直接用==即可。 一个基本类型int和一个包装类型Integer比较，用==也可，比较时候，Integer类型做了拆箱操作。 Integer类型比较大小，要么调用Integer.intValue()转为基本类型用“==”比较，要么直接用equals比较。 Java Integer.compareTo()比较大小 2.定义
【Java8新特性 Lambda表达式-Stream API详解】
qq_44682003的博客
11-07 227
Java8 新特性一、为什么使用Lambda表达式二、Lambda表达式基础语法 一、为什么使用Lambda表达式 Lambda是一个匿名函数，我么可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样传递）。可以写出更加简洁的、灵活的代码。作为一种更紧凑的代码风格，使java语言能力得到了提升 看不懂没关系，上代码我们先体会体会： （补充：匿名内部类） 匿名内部类去实现 Comparator接口： public class TestLambda1{ //匿名内部类 pub
Java_第18章_JDK8-17新特性（上）
qq_52922453的博客
04-17 751
发行版本发行时间备注Java 1.01996.01.23Sun公司发布了Java的第一个开发工具包Java 5.02004.09.30①版本号从1.4直接更新至5.0；②平台更名为JavaSE、JavaEE、JavaMEJava 8.02014.03.18此版本是继Java 5.0以来变化最大的版本。是长期支持版本（LTSJava 9.02017.09.22此版本开始，每半年更新一次Java 10.02018.03.21Java 11.02018.09.25。
Java常用类库学习总结
qq_51553982的博客
08-02 824
常用类库 包装类 Java中不能定义基本数据类型的对象，为了能将基本数据类型当作对象处理，包装类由此诞生！ 概念： 将基本数据类型封装在包装类中,以便把这些基本数据类型转换为对象进行处理 包装类以及所对应的基本数据类型： 包装类 对应基本数据类型 Byte byte Integer int Float float Character char Short short Long long Double double Boolean boolean 1.Inte
Lombda表达式（jdk8新特性）
m0_50860920的博客
05-17 174
lombda 语法 () -> {} 左侧 ：指定了 Lambda 表达式需要的所有参数 右侧 ：指定了 Lambda 体，即 Lambda 表达式要执行的功能。 左右遇一括号省，左侧推断类型省，能省则省 需要“函数式接口”的支持 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰 可以检查是否是函数式接口 格式 () -> System.out.println("Hello Lambda!"); 无参数，无返回值
jdk8新特性--Lambda表达式、函数式接口、Stream API
weixin_49329785的博客
09-05 2013
一、jdk8新特性简介 二、Lambda表达式 简单理解一下Lambda表达式 public class LambdaTest { @Test public void test1(){ Runnable r1 = new Runnable() { @Override public void run() { System.out.println("我爱北京天安门"); .
Java8新特性(自用笔记)
weixin_46876034的博客
07-25 587
Lambda表达式的使用
使用 Stream API 优化你的代码
Java笔记虾
09-23 1326
Java8的新特性主要是Lambda表达式和流，当流和Lambda表达式结合起来一起使用时，因为流申明式处理数据集合的特点，可以让代码变得简洁易读 放大招，流如何简化代码 如果有一个需求，需要对数据库查询到的菜肴进行一个处理： 筛选出卡路里小于400的菜肴 对筛选出的菜肴进行一个排序 获取排序后菜肴的名字 菜肴：Dish.java publicclassD...
java: -source 1.5 中不支持 lambda 表达式
最新发布
04-29
Lambda 表达式是一种 Java 8 引入的新特性，它提供了一种简洁的方式来编写匿名函数，从而简化了编写代码的工作量。然而，在使用 Java 编译器时，如果将源代码指定为“-source 1.5”时，将无法使用 Lambda 表达式。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值