Java Stream的简单示例

Posted 壹言

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java Stream的简单示例相关的知识,希望对你有一定的参考价值。

原文链接:https://www.changxuan.top/?p=1130

前言

自从 Java 8 开始提供了一个Stream 接口。因为是个新东西大多数同学可能都有些抵触心理,往往在代码中并不会用到它。这样就会导致有些地方的代码本该更加简洁,而实际情况确实写的十分臃肿。

虽然我很赞成“写大家看得懂的代码。”这句话,但是又特别喜欢 stream 这种方式。大家在项目中多多使用自然也就会十分熟练了。

示例

前置代码

class Student 
    private String name;
    private Integer age;
    public Student(String name, Integer age)
        this.name = name;
        this.age = age;
    

    public String getName() 
        return name;
    

    public void setName(String name) 
        this.name = name;
    

    public Integer getAge() 
        return age;
    

    public void setAge(Integer age) 
        this.age = age;
    

    @Override
    public String toString() 
        return "Student" +
                "name='" + name + '\\'' +
                ", age=" + age +
                '';
    

基本过滤(filter)

/**
  * 基本过滤
  * @param students 学生集合
  */
  
public static void basicFilter(List<Student> students) 
    /* 基本过滤:筛选出年龄大于 15 的学生 */
    List<Student> above15List = students.stream()
        .filter(s -> s.getAge()>15)
        .collect(Collectors.toList());
    for (Student student : above15List) 
        System.out.println(student.toString());
    

基本转换(map)

/**
  * 基本转换
  * @param students 学生集合
  */
  
public static void basicConvert(List<Student> students) 
    /* 获取集合内每个学生的名字构建一个新的 String 集合 */
    List<String> nameList= students.stream()
        .map(Student::getName)
        .collect(Collectors.toList());
    for (String name : nameList) 
        System.out.println(name);
    

去重(distinct)

/**
  * 去重
  * 使用 equal 方法进行判断是否重复
  * @param students 学生集合
  */
  
public static void distinct(List<Student> students) 
    System.out.println("distinct");
    System.out.println("before");
    for (Student student : students) System.out.println(student.toString());
    List<Student> noRepeatList = students.stream()
        .distinct()
        .collect(Collectors.toList());
    System.out.println("after");
    for (Student student : noRepeatList) 
        System.out.println(student.toString());

排序(sorted)

 /**
   * 排序
   * @description comparing 默认为升序排列, reversed 则为降序排列
   * @param students 学生集合
   */
   
public static void sort(List<Student> students) 
    /* 首先根据学生年龄排序,年龄相同的情况下使用姓名排序 */
    System.out.println("排序(sorted)");
    List<Student> sortedList = students.stream()
        .sorted(Comparator.comparing(Student::getAge)
                .reversed().thenComparing(Student::getName))
        .collect(Collectors.toList());
    for (Student student : sortedList) 
        System.out.println(student.toString());
    

区间(skip&limit)

/**
  * skip and limit
  * skip : 跳过 n 个元素,从 1 开始计数。
  * limit : 此次取的元素数量。
  * ex. skip(1).limit(2) 跳过第一个,取出第二、第三个元素。
  * @param students 学生集合
  */
  
public static void skipAndLimit(List<Student> students) 
    System.out.println("Skip And Limit");
    List<Student> partOfStudent = students.stream()
        .sorted(Comparator.comparing(Student::getAge)
                .reversed())
        .skip(1)
        .limit(2)
        .collect(Collectors.toList());
    for (Student student : partOfStudent) 
        System.out.println(student.toString());

计算总和(sum)

/**
  * 计算总和
  * 其它: mapToDouble、mapToInt
  * @param students 学生集合
  */
  
public static void mapToLong(List<Student> students) 
    /* 计算集合中所有学生年龄的总和 */
    System.out.println("mapToLong");
    Long ageSum = students.stream()
        .mapToLong(Student::getAge)
        .sum();
    System.out.println(ageSum);

flatMap

/**
  * flatMap
  * 接收一个函数 Mapper, 对流中的每一个元素,mapper 会将该元素转换为一个流 Stream ,然后把新生成流
  * 的每一个元素传递个下一个操作
  * @param students 学生集合
  */
  
