前言 自从 Java 8 开始提供了一个 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));
}