2.2概念

它可以被用来对集合或数组进行链状流式的操作。方便对集合或数组操作

2.3 常用操作

2.3.1 创建流

collection集合创建

单例集合： 集合对象.strerm()

@Test
public void collectList(){
   Stream<Book> stream = getBookList().stream();
   stream.forEach(book -> System.out.println(book));
}

双例集合：转换成单例集合再创建

 @Test
   public void collectMap(){
       HashMap<Long, Book> map = new HashMap<>();
       getBookList().stream().forEach(book -> {
           map.put(book.getId(),book);
       });
       //转为单例集合
       Set<Map.Entry<Long, Book>> entries = map.entrySet();
       entries.stream().forEach(System.out::println);
   }

数组创建

数组：Arrays.stream(数组) 或 Stream.of(数组)来操作

注意：Arrays.stream方法生成流是数值流，不是Stream

   @Test
   public void  arrCreate(){
       System.out.println("-------Arrays.stream-------");
       Integer [] arr={1,2,3,4,5,6};
       Stream<Integer> stream = Arrays.stream(arr);
       stream.forEach(System.out::print);
       System.out.println('\n'+"-------Stream.of-------");
       Stream.of(arr).forEach(arrs-> System.out.print(arrs));
   }

Stream创建

//Stream创建
@Test
public void streamCreate(){
   Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
   stream.forEach(System.out::print);
}

2.3.2 中间操作

filter

对流中的元素进行条件过滤

例如：过滤书名为‘小黄历险记’的书本，并打印出来

使用匿名内部类调用

   @Test
   void middleFilter(){
       //过滤书名为‘小黄历险记’的书本 alt+enter 转为lambda形式
      getBookList().stream().filter(new Predicate<Book>() {
          @Override
          public boolean test(Book book) {
              return !book.getName().equals("小黄历险记");
          }
      }).forEach(book -> System.out.println(book));
  }

转为lambda形式

@Test
void middleFilter(){
    //过滤书名为‘小黄历险记’的书本 alt+enter 转为lambda形式
   getBookList().stream()
           .filter(book -> !book.getName().equals("小黄历险记"))
           .forEach(book -> System.out.println(book));
}

map

可以对流中的元素进行计算或转换

例如：返回所有的书籍作家列表并去重输出

  @Test
   void middleMap(){
       //返回所有的书籍作家列表并去重输出
      List<String> authorNameList = getBookAuthorList().stream().map(new Function<Book, String>() {
          @Override
          public String apply(Book book) {
              return book.getAuthor().getName();
          }
      }).distinct().collect(Collectors.toList());  //去重并转为list
      //遍历输出
      authorNameList.forEach(System.out::println);
  }

dsitinct

去重

例如：返回所有的书籍作家列表并去重输出

   @Test
   void middleDistinct(){
       //返回所有的书籍作家列表并去重输出
     getBookAuthorList().stream()
              .map(book -> book.getAuthor().getName())
             .distinct().forEach(System.out::println);
   }

sorted

排序

例如：对书籍价格降序排序并输出

   @Test
   void middleSorted(){
       //对书籍价格降序排序并输出
       getBookList().stream()
               .sorted(new Comparator<Book>() {
                   @Override
                   public int compare(Book o1, Book o2) {
                       return (int)(o1.getPrice()-o2.getPrice());
                   }
               }).forEach(book -> System.out.println(book));
   }

注意：调用空参的sorted()方法，需要流中的元素实现Comparable

limit

设置流的最长长度

例如：输出三条书籍数据

   @Test
   void middleLimit(){
       //输出三条书籍数据
       getBookList().stream()
               .limit(3)
               .forEach(System.out::println);
   }

skinp

扔掉前n个流内容

例如：

输出去掉书籍前2个的列表

   @Test
   void middleSkinp(){
       //输出去掉书籍前2个的列表
       getBookList().stream()
               .skip(2)
               .forEach(System.out::println);
   }

flatMap

把一个对象转换成多个对象作为流中的元素

例1：

