超高效率!使用Java8的Stream对集合操作飞起来
前言
今天博主将为大家分享超高效率!使用Java8的Stream对集合操作飞起来,用时最短!不喜勿喷,如有异议欢迎讨论!
有一个强大的地基才能写出健壮的程序!
简介
java8 也出来好久了,接口默认方法,lambda 表达式,函数式接口,Date API 等特性还是有必要去了解一下。比如在项目中经常用到集合,遍历集合可以试下 lambda 表达式,经常还要对集合进行过滤和排序,Stream 就派上用场了。用习惯了,不得不说真的很好用。
Stream 作为 java8 的新特性,基于 lambda 表达式,是对集合对象功能的增强,它专注于对集合对象进行各种高效、便利的聚合操作或者大批量的数据操作,提高了编程效率和代码可读性。
Stream 的原理:将要处理的元素看做一种流,流在管道中传输,并且可以在管道的节点上处理,包括过滤筛选、去重、排序、聚合等。元素流在管道中经过中间操作的处理,最后由最终操作得到前面处理的结果。
集合有两种方式生成流:
- stream() − 为集合创建串行流
- parallelStream() - 为集合创建并行流
Stream 类
上图中是 Stream 类的类结构图,里面包含了大部分的中间和终止操作。
-
中间操作主要有以下方法(此类型方法返回的都是 Stream):map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
-
终止操作主要有以下方法:forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
来点栗子
为了说明 Stream 对对象集合的操作,新建一个 Student 类(学生类), 覆写 equals() 和 hashCode() 方法
package com.cyj.entity;
import java.util.Objects;
public class Student {
private Long id;
private String name;
private int age;
private String address;
public Student() {
}
public Student(Long id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age && Objects.equals(id, student.id) && Objects.equals(name, student.name)
&& Objects.equals(address, student.address);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age, address);
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
filter(筛选)
public static void main(String[] args) {
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
List<Student> streamStudents = testFilter(students);
streamStudents.forEach(System.out::println);
}
/**
* 集合的筛选
*
* @param students
* @return
*/
private static List<Student> testFilter(List<Student> students) {
// 筛选年龄大于15岁的学生
// return students.stream().filter(s -> s.getAge()>15).collect(Collectors.toList());
// 筛选住在洛阳省的学生
return students.stream().filter(s -> "洛阳".equals(s.getAddress())).collect(Collectors.toList());
}
结果如下:
Student [id=1, name=肖战, age=15, address=洛阳]
Student [id=4, name=李现, age=17, address=洛阳]
map(转换)
public static void main(String[] args) {
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
List<Student> streamStudents = testFilter(students);
streamStudents.forEach(System.out::println);
testMap(students);
}
结果如下:
住址:洛阳
住址:湖北
住址:北京
住址:洛阳
map 就是将对应的元素按照给定的方法进行转换。
distinct(去重)
public static void main(String[] args) {
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
List<Student> streamStudents = testFilter(students);
streamStudents.forEach(System.out::println);
testMap(students);
testDistinct1();
}
/**
* 集合去重(基本类型)
*/
private static void testDistinct1(){
//简单字符串的去重
List<String> list = Arrays.asList("666", "888", "333", "666", "888");
list.stream().distinct().forEach(System.out::println);
}
结果如下:
666
888
333
再来一个
public static void main(String[] args) {
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
List<Student> streamStudents = testFilter(students);
streamStudents.forEach(System.out::println);
testMap(students);
testDistinct1();
testDistinct2();
}
/**
* 集合去重(引用对象)
*/
private static void testDistinct2() {
// 引用对象的去重,引用对象要实现hashCode和equal方法,否则去重无效
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
Student s5 = new Student(1L, "肖战", 15, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);
students.stream().distinct().forEach(System.out::println);
}
结果如下:
Student [id=1, name=肖战, age=15, address=洛阳]
Student [id=2, name=王一博, age=15, address=湖北]
Student [id=3, name=杨紫, age=17, address=北京]
Student [id=4, name=李现, age=17, address=洛阳]
两个重复的 “肖战” 同学进行了去重,这不仅因为使用了 distinct()方法,而且因为 Student 对象重写了 equals 和 hashCode()方法,否则去重是无效的。
sorted(排序)
方法如下:
/**
* 集合排序(默认排序)
*/
private static void testSort1(){
List<String> list = Arrays.asList("666", "222", "888");
list.stream().sorted().forEach(System.out::println);
}
结果如下:
222
666
888
再来一个方法如下
private static void testSort2() {
// 引用对象的去重,引用对象要实现hashCode和equal方法,否则去重无效
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.stream()
.sorted((stu1, stu2)-> Long.compare(stu2.getId(), stu1.getId()))
.sorted((stu1, stu2)->Integer.compare(stu2.getAge(), stu1.getAge()))
.forEach(System.out::println);
}
结果如下
Student [id=4, name=李现, age=17, address=洛阳]
Student [id=3, name=杨紫, age=17, address=北京]
Student [id=2, name=王一博, age=15, address=湖北]
Student [id=1, name=肖战, age=15, address=洛阳]
上面指定排序规则,先按照学生的 id 进行降序排序,再按照年龄进行降序排序
limit(限制返回个数)
/**
* 集合limit,返回前几个元素
*/
private static void testLimit(){
List<String> list = Arrays.asList("333", "222", "111");
list.stream().limit(2).forEach(System.out::println);
}
结果如下
333
222
skip(删除元素)
/**
* 集合skip,删除前n个元素
*/
private static void testSkip() {
List<String> list = Arrays.asList("888", "777", "666");
list.stream().skip(2).forEach(System.out::println);
}
reduce(聚合)
/**
* 集合reduce,将集合中每个元素聚合成一条数据
*/
private static void testReduce(){
List<String> list = Arrays.asList("欢", "迎", "你");
String appendStr = list.stream().reduce("北京", (a, b)-> a + b);
System.out.println(appendStr);
}
min(求最小值,求所有学生中年龄最小的一个,max 同理,求最大值。)
/**
* 求集合中元素的最小值
*/
private static void testMin() {
// 引用对象的去重,引用对象要实现hashCode和equal方法,否则去重无效
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
Student minS = students.stream().min((stu1, stu2)-> Integer.compare(stu1.getAge(), stu2.getAge())).get();
System.out.println(minS.toString());
}
anyMatch/allMatch/noneMatch(匹配)
private static void testMatch() {
// 引用对象的去重,引用对象要实现hashCode和equal方法,否则去重无效
Student s1 = new Student(1L, "肖战", 15, "洛阳");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "洛阳");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
Boolean anyMatch = students.stream().anyMatch(s -> "湖北".equals(s.getAddress()));
if (anyMatch) {
System.out.println("有湖北人");
}
Boolean allMatch = students.stream().allMatch(s -> s.getAge() >= 15);
if (allMatch) {
System.out.println("所有学生都满15周岁");
}
Boolean noneMatch = students.stream().noneMatch(s -> "杨洋".equals(s.getName()));
if (noneMatch) {
System.out.println("没有叫杨洋的同学");
}
}
- anyMatch:Stream 中任意一个元素符合传入的 predicate,返回 true
- allMatch:Stream 中全部元素符合传入的 predicate,返回 true
- noneMatch:Stream 中没有一个元素符合传入的 predicate,返回 true
总结
介绍了 Stream 常用的一些方法,虽然对集合的遍历和操作可以用以前常规的方式,但是当业务逻辑复杂的时候,你会发现代码量很多,可读性很差,明明一行代码解决的事情,你却写了好几行。试试 lambda 表达式,试试 Stream,你会有不一样的体验。
最后
-
更多参考精彩博文请看这里:《陈永佳的博客》
-
喜欢博主的小伙伴可以加个关注、点个赞哦,持续更新嘿嘿!