list.stream().的操作

1.StringUtils类中isEmpty与isBlank的区别

StringUtils.isEmpty(String str) 判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0

StringUtils.isNotEmpty(String str) 等价于 !isEmpty(String str)

System.out.println(StringUtils.isEmpty(null));        //true
System.out.println(StringUtils.isEmpty(""));          //true
System.out.println(StringUtils.isEmpty("   "));       //false
System.out.println(StringUtils.isEmpty("dd"));        //false

StringUtils.isBlank(String str) 判断某字符串是否为空或长度为0或由空白符(whitespace) 构成

StringUtils.isBlank(String str) 等价于 !isBlank(String str)

System.out.println(StringUtils.isBlank(null));        //true
System.out.println(StringUtils.isBlank(""));          //true
System.out.println(StringUtils.isBlank("   "));       //true
System.out.println(StringUtils.isBlank("dd"));        //false   

2.orElse()和list.stream().min()

获取一个结果，如果没有，则输出（）里的内容。

List<MiuiBigversion> miuiBigversionList=miuiBigversionRepository.findAll();
MiuiBigversion miuiBigversion=miuiBigversionList.stream().min(Comparator.comparing(MiuiBigversion::getBigver)).orElse(null);
//查出miuiBigversion类型中bigver最小的那条数据，如果没有，返回orElse()中的值null.

3.list.stream().filter()

过滤符合条件的数据。

stream().filter()的用法_点点滴滴-CSDN博客_.stream().filter()

List<MiuiBigversion> miuiBigversionList=miuiBigversionRepository.findAll();
List<MiuiBigversion> miuiBigversion1=miuiBigversionList.stream().filter(s->s.getBigver()>14).collect(Collectors.toList());
//过滤出miuiBigversionList中bigver>14的所有数据，返回结果list
MiuiBigversion miuiBigversion2=miuiBigversionList.stream().filter(s->s.getBigver()==15).findFirst().orElse(null);
//过滤出miuiBigversionList中bigver==15的某一条数据，如果没有,返回orElse()中的值null.
//gitver时int类型，如果是其他类型，可用其他方法，如equals等。

4.list.stream.peek() 中间操作

java 8 Stream中操作类型和peek的使用 - flydean - 博客园

List<String> list=new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.stream().filter(e -> e.length() > 3)
        .peek(e -> System.out.println("Filtered value: " + e))
        .map(s->s.toUpperCase())
        .peek(e -> System.out.println("Mapped value: " + e))
        .collect(Collectors.toList());
//输出：
Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR

看看peek和map的不同：

List<String> listmap=new ArrayList<>();
listmap=list.stream().map(s->s.toUpperCase()).collect(Collectors.toList());
System.out.println("使用map的结果:"+listmap);
//输出：
使用map的结果:[ONE, TWO, THREE, FOUR]

List<String> listpeek=new ArrayList<>();
listpeek=list.stream().peek(s->s.toUpperCase()).collect(Collectors.toList());
System.out.println("使用peek的结果:"+listpeek);
//输出：
使用peek的结果:[one, two, three, four]

可以看到使用peek之后stream中的元素并没有被转换成大写格式。

当然peek也有例外，假如我们Stream里面是一个对象会怎么样？

一个User类：

public class User {
    private String name;
    private int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
}

使用peek：将name设置为zhao。

List<User> users=new ArrayList<>();
users.add(new User("zyy",18));
users.add(new User("zy",1));
List<User> list3=users.stream().peek(s->s.setName("zhao")).collect(Collectors.toList());
System.out.println("age:"+list3.get(0).getAge());
System.out.println("name:"+list3.get(0).getName());
System.out.println("age:"+list3.get(1).getAge());
System.out.println("name:"+list3.get(1).getName());
//输出：
age:18
name:zhao
age:1
name:zhao

过滤,将name=zy的名字设置为yan

List<User> users1=new ArrayList<>();
users1.add(new User("zyy",18));
users1.add(new User("zy",1));
List<User> list4=users1.stream().filter(s->s.getName().equals("zy")).peek(s->s.setName("yan")).collect(Collectors.toList());
System.out.println(list4.size());
System.out.println("age:"+list4.get(0).getAge());
System.out.println("name:"+list4.get(0).getName());
//输出：
1
age:1
name:yan

可见，我们看到如果是对象的话，实际的结果会被改变。

为什么peek和map有这样的区别呢？

我们看下peek和map的定义：

Stream<T> peek(Consumer<? super T> action)
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

peek接收一个Consumer，而map接收一个Function。

Consumer是没有返回值的，它只是对Stream中的元素进行某些操作，但是操作之后的数据并不返回到Stream中，所以Stream中的元素还是原来的元素。

而Function是有返回值的，这意味着对于Stream的元素的所有操作都会作为新的结果返回到Stream中。