输出所有书籍的全部粉丝并去重

 @Test
   void middleFlagMap(){
       输出所有书籍的全部粉丝并去重
       getBookFansList().stream()
               .flatMap(new Function<Book, Stream<Fans>>() {
                   @Override
                   public Stream<Fans> apply(Book book) {
                       return book.getFans().stream();
                   }
               }).distinct().forEach(fans -> System.out.println(fans));
   }

peek

遍历处理

   //对书籍所有价格增加100
   getBookList().stream()
           .peek(new Consumer<Book>() {
               @Override
               public void accept(Book book) {
                   book.setPrice(book.getPrice()+100.0);
               }
           }).forEach(book -> System.out.println(book));
}

2.4 终结操作

forEach

遍历

例子：输出所有书籍的书名

  @Test
   public void finalForEach(){
       //输出所有书籍的书名
       getBookList().stream()
               .distinct()
               .forEach(book -> System.out.println(book.getName()));
   }

count

计算流个数

例子：输出书籍所有粉丝的数量并去重

   @Test
   public void finalCount(){
       //输出书籍所有粉丝的数量并去重
       long count = getBookFansList().stream()
               .flatMap(book -> book.getFans().stream())
               .distinct()
               .count();
       System.out.println(count);
   }

max&min

取流中最值

例子：分别获取作家的所出书籍的最高分和最低分

       List<Author> authors = getAuthors();
       Optional<Integer> max = authors.stream()
               .flatMap(author -> author.getBooks().stream())
               .map(book -> book.getScore())
               .max((o1, o2) -> o2 - o1);

       Optional<Integer> min = authors.stream()
               .flatMap(author -> author.getBooks().stream())
               .map(book -> book.getScore())
               .min((o1, o2) -> o1 - o2);
       System.out.println(max.get()+"-"+min.get());

collect

把当前流转换成一个集合

toList

例子：获取一个存放所有书籍的List集合

 @Test
   public void finalCollectList(){
       //获取一个存放所有书籍的List集合
       List<Book> bookList = getBookList().stream()
               .collect(Collectors.toList());
       System.out.println(bookList);
   }

toSet

例子：获取一个存放所有书籍的粉丝Set集合

@Test
   public void finalCollectSet(){
       //获取一个存放所有书籍的粉丝Set集合
       Set<Fans> fansSet = getBookFansList().stream()
               .flatMap(book -> book.getFans().stream())
               .collect(Collectors.toSet());
       System.out.println(fansSet);
   }

toMap

例子：获取一个Map集合，map的key为书名，value为List<Fans>

   @Test
   public void finalCollectMap(){
       //获取一个Map集合，map的key为书名，value为List<Fans>
       //注意map中key是唯一的
       Map<String, List<Fans>> listMap = getBookFansList().stream()
               .collect(Collectors.toMap(new Function<Book, String>() {
                   @Override
                   public String apply(Book book) {
                       return book.getName();
                   }
               }, book -> book.getFans()));

//        Map<String, List<Fans>> listMap = getBookFansList().stream()
//                .collect(Collectors.toMap(book -> book.getName(), book -> book.getFans()));
       System.out.println(listMap);
   }

groupingBy

条件分组

例子：根据书籍类型进行分组

@Test
public void finalCollectGroupingBy(){
   //根据书籍类型进行分组
   Map<String, List<Book>> listMap = getBookList().stream()
           .collect(Collectors.groupingBy(book -> book.getType()));
   Set<Map.Entry<String, List<Book>>> entrySet = listMap.entrySet();
   entrySet.forEach(System.out::println);
}

counting

符合条件的总数

例子：查看书籍价格高于999的总数

@Test
public void finalCollectCounting (){
   //查看书籍价格高于999的总数
   Long count = getBookList().stream()
           .filter(book -> book.getPrice() > 999)
           .collect(Collectors.counting());
   System.out.println(count);
}

summingDouble

对结果求和

例子：求出书籍价格之和

@Test
public void finalCollectSummingDouble(){
   //求出书籍价格之和
  double price= getBookList().stream()
           .collect(Collectors.summingDouble(value -> value.getPrice()));
   System.out.println(price);
}

minBy

筛选元素中最小数

例子：查找出描述最少的书籍

