本篇文章为你整理了复习Stream流，函数式接口，方法引用（）的详细内容，包含有 复习Stream流，函数式接口，方法引用，希望能帮助你了解 复习Stream流，函数式接口，方法引用。
今天对这些内容进行了一个复习，以写demo加做笔记的形式
stream能够更加优雅的处理集合、数组等数据，让我们写出更加直观、可读性更高的数据处理代码
创建steam流的方式
set、list能够直接通过.stream()的形式创建steam流
而数组需要通过 Arrays.stream(arr); Stream.of(arr);
map需要通过entrySet()方法，先将map转换成Set Map.Entry String, Integer set对象，再通过set.stream()的方式转换
stream中的api比较多
/**
* @author Pzi
* @create 2022-12-30 13:22
@SpringBootTest
@RunWith(SpringRunner.class)
public class Test2 {
@Test
public void test1() {
List Author authors = S.getAuthors();
authors
.stream()
.distinct()
.filter(author - {
// 满足这个条件，那么才会被筛选到继续留在stream中
return author.getAge()
.forEach(author - System.out.println(author.getAge()));
//entrySet是一个包含多个Entry的Set数据结构,Entry是key-val型的数据结构
Set Map.Entry String, Integer entries = map.entrySet();
entries.stream()
.filter(entry - {
return entry.getValue()
.forEach(entry - {
System.out.println(entry);
.skip(1)
.forEach(author - System.out.println(author.getName() + " " + author.getAge()));
// flapMap的使用，重新组装，改变stream流中存放的对象
@Test
public void test5() {
// 打印所有书籍的名字。要求对重复的元素进行去重。
List Author authors = S.getAuthors();
authors.stream()
.flatMap(author - author.getBooks().stream())
.distinct()
.forEach(book - System.out.println(book.getName()));
authors.stream()
// 将以authors为对象的stream流 组装成 以book为对象的strem流
.flatMap(author - author.getBooks().stream())
.distinct()
// 将每个book中的category转换成数组，然后将[x1,x2]代表分类的数组转换成stream流，然后使用flapMap将该数组stream流组装成以x1,x2...为对象的stream流
// 将以book为对象的strem流 组装成 以category为对象的stream流
.flatMap(book - Arrays.stream(book.getCategory().split(",")))
.distinct()
.forEach(category - System.out.println(category));
// 数组转换成stream流
@Test
public void test6() {
Integer[] arr = {1, 2, 3, 4, 5};
Stream Integer stream = Arrays.stream(arr);
stream
.filter(integer - integer 3)
.forEach(integer - System.out.println(integer));
@Test
public void test7() {
// 打印这些作家的所出书籍的数目，注意删除重复元素。
List Author authors = S.getAuthors();
long count = authors
.stream()
.flatMap(author - author.getBooks().stream())
.distinct()
.count();
System.out.println(count);
// max() min()
@Test
public void test8() {
// 分别获取这些作家的所出书籍的最高分和最低分并打印。
List Author authors = S.getAuthors();
Optional Integer max = authors.stream()
.flatMap(author - author.getBooks().stream())
.map(book - book.getScore())
.max((score1, score2) - score1 - score2);
// 获取一个Map集合，map的key为作者名，value为List Book
Map String, List Book collect2 = authors.stream()
.distinct()
.collect(Collectors.toMap(author - author.getName(), author - author.getBooks()));
System.out.println(collect2);
// anyMatch
@Test
public void test10() {
List Author authors = S.getAuthors();
boolean b = authors.stream()
.anyMatch(author - author.getAge() 29);
System.out.println(b);
// allMatch
@Test
public void test11() {
List Author authors = S.getAuthors();
boolean b = authors.stream()
.allMatch(author - author.getAge() 18);
System.out.println(b);
// findFirst
@Test
public void test12() {
List Author authors = S.getAuthors();
Optional Author first = authors.stream()
.sorted(((o1, o2) - o1.getAge() - o2.getAge()))
.findFirst();
first.ifPresent(author - System.out.println(author));
// reduce() 的使用
@Test
public void test13() {
// 使用reduce求所有作者年龄的和
List Author authors = S.getAuthors();
Integer sum = authors.stream()
.distinct()
.map(author - author.getAge())
.reduce(0, (result, element) - result + element);
// .reduce(0, (result, element) - result + element);
System.out.println(sum);
@Test
public void test14() {
// 使用reduce求所有作者中年龄的最小值
List Author authors = S.getAuthors();
Integer minAge = authors.stream()
.map(author - author.getAge())
.reduce(Integer.MAX_VALUE, (res, ele) - res ele ? ele : res);
System.out.println(minAge);
// 没有初始值的reduce()使用
@Test
public void test15() {
List Author authors = S.getAuthors();
Optional Integer age = authors.stream()
.map(author - author.getAge())
.reduce((res, ele) - res ele ? ele : res);
System.out.println(age.get());
Optional Author authorOptional = Optional.ofNullable(null);
Author author1 = authorOptional.orElseGet(() - new Author(1l, "1", 1, "1", null));
System.out.println(author1);
// authorOptional.ifPresent(author - System.out.println(author.getName()));
@Test
public void test17() {
Optional Author authorOptional = Optional.ofNullable(null);
try {
Author author = authorOptional.orElseThrow((Supplier Throwable ) () - new RuntimeException("exception"));
System.out.println(author.getName());
} catch (Throwable throwable) {
throwable.printStackTrace();
// Optional的filter()方法
// ifPresent()可以安全消费Optional中包装的对象
@Test
public void test18() {
Optional Author optionalAuthor = Optional.ofNullable(S.getAuthors().get(0));
optionalAuthor
.filter(author - author.getAge() 14)
.ifPresent(author - System.out.println(author));
public void test19() {
Optional Author optionalAuthor = Optional.ofNullable(S.getAuthors().get(0));
boolean present = optionalAuthor.isPresent();
if (present) {
System.out.println(optionalAuthor.get().getName());
// Optional的map()，将一个 Optional 转换成另一个 Optional
@Test
public void test20() {
Optional Author optionalAuthor = Optional.ofNullable(S.getAuthors().get(0));
optionalAuthor.ifPresent(author - System.out.println(author.getBooks()));
Optional List Book books = optionalAuthor.map(author - author.getBooks());
books.ifPresent(books1 - System.out.println(books.get()));
// 类的静态方法
@Test
public void test21() {
List Author authors = S.getAuthors();
authors.stream()
.map(author - author.getAge())
.map(integer - String.valueOf(integer));
// lambda方法体中只有一行代码
// .map(String::valueOf);
// 对象的实例方法
@Test
public void test22() {
List Author authors = S.getAuthors();
Stream Author authorStream = authors.stream();
StringBuilder sb = new StringBuilder();
authorStream.map(author - author.getName())
// lambda方法体中只有一行代码，且将参数全部按照顺序传入这个重写方法中
.forEach(str - sb.append(str));
// 接口中只有一个抽象方法称为函数式接口
// 方法引用的条件是：lambda方法体中只有一行方法
// 构造器的方法引用
@Test
public void test23() {
List Author authors = S.getAuthors();
authors.stream()
.map(Author::getName)
.map(StringBuilder::new)
.map(stringBuilder - stringBuilder.append("abc"))
.forEach(System.out::println);
.map(author - author.getAge())
.peek(integer - System.out.println(integer+" "+Thread.currentThread().getName()))
.reduce(new BinaryOperator Integer () {
@Override
public Integer apply(Integer result, Integer ele) {
return result + ele;
}).ifPresent(sum - System.out.println(sum));
lambda表达式只关心 形参列表 和 方法体
用在重写抽象方法的时候，一般都是采用lambda表达式的方式来重写
函数式接口
函数式接口：接口中只有一个抽象方法，就称之为函数式接口。在Java中Consumer，Funciton，Supplier
方法引用：当lambda表达式的方法体中只有一行代码，并且符合一些规则，就可以将该行代码转换成方法引用的形式
可以直接使用idea的提示自动转换
这只是一个语法糖，能看懂代码就行，不要过于纠结
以上就是复习Stream流，函数式接口，方法引用（）的详细内容，想要了解更多 复习Stream流，函数式接口，方法引用的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。