函数式编程&Stream流-java8新特性（二）

已于 2023-10-29 21:56:49 修改
阅读量507 收藏
点赞数 20
文章标签： spring java intellij idea 开发语言
于 2023-10-26 23:42:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53676834/article/details/134053261
版权

一、Stream流的介绍

1、介绍：

        Stream流是在jdk8当中提供的一个新特性，它可以去操作数组或者集合，并且是把里面的数据像流一样的形式来进行操作。

   如果流的一系列的操作要成功触发并生效，那必须需要有终结操作，一个流只能做一次终结操作，如果没有终结操作，中间操作根本不会被执行，所有的中间操作返回的都是一个Stream对象，所以可以一直链式编程。

二、Stream流的创建方式

                对于java来说，集合分为两大类：

    一个是单列集合，它的父接口是Connection, 另外一个是双列集合，它的父接口是map。

1、单列集合： 
  • 集合对象.stream() 

List<Author> authors = getAuthors();
Stream<Author> stream = authors.stream();

List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream();

  • 数组： Arrays.stream(数组)  或者使用  Stream.of(数组) 来创建

Integer[] arr = {1,2,3,4,5} ;

Stream<Integer> stream1 = Arrays.stream(arr);

Stream<Integer> stream2 = Stream.of(arr);

2、双列集合：

       转换成单列集合后再创建 

  •  ps： 关于Map的四种遍历方式、entrySet()、Stream流中的Map举例可以看我这篇文章：

                                              http://t.csdnimg.cn/Lvo0A

@Test
    public void Test08(){
        Map<String, Integer> map = new HashMap<>();

        map.put("蜡笔小新",5);

        map.put("小黑子",22);

        map.put("日向翔阳",16);

        Set<Map.Entry<String,Integer>> entries = map.entrySet();

        Stream<Map.Entry<String,Integer>> stream1 = entries.stream();

        Stream<Map.Entry<String,Integer>> stream2 = map.entrySet().stream();
    }

        我们创建完流后，还要经过一系列中间操作，最后还要加上终结操作，这样的话这个流才能真正的使用起来。

        

三、Stream流"中间操作"常用的API

   如果流的一系列的操作要成功触发并生效，那必须需要有终结操作，一个流只能做一次终结操作，如果没有终结操作，中间操作根本不会被执行，所有的中间操作返回的都是一个Stream对象，所以可以一直链式编程

Stream 有很多的 API 供我们使用，如下：

根据操作分类：

0、案例准备：

        实体类Author：


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode  // 去重
public class Author {
    private Long id;
    private String name;
    private Integer age;
    private String intro;
    private List<Book> books;
}

         实体类Book


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
public class Book {
    private Long id;
    private String name;
    private String category;
    private Integer score;
    private String intro;
}



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

public class StreamDemo {

    private static List<Author> getAuthors() {
      Author author = new Author(1L, "蒙多", 17, "一个祖安人", null);
        Author author2 = new Author(2L, "亚拉索", 18, "艾欧尼亚", null);
        Author author3 = new Author(3L, "易大师", 19, "黑色玫瑰", null);
        Author author4 = new Author(3L, "易大师", 19, "黑色玫瑰", null);

        List<Book> book1 = new ArrayList<>();
        List<Book> book2 = new ArrayList<>();
        List<Book> book3 = new ArrayList<>();
        List<Book> book4 = new ArrayList<>();

        book1.add(new Book(1L,"刀的两侧是光明与黑暗","哲学,爱情", 84, "*"));
        book1.add(new Book(2L,"一个人不能死在同一把刀下","爱情,个人成长", 80, "**"));

        book2.add(new Book(3L,"那风吹不到的地方","爱情,传记", 75, "***"));
        book2.add(new Book(3L,"那风吹不到的地方","爱情,传记", 75, "****"));
        book2.add(new Book(4L,"吹或不吹","哲学", 76, "*****"));

        book3.add(new Book(5L,"你的剑就是我的剑","个人成长", 78, "******"));
        book3.add(new Book(6L,"风与剑","传记", 82, "*******"));
        book3.add(new Book(6L,"风与剑","传记", 82, "********"));

        book4.add(new Book(5L,"你的剑就是我的剑","个人成长", 78, "******"));
        book4.add(new Book(6L,"风与剑","传记", 82, "*******"));
        book4.add(new Book(6L,"风与剑","传记", 82, "*******"));



        author.setBooks(book1);
        author2.setBooks(book2);
        author3.setBooks(book3);
        author4.setBooks(book4);

        List<Author> authors = new ArrayList<>(Arrays.asList(author,author2,author3,author4));
        return authors;
    }
}