@Test
public void finalCollectMinBy(){
   //查找出描述最少的书籍
   Book book = getBookList().stream()
           .collect(Collectors.minBy((o1, o2) -> o1.getDescription().length() - o2.getDescription().length())).get();
   System.out.println(book);
}

joining

以指定分隔符链接成字符串

例子：将书籍名字，以指定分隔符链接成字符串

@Test
public void  finalCollectJoining(){
   //将书籍名字，以指定分隔符链接成字符串
   String bookNames = getBookList().stream()
           .map(book -> book.getName())
           .collect(Collectors.joining("-"));
   System.out.println(bookNames);

}

sum

求和

@Test
public void finalSum(){
   //求出书籍价格之和
   double priceSum = getBookList().stream()
           .mapToDouble(Book::getPrice).sum();
   System.out.println(priceSum);

}

min

求最小值

@Test
public void finalMin(){
   //求出书籍价格最低
   OptionalDouble min = getBookList().stream()
           .mapToDouble(Book::getPrice).min();
   System.out.println(min);
   double priceMin = min.getAsDouble();
   System.out.println(priceMin);
}

max

求最大值

@Test
public void finalMax(){
   //求出价格最高的书籍
   Optional<Book> max = getBookList().stream()
           .max(Comparator.comparing(book -> book.getPrice()));
   Double price = max.get().getPrice();
   System.out.println(price);
}

匹配

anyMatch

用来判是否至少匹配条件的一个元素，返回boolean类型

例子：判断是否有价格高于999以上的

   @Test
   public void finalAnyMatch(){
       //判断是否有价格高于999以上的书籍
       boolean b = getBookList().stream()
               .anyMatch(book -> book.getPrice() > 999);
       System.out.println(b);
   }

AllMatch

用来判断是否都符合匹配条件，返回boolean类型

  @Test
   public void finalAllMatch(){
       //判断价格是否都高于999以上的
       boolean b = getBookList().stream()
               .allMatch(book -> book.getPrice() > 999);
       System.out.println(b);
   }

noneMath

用来判断是否都不符合匹配条件，返回boolean类型

   @Test
   public void finalNoneMatch(){
       //判断价格是否都不高于999以上的
       boolean b = getBookList().stream()
               .noneMatch(book -> book.getPrice() > 999);
       System.out.println(b);
   }

查找

findAny

获取流中的任意元素

例子：查找任意一个书籍粉丝大于1的书籍，存在则输出书籍名字

   @Test
   public void finalFindAny(){
       //查找任意一个书籍粉丝大于1的书籍，存在则输出书籍名字
       Optional<Book> bookOptional = getBookFansList().stream()
               .filter(book -> book.getFans().size() > 1)
               .findAny();
       //如果存在则输出
       bookOptional.ifPresent(book -> System.out.println(book.getName()));
   }

findFirst

获取流中的第一个元素

例子：获取一个价格搞于999的书籍，并输出该书籍名字和价格

   @Test
   public void finalFindFirst(){
       //获取一个价格搞于999的书籍，并输出该书籍名字和价格
        getBookList().stream()
                .filter(book -> book.getPrice()>999)
                .findFirst()
                .ifPresent(book -> System.out.println(book.getName()+"-"+book.getPrice()));
   }

reduce归定

对流中的数据按照制定的计算方式计算出一个结果

内部计算方式如下：

T reult=identity;
for (T element:this stream)
   result=accumulator.apply(result,element)
return result;

查找书籍价格最高

   @Test
   public void finalReduce(){
       //查找书籍价格最高
       Double reduce = getBookFansList().stream()
               .map(book -> book.getPrice())
               .reduce(0.0, (result, element) -> result + element);
       System.out.println(reduce);

   }

reduce一个参数的重载形式内部的计算

查找价格最低的书籍

   @Test
   public void finalReduce02(){
       //查找价格最低的书籍
       Optional<Double> priceOptional = getBookFansList().stream()
               .map(book -> book.getPrice())
               .reduce(new BinaryOperator<Double>() {
                   @Override
                   public Double apply(Double finalPrice, Double price) {
                       return finalPrice > price ? price : finalPrice;
                   }
               });
       System.out.println(priceOptional.get());

   }