Java8 Stream的简单示例

前言

自从 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));
}

发布者

常轩

常轩

总要做点什么吧!

发表评论

电子邮件地址不会被公开。 必填项已用*标注