常用的中间操作API如下：


1、filter：

                对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中

                         

        

  •  案例：需要打印所有年龄小于18的作家的名字，并且注意去重：
  private static void test01() {
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .filter(new Predicate<Author>() {
                    @Override
                    public boolean test(Author author) {
                        return author.getAge()< 18;
                    }
                })
                .forEach(new Consumer<Author>(){
                    public void accept(Author author){
                        System.out.println(author.getName());
                    }
                });
    }
  • Lambda表达式优化匿名内部类：
  private static void test01() {
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .filter(author -> author.getAge()<18)
                .forEach(author -> System.out.println(author.getName()));
    }
2、distinct:

       可以去除流中的重复元素，distinct方法是依赖Object的equals方法来判断是否是相同对象的，所以需要注意重写equals方法，即加注解 @EqualsAndHashCode

  • 案例：对作家进行去重：

List<Author> authors = getAuthors();

authors.stream().distinct()
3、map:

        对Stream流中的元素进行计算或者对Stream流中的元素进行数据类型的转换

                

  • 3.1、案例一：打印所有作家的姓名

        map方法，它的参数是function ，它有两个泛型，第一个泛型Author就是流元素的类型，第一个泛型不能修改，改了报错，第一个泛型必须和流当中的泛型是一样的。

        但是第二个是非常重要的，它代表了你期望通过map把Author转换成什么类型，如果说你还是转换成Author，那你就写Author：

        但是我期望是把它转换成一个字符串。我希望到时候流当中的每个元素都是一个字符串儿，就是这个作家的姓名，就写String

        经过这一步map操作之后，其实流里面都是一个一个的字符串了：

  •  Lambda表达式优化匿名内部类：

  • 3.2、也可以对流中的元素进行计算，案例二：
 private static void test02() {
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getAge())
                .map(age -> age + 10)
                .distinct()
                .forEach(age -> System.out.println(age));
    }
4、sorted：

        可以对流中的元素进行排序 

  • 我们在调用sorted时会发现它有两种传参形式：

  • 4.1、空参的sorted()方法

案例：对流中的元素按照年龄进行降序排序 

    如果调用空参的sorted()方法，需要流中的元素实现了Comparable接口，否则会抛出

                        java.lang.ClassCastException  类型转换异常：

        实际上这里在进行排序的时候，他会把流当中的Author类型的元素，转换成Comparable接口类型，再去进行相应方法的调用。

        但是现在的Author 和 Comparable接口是没有关系的，它并没有实现Comparable这个接口，所以肯定会出现类型转换异常：

        如果一个类想让它具有比较的能力，你可以选择去实现这个Comparable接口，在compareTo()方法当中去定义如何去比较两个元素/两个对象:

        我们这里要求是按照年龄进行排序，所以我们就可以拿this当前作家和你所传入进来的Author o对象去进行一个年龄的比较，去进行一个相减的操作，比较的结果是int类型,其实只要去返回他们的比较结果就可以了:

                                以this为准，this在左是升序，this在右是降序

                                o1-o2是升序，o2-o1是降序，o1是当前项

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode  // 去重
public class Author implements Comparable<Author>{
    private Long id;
    private String name;
    private Integer age;
    private String intro;
    private List<Book> books;

    @Override
    public int compareTo(Author o) {
        return  o.getAge()- this.getAge();
    }
}

 结果输出：

  • 4.2、传入对 Comparator 接口的实现：

案例：对流中的元素按照年龄进行降序排序 

                                 以this为准，this在左是升序，this在右是降序

                                 o1-o2是升序，o2-o1是降序，o1是当前项

    private static void test02(){
        List<Author> authors = getAuthors();
        authors.stream()
                .sorted(new Comparator<Author>(){
                    public int compare(Author o1 , Author o2){
                        return o2.getAge()-o1.getAge();
                    }
                })
                .forEach(author -> System.out.println(author.getAge()));
    }
  •  Lambda表达式优化匿名内部类：
    private static void test02(){
        List<Author> authors = getAuthors();
        authors.stream()
                .sorted((o1,o2) -> o2.getAge()-o1.getAge())
                .forEach(author -> System.out.println(author.getAge()));
    }
