Java8——Stream 流

 关注
发布于: 2020 年 07 月 16 日
Stream是数据渠道，用于操作集合、数组等生成的元素序列。
﻿
Stream操作的三个步骤：
﻿
创建Stream
﻿
中间操作
﻿
终止操作
﻿
一、获取stream的四种方式﻿
通过collection系列集合的stream()或parallelStream()获取。
﻿
@Test
void test11(){
    List<String> list = new ArrayList<>();
    Stream<String> stringStream = list.stream();
}
﻿
通过Arrays中的静态方法stream()获取数组流。
﻿
@Test
void test11(){
    Person[] person = new Person[10];
    Arrays.stream(person);
}
﻿
通过Stream中的静态方法of()。
﻿
@Test
void test11(){
    Stream<String> stream = Stream.of("a", "b", "c");
}
﻿
创建无限流
﻿
/**
 * 迭代
 */
@Test
void test11(){
    Stream<Integer> integerStream = Stream.iterate(0, x -> x + 2);
}
﻿
/**
 * 生成
 */
@Test
void test11(){
    Stream.generate(() -> Math.random());
}
﻿
二、中间操作﻿
中间操作不会执行任何操作，只有终止操作才会一次性输出全部值，即“惰性求值”。
﻿
2.1 筛选与切片﻿
filter——接收lamdba，从流中排除某些元素
﻿
@Test
void test12(){
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    // 中间操作
    Stream<Person> personStream = personList.stream()
        .filter(e -> e.getAge() > 18);
    // 终止操作
    personStream.forEach(System.out::println);
}
﻿
limit——截断流，使其元素不超过给定数量
﻿
@Test
void test12(){
    
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    personList.stream()
        .limit(1)
        .forEach(System.out::println);
}
﻿
skip(n)——跳过元素，返回一个扔掉前n个元素的流，若不足n个，则返回一个空流。与limit(n)互补。
﻿
@Test
void test12(){
    
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20)
    );
    personList.stream()
        .skip(1)
        .forEach(System.out::println);
}
﻿
distinct——筛选，通过生成元素的hashCode()和equals()，去除重复元素。
﻿
@Test
void test12(){
    
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20),
        new Person("Java旅途",20)
    );
    personList.stream()
        .distinct()
        .forEach(System.out::println);
}
﻿
**注意：使用distinct的时候需要重写实体的hashCode()和equals()方法。**
﻿
2.2 映射﻿
map——接收lamdba，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
﻿
/**
 * 获取personList的所有name
 */
@Test
void test13(){
    List<Person> personList = Arrays.asList(
        new Person("Java旅途",18),
        new Person("Java旅途",20),
        new Person("Java旅途",20)
    );
    personList.stream()
        .map(Person::getName)
        .forEach(System.out::println);
}
﻿
flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流生成一个流。
﻿
// 将字符串转换为字符，并将字符放进list返回
static Stream<Character> filterCharcter(String string){
    List<Character> list = new ArrayList<>();
    for (Character ch : string.toCharArray()){
        list.add(ch);
    }
    return list.stream();
}
﻿
@Test
void test13(){
    List<String> list = Arrays.asList("aaa","bbb","ccc");
    list.stream()
        .flatMap(LamdbaApplicationTests::filterCharcter)
        .forEach(System.out::println);
}
﻿
2.3 排序﻿
sorted()——自然排序（comparable）
sorted(comparator com)——定制排序（comparator ）
﻿
/**
* 定制排序，e1和e2按age排序，age一样按name排
*/
@Test
void test14(){
    List<Person> personList = Arrays.asList(
            new Person("Java旅途",18),
            new Person("Java旅途",20)
    );
    personList.stream()
        .sorted((e1,e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                return e1.getAge()+"".compareTo(e2.getAge()+"");
            }
        }).forEach(System.out::println);
}
﻿
三、终止操作﻿
3.1 查找与匹配﻿
完善一下Person类
﻿
@Data
public class Person implements Serializable {
    private static final long serialVersionUID = -7008474395345458049L;
    private String name;
    private int age;
    private Status status;
    
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(String name, int age, Status status) {
        this.name = name;
        this.age = age;
        this.status = status;
    }
    public enum Status {
        FRER,
        BUSY;
    }
}
﻿
allMatch——检查是否匹配所有元素
﻿
/**
* 是否所有元素都是Fire状态，是返回true
*/
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .allMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
﻿
anyMatch——检查是否至少匹配一个元素
﻿
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .anyMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
﻿
noneMatch——检查是否所有元素都不匹配
﻿
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    boolean b = personList1.stream()
        .noneMatch(e -> e.getStatus().equals(Person.Status.FRER));
    System.out.println(b);
}
﻿
findFirst——返回第一个元素
﻿
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    Optional b = personList1.stream()
        .findFirst();
    System.out.println(b.get());
}
﻿
findAny——返回当前流中的任意元素
﻿
@Test
void test15(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    Optional b = personList1.stream()
        .findAny();
    System.out.println(b.get());
}
﻿
count——返回流中元素的总数
max——返回流中最大值
min——返回流中最小值
﻿
3.2 规约﻿
reduce(T identity, BinaryOperator)/reduce(BinaryOperator)——可以将流中元素反复结合起来，得到一个值。
﻿
/**
  * reduce 第一个参数是起始值
  */
@Test
void test16(){
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer sum = list.stream()
        			  .reduce(0,(x,y) -> x+y);
    System.out.println(sum);
    
    Optional<Integer> reduce = list.stream()
                				   .reduce((x, y) -> x + y);
    System.out.println(reduce.get());
}
﻿
3.3 收集﻿
collect——将流转化为其他形式。接收一个Collector接口的实现。用于给Stream中元素做汇总的方法。
﻿
/**
* 取出名字放在一个list中
*/
@Test
void test16(){
    List<Person> personList1 = Arrays.asList(
        new Person("Java旅途",18, Person.Status.FRER),
        new Person("Java旅途",20, Person.Status.BUSY)
    );
    List<String> collect = personList1.stream()
        .map(Person::getName)
        .collect(Collectors.toList());
    collect.forEach(System.out::println);
}
﻿
Optional常用方法﻿
Optional类是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
﻿
Optional.of(T t) ——创建一个Optional实例
Optional.empty()——创建一个空的optional实例
Optional.ofNullable(T t)——若t不为null，创建optional实例，否则创建空实例
isPresent()——判断是否包含值
orElse(T t)——如果调用对象包含值，返回该值，否则返回 t
orElseGet(Supplier s)——如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f)——如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
flatMap(Function mapper)——与map类似，要求返回值必须是Optional
﻿
发布于: 2020 年 07 月 16 日阅读数: 132
原文链接:【http://xie.infoq.cn/article/7b6a43142887a2ab111fa8cff】。
Java旅途

 关注
还未添加个人签名 2020.06.17 加入
公众号：Java旅途
发布
暂无评论