Stream流使用

Stream流的使用

转换为流的操作

map转换为stream流

Map map = new HashMap();
Set<Map.Entry<String,Integer>> set = map.entrySet();
Stream<Map.Entry<String,Integer>> stream = set.stream();

数组转换为Stream流

Integer [] arr = {1,2,3,4,5,4};
Stream<Integer> stream = Stream.of(arr);

list转换为stream流

List list = new ArrayList();
Stream stream = list.stream();

流的中间操作

对于集合数据的操作

filter：用于过滤掉匹配条件数据

List<Author> authors = getAuthors();
authors.stream()
        .filter(author -> author.getName().length() > 1) //名字长度大于1的过滤掉
        .forEach(author -> System.out.println(author.getName()));

filter过滤多个条件使用and

List<Author> authors = getAuthors();
authors.stream()
        .filter(((Predicate<Author>) author -> author.getAge() > 17).and(author -> author.getName().length() > 1))
        .forEach(author -> System.out.println(author.getName()));

map：用于数据转换

List<Author> authors = getAuthors();
authors.stream()
        .map(author -> author.getAge()) //将List的数据转换为 Integer
        .map(age -> age+10) //给integer加10
        .forEach(age -> System.out.println(age));//终结操作

distinct：去重操作

List<Author> authors = getAuthors();
authors.stream()
        .distinct() //去除重复的数据
        .forEach(author -> System.out.println(author.getName()));

sorted：排序操作

List<Author> authors = getAuthors();
authors.stream()
        .distinct() //去重
        .sorted((o1,o2) -> o1.getAge() - o2.getAge()) //第一个参数减第二个参数升序，反过来就是降序
        .forEach(author -> System.out.println(author.getAge()));

limit：限制数据长度

List<Author> authors = getAuthors();
authors.stream()
        .distinct() //去重
        .sorted() //如果不填写参数默认使用实体类中compareTo方法排序
        .limit(1) //展示一条数据
        .forEach(author -> System.out.println(author.getName()));

skip：跳过几个元素

List<Author> authors = getAuthors();
authors.stream()
        .distinct() //去重
        .sorted() //排序
        .skip(2) //跳过两个元素，例如1，2，3三个数据跳过两个只输出 3
        .forEach(author -> System.out.println(author.getAge()));

flagMap：可以转换多个对象,map只能转换单个对象

List<Author> authors = getAuthors();
authors.stream()
        .flatMap(author -> author.getBooks().stream())//获取到集合对象转换为流
        .distinct() //给第一次转换完成的结果去重
        .flatMap(book -> Arrays.stream(book.getCategory().split(","))) //获取book对象中的类别字段，将 值一，值二这种类型的数据转换为数组在转换为流
        .distinct() //给第二次转换完成的结果去重
        .forEach(s -> System.out.println(s));

终结操作

操作stream流，使用完成后必须需要终结操作，否则无效,终结操作之后不可以在去.中间操作

forEach：负责遍历输出数据

List<Author> authors = getAuthors();
authors.stream()
        .distinct() //去重
        .sorted() //排序
        .forEach(author -> System.out.println(author)); //遍历输出结果

count：获取个数 有返回值

List<Author> authors = getAuthors();
long count = authors.stream()
        .flatMap(author -> author.getBooks().stream()) //将authors流对象转换为book流对象
        .distinct() //去重
        .count(); //获取返回的个数，需要用一个变量接收。
System.out.println(count);

max,min：获取最大最小值

Optional对象 https://www.cnblogs.com/zjh0420/p/16677938.html

List<Author> authors = getAuthors();
Optional<Integer> max = authors.stream()
        .flatMap(author -> author.getBooks().stream())
        .distinct()
        .map(book -> book.getScore())
        .max((o1, o2) -> o1 - o2); //获取最大值

System.out.println(max.get());

collect：把当前流转换成一个集合

List<Author> authors = getAuthors();
//转换为一个新的list集合
List<String> collect = authors.stream()
        .map(author -> author.getName())
        .collect(Collectors.toList());
System.out.println(collect);

//转换为一个新的Set集合
Set<Book> collect = authors.stream()
        .flatMap(author -> author.getBooks().stream())
        .collect(Collectors.toSet());
System.out.println(Arrays.asList(collect));

//转换为一个新的Mapp集合
List<Author> authors = getAuthors();
Map<String, List<Book>> collect = authors.stream()
        .distinct()
        .collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()));
System.out.println(collect);

anyMatch：用来判断匹配条件 返回boolean类型