5、flatMap：

        map只能把一个对象转换成另一个对象来作为流中的元素，而flatMap可以把一个对象转换成多个对象作为流中的元素

它的参数是传进来Author作家，也就是说每个元素都是作家类型的，然后你要注意它返回的类型：要求我们返回的是Stream流对象：

                                                         

5.1、案例一：

 要求打印所有书籍的名字， 书籍当中如果有重复的话，我们要进行去重

  • 很多同学没有学过flatMap，很有可能做的一件事情是这样的：
private static void tesst04(){
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getBooks())
                .forEach(new Consumer<List<Book>>() {
                    @Override
                    public void accept(List<Book> books) {
      // 这样写的话，流当中的每一个元素都是List<Book>,不是Book
      // 整体是 List<List<Book>>
      // 我们还要在这里面再进行forEach遍历
                    }
                });
    }
  •    这种方式其实就不太符合我们的期望了，我们其实就是想把List<List<Book>>集合里面的每个List<Book>元素都转换成一个Book对象：即让流中的每一个元素都变成Book对象；

  •      所以应该使用到flatMap：首先我们先调用author.getBooks()方法， 拿到的是一个List<Book>集合，然后把这个集合转换成对应的Stream流对象 ， 并且现在流当中的元素类型就是我们的Book类型，他会自动把这些流进行一个拼接。

           相对于是把List<List<Book>>集合当中的每一个元素转化为多个元素返回：

  •   Lambda表达式优化匿名内部类：
  private static void tesst04(){
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .forEach(book -> System.out.println(book.getName()));
    }
 5.2、案例二：

打印现有书籍的所有分类。要求对分类进行去重、不能出现这种格式：哲学,爱情：

        如果说这本书是属于多个分类”哲学、爱情“，那我们应该在多个分类之间用逗号进行分割，把它转换成两个分类：一个是哲学，一个是爱情，相当于就是进行一个字符串的分割：

                        

        调用String.split()方法，将一个字符串分割为子字符串，然后将结果作为字符串数组返回：返回的是一个字符型数组，如果说他只有一种分类的这种情况，它其实也会转换成一个字符串数组，只不过数组里只有一个元素。

        flatMap() 方法 它要求返回的是Stream流对象，所以你要把这个数组转换成流对象，数组怎么转换成流对象，前面讲过：

        

                .flatMap(book -> Stream.of(book.getCategory().split(",")))

                .flatMap(book-> Arrays.stream(book.getCategory().split(",")))

  //打印现有书籍的所有分类。要求对分类进行去重
    //1、先获得所有的书籍 Stream<Book>
    //2、再获得所有的书籍的分类
    private static void test05(){
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct() //这里的去重是对流当中的书籍去重
                .flatMap(book -> Arrays.stream(book.getCategory().split(",")))
                .distinct()//这里的去重是对流当中的类别去重
                .forEach(name -> System.out.println(name));
    }
 6、limit：

        可以设置流的最大长度，超出的部分将被抛弃掉，相当于进行了一个截取

  •  案例：对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素,然后打印其中年龄最大的两个作家的姓名：

        可以先进行排序再去重，也可以先去重再排序，实际上先去重效果会更好一点，因为你去重之后，它参与排序的元素就不用那么多了：

    private static void test06(){
        //对流中的元素按照年龄进行降序排序，
        // 并且要求不能有重复的元素,然后打印其中年龄最大的两个作家的姓名
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted((o1,o2)->o2.getAge()-o1.getAge())
                .limit(2)
                .forEach(author -> System.out.println(author.getName()));
    }
 7、sikp：

        跳过流中的前n个元素，返回剩下的元素

  • 案例：打印除了年龄最大的作家以外的其他作家，要求不能有重复元素，并且按照年龄降序排列：
 private static void test07(){
        //打印除了年龄最大的作家以外的其他作家，
        // 要求不能有重复元素，并且按照年龄降序排列
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted(new Comparator<Author>() {
                    @Override
                    public int compare(Author o1, Author o2) {
                        return o2.getAge()-o1.getAge();
                    }
                })
                .skip(1)
                .forEach(author -> System.out.println(author.getName()));
    }

