标签：Stream stream author 使用 List System authors println

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：获取最大最小值

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,author,使用,List,System,authors,println
来源： https://www.cnblogs.com/zjh0420/p/16677915.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。