关注我,精彩文章第一时间推送给你
公众号.jpg
简介
Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
下面通过代码了解下
创建学生类、精英学生类
/**
* 定义学生类
*/
@Data
@AllArgsConstructor
class Student {
private Integer id;
private String name;
private Integer age;
private Double score;
}
/**
* 定义精英学生类
*/
@Data
class EliteStudent {
private String name;
private Double score;
}
构建两个集合,用于Stream()流处理
@Slf4j
@SpringBootTest
class StreamTest {
private List list;
private List> listFlat;
@BeforeEach//注解在非静态方法上
void init() {
list = Arrays.asList(
new Student(1, "盖伦1", 200, 66.0),
new Student(2, "赵信", 21, 90.0),
new Student(3, "乐芙兰1", 21, 90.0),
new Student(4, "李青", 50, 100d),
new Student(5, "泰达米尔", 600, 90d)
);
listFlat = Arrays.asList(
Arrays.asList(
new Student(1, "盖伦1", 200, 66.0),
new Student(2, "赵信", 21, 90.0)
),
Arrays.asList(
new Student(3, "乐芙兰1", 21, 90.0),
new Student(4, "李青", 50, 100d)
),
Collections.singletonList(
new Student(5, "泰达米尔", 600, 90d)
)
);
}
//各种流处理方法---------filter
//----------------------map
//--------------------reduce等等
}
1.filter
/**
* filter
* @DESC 过滤出list中学生名字中包括 "1" 的学生集合,
* 并使用peek()利用其返回Stream直接以流的方式实现打印过滤出的学生
*
* peek() 和 ForEach() 的区别:
* 前者返回Stream 可在流的基础上继续流操作
* 后者返回void,想要继续流操作需要进行二次流处理
*/
@Test
void filterTest() {
final List collect = list.stream().filter(item -> item.getName().contains("1"))
.peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals(2, collect.size());
/**
* 获取过滤的第一条数据,如果包含则打印
*/
list.stream().filter(item -> item.getName().contains("1"))
.findFirst()
.ifPresent(System.out::println);
}
2.map
/**
* map
* @DESC 可以将List里面的对象转化成新的对象
* 1.将学生集合里不小于90分的作为精英学生过滤出来,并打印
* 2.获取所有学生的 name 集合,并打印
*/
@Test
void mapTest() {
final List collect = list.stream().filter(item -> item.getScore() >= 90)
.map(student -> {
EliteStudent eliteStudent = new EliteStudent();
BeanUtils.copyProperties(student, eliteStudent);
return eliteStudent;
}).peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals(3, collect.size());
final List nameList = list.stream().map(Student::getName)
.peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals(5, nameList.size());
}
3.flatMap
/**
* flatMap
* @DESC 将嵌套列表转换为普通列表,例如 List> 转化为 List
* 1.将嵌套列表转化成普通列表,断言转化结果 = list
* 2.转化后获取列表的 id 集合并打印
* 3.转化后再提取集合的分数,求平均值,打印平均值
*/
@Test
void flatMapTest() {
List collect = listFlat.stream().flatMap(Collection::stream)
.peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals(collect, list);
List idList = listFlat.stream().flatMap(Collection::stream)
.peek(System.out::println)
.flatMapToInt(student -> IntStream.of(student.getId()))
.peek(System.out::println)
.boxed()
.collect(Collectors.toList());
Assertions.assertEquals(idList.size(), 5);
listFlat.stream().flatMap(Collection::stream)
.mapToDouble(Student::getScore)
.average()
.ifPresent(System.out::println);
}
4.sorted
/**
* sorted
* @DESC 排序
* 1.先按照分数倒叙排列,如果分数相同按照年龄正序排列,如果年龄相同按照 id 正序排列,打印
* 2.如果 reversed() 写在最后,则全部按照倒叙排列
*/
@Test
void sortedTest() {
List collect = list.stream().sorted(Comparator.comparing(Student::getScore).reversed()
.thenComparing(Student::getAge)
.thenComparing(Student::getId))
.peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals("李青", collect.get(0).getName());
log.info("-------------------------------------------------------------");
List collect2 = list.stream().sorted(Comparator.comparing(Student::getScore)
.thenComparing(Student::getAge)
.thenComparing(Student::getId).reversed())
.peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals("李青", collect2.get(0).getName());
}
5.match
/**
* match
* @DESC 验证list中的每一项是否匹配我们的条件
* allMatch 全都匹配
* anyMatch 任意匹配
* noneMatch 全不匹配
*
* 设置匹配条件为正则表达式 ^[1-9]\\d*$ 正整数
* 1.验证list的id是否全都匹配条件
* 2.临时改变list的第一个年龄为 -1 验证是否年龄任意一个匹配条件
* 3.验证分数是否全不匹配条件
*/
@Test
void matchTest() {
boolean b = list.stream().allMatch(item -> ReUtil.isMatch("^[1-9]\\d*$", item.getId().toString()));
log.info("输出list的id是否全部匹配条件,结果:----------[{}]", b);
list.get(0).setAge(-1);
list.forEach(System.out::println);
boolean b1 = list.stream().anyMatch(item -> ReUtil.isMatch("^[1-9]\\d*$", item.getAge().toString()));
log.info("输出list的年龄是否任意匹配条件,结果:----------[{}]", b1);
boolean b2 = list.stream().noneMatch(item -> ReUtil.isMatch("^[1-9]\\d*$", item.getScore().toString()));
log.info("输出list的年龄是否都不匹配条件,结果:----------[{}]", b2);
}
6.reduce
/**
* reduce
* @DESC 合并流元素产生单个值
* 1.计算list中所有学生年龄的总和,存在则打印
* 2.计算list中所有学生年龄的总和,存在则打印
*/
@Test
void reduceTest() {
list.stream().map(Student::getAge)
.reduce(Integer::sum)
.ifPresent(System.out::println);
list.stream().map(Student::getScore)
.reduce(Double::sum)
.ifPresent(System.out::println);
}
7.collertor
/**
* collector
* 收集器,主要用于toList() / toSet() / toMap() / joining()连接字符串
* 1.把list中的id作为key, name作为value转化成Map
* 2.把学生名字用逗号拼接,并且第一个逗号用星号替换
*/
@Test
void collectorTest() {
Map map = list.stream().collect(Collectors.toMap(Student::getId, Student::getName));
map.forEach((k, v) -> log.info("key = {} , value = {}", k, v));
String s = list.stream().map(Student::getName)
.collect(Collectors.joining(","))
.replaceFirst(",", "*");
log.info("输出逗号拼接的字符串-->{}", s);
}
8.summarizingDouble
/**
* summarizingDouble
* 1.计算集合中某个元素的 count / sum / avg / min / max
* 2.第二种写法
*/
@Test
void summarizingDoubleTest() {
DoubleSummaryStatistics collect = list.stream()
.collect(Collectors.summarizingDouble(Student::getScore));
System.out.println(collect);
DoubleSummaryStatistics doubleSummaryStatistics = list.stream()
.mapToDouble(Student::getScore)
.summaryStatistics();
System.out.println(doubleSummaryStatistics);
}
9.partitioningBy
/**
* partitioningBy
* @DESC 用于分割列表
* 把学生列表中年龄大于100的放进key为true的Map中
* 小于等于100的放进key为false的Map中
*/
@Test
void partitioningByTest() {
Map> map = list.stream()
.collect(Collectors.partitioningBy(e -> e.getAge() > 100));
log.info("true列表 = {}", map.get(Boolean.TRUE));
log.info("false列表 = {}", map.get(Boolean.FALSE));
}
10.groupingBy
/**
* groupingBy
* @DESC 分组
* 1.根据成绩分组
* 2.获取每个分数的人数
* 3.根据成绩获取取得每个成绩的学生的总分
*/
@Test
void groupingByTest() {
Map> map1 = list.stream().collect(Collectors.groupingBy(Student::getScore));
map1.forEach((k, v) -> System.out.println(k + "\t" + v));
Map map2 = list.stream().collect(Collectors.groupingBy(Student::getScore, Collectors.counting()));
map2.forEach((k,v) -> System.out.println(k + "\t" + v));
Map map3 = list.stream()
.collect(Collectors.groupingBy(Student::getScore, Collectors.summingDouble(Student::getScore)));
map3.forEach((k, v) -> System.out.println(k + "\t" + v));
}
11.parallel
/**
* parallel
* @DESC 并发
* 延迟一秒后,并发的打印出学生的名字
*/
@Test
void parallel() {
list.stream().parallel().forEach(this::print);
}
private void print(Student student) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("学生的名字是 : {}", student.getName());
}
12.读写文件
/**
* @DESC 读写文件
* 先把list中的数据写到student.txt中
* 再读取出来
*/
@Test
void fileTest() throws IOException {
PrintWriter printWriter = new PrintWriter(Files.newBufferedWriter(Paths.get("D://student.txt")));
//list列表写出到文件student.txt中
list.forEach(printWriter::println);
printWriter.close();
//读取文件
List collect = Files.lines(Paths.get("D://student.txt"))
.peek(System.out::println)
.collect(Collectors.toList());
Assertions.assertEquals(5, collect.size());
}