四、Stream流"终结操作"常用的API

        如果流的一系列的操作要成功触发并生效，那必须需要有终结操作，一个流只能做一次终结操作，如果没有终结操作，中间操作根本不会被执行，所有的中间操作返回的都是一个Stream对象，所以可以一直链式编程

1、forEach：

        对流中的元素进行遍历操作，我们通过传入的参数去指定对遍历到的元素进行什么具体的操作

                 

  •  案例：输出所有作家的名字
//        输出所有作家的名字
        List<Author> authors = getAuthors();
        authors.stream()
                .map(author -> author.getName())
                .distinct()
                .forEach(name-> System.out.println(name));
 2、count：

        可以用来获取当前流中的元素

  •  案例：打印这些作家的所出书籍的数目，注意删除重复元素，不同的作家没有同名字的书籍
    private static void test08(){
        //打印这些作家的所出书籍的数目，注意删除重复元素
        List<Author> authors = getAuthors();
        Long counts = authors.stream()
                .distinct()
                .flatMap(author -> author.getBooks().stream())
                .count();
        System.out.println(counts);
    }
3、max、min

        可以用来获取流中的最值

  •  案例： 分别获取这些作家的所出书籍的最高分和最低分并打印。

最高分：

    private static void test09(){
        List<Author> authors = getAuthors();
        //分别获取这些作家的所出书籍的最高分和最低分并打印。
        Book book = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .max(new Comparator<Book>() {
                    @Override
                    public int compare(Book o1, Book o2) {
                        return o1.getScore() - o2.getScore();
                    }
                })
                .get();
        System.out.println(book.getScore());
    }
  private static void test10(){
        List<Author> authors = getAuthors();
        Integer max_score = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .distinct()
                .map(book -> book.getScore())
                .max((o1,o2) -> o1-o2)
                .get();
        System.out.println(max_score);
    }

最低分： 

4、collect 

        把当前流转换成一个集合

         我们使用Stream流对数据进行了一系列的处理之后， 我最终的这些数据可能还要返回给别人去使用，例如返回成集合的一个形式，那这个时候就需要把流再转换成集合。

        我们知道集合其实主要有两种，一种是单列集合，单列集合其实主要就两种：List和Set；另一种双列集合里面，就是map集合。

        接下去我们就来看一下如何使用collect方法，把Stream流转分别转换成这三种集合：

          这里要注意collect方法，这个参数会比较复杂一点。实际上我们在用它的时候，是不需要直接写匿名内部类的，因为这个参数是非常复杂的，我们用的是它的工具类，它提供好的一个工具类Collectors，专门供我们这个collect方法去使用的：

         Collectors工具类，它里面提供了一些静态方法，因为工具里面基本上都是静态的成员，所以我们直接类名点就可以了：

4.1 转化成list集合——toList()方法：
  • 案例：获取一个存放所有作者名字的集合
 private static void test12(){
        //获取一个存放所有作者名字的集合
        List<Author> authors = getAuthors();
        List<String> names = authors.stream()
                .map(author -> author.getName())
                .distinct()
                .collect(Collectors.toList());
        System.out.println(names);//[蒙多, 亚拉索, 易大师]
    }
4.2 转化成set集合——toSet()方法：

           toSet()方法和toList()方法相比较而言，toSet()方法可以自动去重，

                因为Set集合本身是无序不可重复嘛

 private static void test12(){
        //获取一个存放所有作者名字的集合
        List<Author> authors = getAuthors();
        Set<String> names = authors.stream()
                .map(author -> author.getName())
                .collect(Collectors.toSet());
        System.out.println(names);//[亚拉索, 蒙多, 易大师]
    }
4.3 转化成Map集合——toMap()方法：
  • 案例：获取一个Map集合，map的key为作者名，value为List<Book>

转化成Map集合相对来说比较复杂一点，

我们要把流当中的元素转换成一个map，map是有key和value的，那你得告诉流当中的元素怎么转换成key，怎么转换成value，所以它要求你传入两个参数都是Function类型，实际上这个接口是可以进行转换的，我们前面的map方法，它的参数其实都是这个function接口类型的。