List<Author> authors = getAuthors();
boolean b = authors.stream()
        .anyMatch(author -> author.getAge() > 29); //判断是否有年龄大于29的

System.out.println(true);

allMatch：用来判断所有条件是否都匹配 返回boolean类型

List<Author> authors = getAuthors();
boolean b = authors.stream()
        .allMatch(author -> author.getAge() >= 18); //判断是否是所有人的年龄都大于18

System.out.println(b);

noneMatch：用来判断所有条件是否都不匹配 返回boolean类型

List<Author> authors = getAuthors();
boolean b = authors.stream()
        .noneMatch(author -> author.getAge() > 100);

System.out.println(b);

findAny：获取流中的任意元素

List<Author> authors = getAuthors();
Optional<Author> any = authors.stream()
        .findAny(); //随机的

System.out.println(any);

findFirst：获取流中的第一个元素

List<Author> authors = getAuthors();
Optional<Author> first = authors.stream()
        .sorted((o1,o2) -> o1.getAge() -  o2.getAge())
        .findFirst();

first.ifPresent(author -> System.out.println(author.getName()));

reduce：把流中的数据按照指定的方式计算出一个结果

List<Author> authors = getAuthors();
//求年龄总和
Integer reduce = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(0, (result, element) -> result + element);
System.out.println(reduce);

//求所有年龄最大的值
Integer max = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(Integer.MIN_VALUE, (result, element) -> result < element ? element : result);//result为Integer.MIN_VALUE,后面计算比较继续赋值给result
System.out.println(max);

//求所有年龄最小的值， reduce中两个参数第一个作为初始值
Integer min = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(Integer.MAX_VALUE, (result, element) -> result > element ? element : result); //result为Integer.MAX_VALUE,后面计算比较继续赋值给result
System.out.println(min);

//求最小值年龄，reduce一个参数默认将列表第一个值 赋值给result作为初始值比较
Optional<Integer> minOne = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce((result, element) -> result > element ? element : result);
System.out.println(minOne.get());

需要准备的静态数据

    //使用数据
    private static List<Author> getAuthors(){
        //数据初始化
        Author author = new Author(1L, "蒙多",33,"一个从菜刀中明悟哲理的祖安人" ,null);
        Author author2 = new Author(2L, "亚拉索",15, "狂风也追逐不上他的思考速度" , null);
        Author author3 = new Author(3L,"易",14,"是这个世界在限制他的思维" , null);
        Author author4 = new Author(3L,"易",14, "是这个世界在限制他的思维" , null);

        //书籍列表
        List<Book> books1 = new ArrayList<>();
        List<Book> books2 = new ArrayList<>();
        List<Book> books3 = new ArrayList<>();

        books1.add(new Book(1L, "刀的两侧是光明与黑暗", "哲学,爱情",88,"用一把刀划分了爱恨"));
        books1.add(new Book(2L,"一个人不能死在同一把刀下","个人成长,爱情" ,99, "讲述如何从失败中明悟真理"));

        books2.add(new Book(3L,"那风吹不到的地方" , "哲学" ,85 , "带你用思维去领略世界的尽头"));
        books2.add(new Book(3L, "那风吹不到的地方" , "哲学" ,85 , "带你用思维去领略世界的尽头"));
        books2.add(new Book(4L , "吹或不吹", "爱情,个人传记",56,"一个哲学家的恋爱观注定很难把他所在的时代理解"));

        books3.add(new Book(5L, "你的剑就是我的剑", "爱情" ,56,"无法想象一个武者能对他的伴侣这么的宽容"));
        books3.add(new Book(6L, "风与剑","个人传记",100,"两个哲学家灵魂和肉体的碰撞会激起怎么样的火花呢?"));
        books3.add(new Book(6L,"风与剑","个人传记",100, "两个哲学家灵魂和肉体的碰撞会激起怎么样的火花呢?"));

        author.setBooks(books1);
        author2.setBooks(books2);
        author3.setBooks(books3);
        author4.setBooks(books3);

        List<Author> authorList = new ArrayList<>(Arrays.asList(author,author2,author3,author4));
        return authorList;
    }

需要准备的实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class Book {

    //id
    private long id;
    //姓名
    private String name;
    //年龄
    private String category;
    //评分
    private int score;
    //简介
    private String intro;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class Author implements Comparable<Author> {

    //id
    private Long id;
    //姓名
    private String name ;
    //年龄
    private Integer age;
    //简介
    private String intro;
    //作品
    private List<Book> books ;

    //比较排序
    @Override
    public int compareTo(Author o) {
        return o.getAge() - this.getAge();
    }
}