public static void flatMap(List<Student> students) 
    System.out.println("flatMap");
    List<String> lines = Arrays.asList(new String[]"abc DEF", "hhhh", "fire");
    List<String> words = lines.stream()
        .flatMap(line -> Arrays.stream(line.split(" ")))
        .collect(Collectors.toList());
    System.out.println(words);

最大最小(min&max)

/**
  * min and max
  * min and max method will return a Optional<T> Object that include some methods such as get,isPresent and so on.
  * @param students student Collection
  */
  
public static void minAndMax(List<Student> students) 
    /* 获取年龄最大和最小年龄的学生 */
    System.out.println("min and max");
    Student min = students.stream()
        .min(Comparator.comparing(Student::getAge))
        .get();
    System.out.println("min:"+min.toString());
    Student max = students.stream()
        .max(Comparator.comparing(Student::getAge))
        .get();
    System.out.println("max"+max.toString());

数量(count)

/**
  * 符合条件的元素数量 count
  * @param students student collection
  */
  
public static void count(List<Student> students) 
    System.out.println("count");
    long above15Students = students.stream()
        .filter(student -> student.getAge() > 15)
        .count();
    System.out.println("年龄大于15的学生数量:"+above15Students);

匹配(allMatch&anyMatch&noneMatch)

/**
  * 判断流中的元素是否满足某一条件
  * allMatch: 当流中的所有元素都满足条件时才返回 true
  * anyMatch: 只要流中有一个元素满足条件就返回 true
  * noneMatch: 只有流中的所有元素都不满足条件才返回 true
  * 如果流为空,那么都将返回 true
  * @param students 学生集合
  */
  
public static void match(List<Student> students) 
    System.out.println("match");
    /* 判断是否所有的学生年龄都大于 8 岁, 预期输出为 true */
    boolean allMatch = students.stream()
        .allMatch(student -> student.getAge() > 8);
    System.out.println(allMatch);
    /* 判断是否有学生年龄大于 15 岁,预期输出为 true */  
    boolean anyMatch = students.stream()
        .anyMatch(student -> student.getAge() > 15);
    System.out.println(anyMatch);
    /* 判断是否有学生年龄大于 30 岁,预期输出为 true*/
    boolean noneMatch = students.stream()
        .noneMatch(student -> student.getAge() > 30);
    System.out.println(noneMatch);

获取元素(findFirst&findAny)

/**
  * find first and find any
  * 获取第一个元素,获取任意一元素
  * @param students 学生集合
  */
  
public static void findFirstAndAny(List<Student> students) 
    System.out.println("findFirst and findAny");
    Student firstStudent = students.stream()
        .findFirst()
        .get();
    System.out.println(firstStudent.toString());
    Student anyStudent = students.stream()
        .filter(student -> student.getAge() < 15)
        .findAny()
        .get();
    System.out.println(anyStudent.toString());

遍历(forEach&forEachOrdered)

/**
  * 遍历
  * forEach 不保证处理的顺序
  * forEachOrdered 保证按照流中元素的出现顺序进行处理
  * 它们接受一个 Consumer 对象,对流中的每一个元素都传递给 Consumer
  * @param students 学生集合
  */
  
public static void forEach(List<Student> students) 
    System.out.println("ForEach");
    students.stream()
        .forEach(student -> System.out.println(student.toString()));
    students.stream()
        .forEach(student -> 
            System.out.println(student.getName());;
            System.out.println(student.toString());
        );
    students.stream()
        .forEach(System.out::println);

转换数组(toArray)

/**
  * 将流转换数组
  * @param students 学生集合
  */
  
public static void toArray(List<Student> students) 
    System.out.println("toArray");
    Student[] above15Students = students.stream()
        .filter(student -> student.getAge() > 15)
        .toArray(Student[]::new);
    System.out.println(Arrays.toString(above15Students));

以上是关于Java Stream的简单示例的主要内容,如果未能解决你的问题,请参考以下文章

Java Stream按条件减少多个列表

Java8利用stream流快速排序(包括中文)

Java8 List统计(最大值,最小值平均值总和)

给定硬币的所有可能总和

java8 stream sorted

Java8 Stream 实现排序和分页