所以我们要传入两个Function，一个是告诉他怎么转换成key，另外一个是告诉他怎么转换成value：  你要去指定一下从哪个类型转换成哪个类型。

明日春风
关注
  • 20
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java8stream源码-java8:Java8——函数式编程
06-04
java8流源码java8 Java 8 —— 函数式编程 介绍 该存储库包含例如 Java 8 In Action 和 Java 8 Lambdas Pragmatic Functional Programming 一书中的源代码。 同时自己也做了一些扩展使用，修复了源码中的bug。 例如 Java 8 In Action 中的源代码可以在目录中找到： 第 1 章 Java 8：你为什么要关心？ 第 2 章 使用行为参数化传递代码 第 3 章 Lambda 表达式 第 4 章 介绍流 第 5 章 使用流 第 6 章使用流收集数据 第 7 章并行数据处理和性能 第 8 章重构、测试和调试 第 9 章默认方法 第 10 章使用 Optional 作为 null 的更好替代 第 11 章 CompletableFuture:composableasynchro 第 12 章新的日期和时间 API 第 13 章功能性思考 第 14 章函数式编程技术 第 15 章混合 OOP 和 FP：比较 Java 8 和 Scala 第 16 章结论和 Java 的下一步 例如在 Java 8 Lambd
Java-Java函数式编程教程
11-14
在Java 8及更高版本中，函数式编程得到了官方的大力支持，引入了Lambda表达式、Stream API和Optional类等新特性，使得Java开发者可以更高效、简洁地编写代码。 1. **Lambda表达式**： Lambda表达式是Java函数式...
Java8 函数式编程stream流
2301_78834737的博客
07-28 120
Java 8 中新增的特性旨在帮助程序员写出更好的代码，其中对核心类库的改进是很关键的一部分，也是本章的主要内容。对核心类库的改进主要包括集合类的 API 和新引入的流（Stream），流使程序员得以站在更高的抽象层次上对集合进行操作。下面将介绍stream流的用法。
java8 Stream 所有函数demo
zhouzhenyong的专栏
06-13 632
所有函数： allMatch 和 anyMatch /** * allMatch 和 anyMatch * 这个并不是过滤数据用的，而只是获取一个判断结果 * * 注意：这个函数一个Stream只能调用一次，调用一次后，这个Stream就调用close，也就是流就会关闭了， * 如果还要使用，那么需要再开辟一个 */ @Test public void allMatchAndAnyMatchTest(){ List<Integer> integerList = Array.
Java8 Stream 使用详解
qq_39939541的博客
07-12 1627
Java 8引入了Stream流的概念，它是对集合对象（Collection）进行操作的高级抽象。Stream流的操作分为两种：中间操作和终端操作。中间操作是指在流上进行的操作，返回的仍然是一个流，可以进行链式操作，而终端操作是指对流的最终操作，返回的是一个结果或者一个副作用。Stream流的特点如下：Stream流是对集合对象的一种封装，使得可以用函数式编程的方式对集合进行操作。Stream流的操作是延迟执行的，只有在终端操作时才会触发执行。
Stream 流 集合操作（创建方法，中间方法，终结方法，静态方法）
rushrush1的博客
05-29 1049
一、创建方法： Collection：直接调用stream(); Map:先转为Collection，再调用stream(); 数组：Arrays.stream(); 单独对象:Stream.of(); //双列集合流 Map<String,Integer> map = new HashMap<>(); Stream<Map.Entry<String, Integer>> stream1 = map.entrySet().str
java8新特性包含 lambda 函数式接口,stream 流
02-02
其中，lambda 函数式接口和 Stream API 是两大核心特性，它们为 Java 带来了函数式编程的元素，使得代码更加简洁、易读。 ### Lambda 函数式接口 Lambda 表达式是 Java 8 的一大亮点，它是一种匿名函数，可以被...
day14-函数式接口&Stream流1
08-04
- Java 8引入的Stream API允许我们对集合进行操作，如过滤、映射、排序等，支持函数式编程风格。 - 在`ComparatorDemo`的示例中，`Collections.sort`方法的第二个参数可以接收一个`Comparator`，这允许我们使用...
Java 8新特性之Lambda与函数式编程.pdf
07-02
通过这些新特性的引入，Java 8不仅提高了开发效率和程序的表达能力，还为并行和函数式编程提供了支持，使得Java编程更加现代化和强大。无论是在金融、医疗还是企业级应用开发中，Java 8的新特性都为开发者提供了更多...
创建list（asList和Stream.of）、合并list
dl674756321的博客
05-11 1994
1、asList的方式来创建list List<Integer> integers = asList(1, 2, 3); asList 返回的是一个由指定数组生成的固定大小的 List，所以它不支持插入和删除，也就是不支持动态扩容。 原因：它在创建list时，里面有一个也叫做ArrayList的内部类，这个内部类中有一个被声明为final的数组，所有传入的的元素都会保留到这个final数组中，所以其实它内部的这个ArrayList并不是java.util.ArrayList，而是java.ut
Stream流创建及使用
最新发布
m0_58059559的博客
04-28 337
Stream流的使用
Java8中Stream详细用法大全
热门推荐
qq_45228323的博客
02-16 6万+
一、概述 Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda ，给我们操作集合（Collection）提供了极大的便利。Stream流是JDK8新增的成员，允许以声明性方式处理数据集合，可以把Stream流看作是遍历数据集合的一个高级迭代器。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找/筛选/过滤、排序、聚合和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的
【Java 8系列】Stream详解，看这一篇就够啦
Yangy的博客
12-23 5万+
热门系列： 【Java 8系列】Java开发者的判空利器 -- Optional 【Java 8系列】Lambda 表达式，一看就废 程序人生，精彩抢先看 1.前言 2.正文 3.总结 ...
Stream集合流操作
m0_58823014的博客
08-03 701
JAVA8新特性 —Stream集合流操作
Stream流使用，收集成一个List或者Set集合，可以代替for循环使用
有时间可以指导毕业设计，可以私聊我。一个热爱编程的smallCuteMonkey，可以私信我
04-23 7848
文章目录1.Stream流是什么？2. stream流的创建方式？2.1通过集合直接创建2.2通过数组直接创建2.3通过Stream.of创建3. Stream对数据进行操作3.1 （filter,skip,limit,distinct）筛选和切片(方法直接可以通过链式编程写出)3.2 map映射3.3 进行排序3.4 （allmatch,noneMatch,findAny,filter）匹配查找3.5 （reduce）归约3.6 （collect） 收集,可以为Set(无序，去除重复),List（有序，有
Java8 stream流 生成新的集合，那么新集合里面的值是否为原值呢？
Wang8309166的博客
05-06 8957
Java8 stream流
Java8新特性之Stream流与集合
Kevin.wang
07-14 866
流与集合 我们先来打个直观的比方吧。比如说存在DVD里的电影，这就是一个集合(也许是字节，也 许是帧，这个无所谓)，因为它包含了整个数据结构。现在再来想想在互联网上通过视频流看同 样的电影。现在这是一个流(字节流或帧流)。流媒体视频播放器只要提前下载用户观看位置的 那几帧就可以了，这样不用等到流中大部分值计算出来，你就可以显示流的开始部分了(想想观 看直播足球赛)。特别要注意，视频播放器可能没有将...
Stream流创建的四种方式：集合创建、数组创建、方法创建Stream.of、创建无限流
小布のJava世界
05-31 1787
Stream创建的四种操作 package com.xiaobu.lambda.java3; import com.xiaobu.lambda.java2.Employee; import com.xiaobu.lambda.java2.EmployeeData; import org.junit.Test; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.ut
Java Stream流的创建
nrsc
12-10 995
1.大致分类 &amp;amp;nbsp;&amp;amp;nbsp; 本文将主要从如下五个方面来讲Stream流的创建 2.直接上代码 &amp;amp;nbsp;&amp;amp;nbsp;为了大家的方便,也是为了自己以后看起来方便,我对上面五种创建Stream流的方式都手写了一下,下面是具体的代码 package com.nrsc.stream; import java.util.Arrays; import java.util.List; impo...
java 集合stream流 详解
u012758488的博客
08-10 2810
Stream distinct() 返回由该流的去重（根据Object.equals(Object) ）之后的不同元素组成的流。static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流。使用默认方法stream()生成流， default Stream stream()中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作。对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值