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();

    }

}

巴特西

Stream流使用

Stream流的使用

转换为流的操作

map转换为stream流

数组转换为Stream流

list转换为stream流

流的中间操作

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

filter过滤多个条件使用and

map：用于数据转换

distinct：去重操作

sorted：排序操作

limit：限制数据长度

skip：跳过几个元素

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

终结操作

forEach：负责遍历输出数据

count：获取个数有返回值

max,min：获取最大最小值

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

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

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

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

findAny：获取流中的任意元素

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

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

需要准备的静态数据

需要准备的实体类

最新文章

热门文章

巴特西

Stream流使用

Stream流的使用

转换为流的操作

map转换为stream流

数组转换为Stream流

list转换为stream流

流的中间操作

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

filter过滤多个条件使用and

map：用于数据转换

distinct：去重操作

sorted：排序操作

limit：限制数据长度

skip：跳过几个元素

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

终结操作

forEach：负责遍历输出数据

count：获取个数 有返回值

max,min：获取最大最小值

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

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

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

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

findAny：获取流中的任意元素

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

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

需要准备的静态数据

需要准备的实体类

最新文章

热门文章

count：获取个数有返回值

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

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

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