Stream常用方式汇总

 1     // Collection接口 提供了stream()方法
 2 
 3     // List转流
 4     List<String> list = new ArrayList<>();
 5     Stream<String> streamA = list.stream();
 6 
 7     // Set转流
 8     Set<String> set = new HashSet<>();
 9     Stream<String> streamB = set.stream();
10 
11     // Map转流
12     Map<String, Integer> map = new HashMap<>();
13     Stream<Entry<String, Integer>> streamC = map.entrySet().stream();
14     Stream<Integer> streamD = map.values().stream();
15 
16     // 数组转流
17     String[] arr = { "A", "B", "C" };
18     Arrays.stream(arr);
19 
20     // Iterable转流
21     Iterable<String> iterable = new ArrayList<>();
22     StreamSupport.stream(iterable.spliterator(), false);

 1     // 高级收集器
 2 
 3     // 字符串拼接
 4 
 5     List<String> list = Arrays.asList("s1", "s2", "s3");
 6 
 7     // 无分隔符
 8     String strA = list.stream().collect(Collectors.joining());
 9     // 单个分隔符
10     String strB = list.stream().collect(Collectors.joining(","));
11     // 前后缀及分隔符
12     String strC = list.stream().collect(Collectors.joining(",", "[", "]"));
13 
14     // --------------------------------------------------
15 
16     // 返回集合
17 
18     // 返回数组
19     // 返回Object数据
20     Object[] arrO = list.stream().toArray();
21     // 返回特定类型数据
22     String[] arrS = list.stream().toArray(String[]::new);
23     
24     // 返回List
25     List<String> listO = list.stream().filter(str -> str.length() > 5).map(String::toUpperCase).collect(Collectors.toList());
26     // 返回特定类型如ArrayList
27     List<String> listP = list.stream().filter(str -> str.length() > 5).map(String::toUpperCase).collect(Collectors.toCollection(ArrayList::new));
28     // list转map
29     List<Item> items = new ArrayList<>();
30     Map<String, String> mapO = items.stream().collect(Collectors.toMap(Item::getItemId, Item::getName));
31     Map<String, Item> mapP = items.stream().collect(Collectors.toMap(Item::getItemId, Function.identity()));

 1 class Item {
 2     private String itemId;
 3     private String name;
 4     private String value;
 5     private List<String> subItems;
 6 
 7     public String getItemId() {
 8         return itemId;
 9     }
10 
11     public void setItemId(String itemId) {
12         this.itemId = itemId;
13     }
14 
15     public String getName() {
16         return name;
17     }
18 
19     public void setName(String name) {
20         this.name = name;
21     }
22 
23     public String getValue() {
24         return value;
25     }
26 
27     public void setValue(String value) {
28         this.value = value;
29     }
30 
31     public List<String> getSubItems() {
32         return subItems;
33     }
34 
35     public void setSubItems(List<String> subItems) {
36         this.subItems = subItems;
37     }
38 }

 1     List<String> listA = Arrays.asList("s1","s2","s3");
 2     List<String> listB = Arrays.asList("t1","t2","t3");
 3     
 4     // Stream.concat()实现多个流拼接
 5     Stream<String> streamA = Stream.concat(listA.stream(), listB.stream());
 6     
 7     // Stream.of()实现拼接
 8     // 多个元素
 9     Stream<String> streamB = Stream.of("A", "B", "C");
10     // 多个List
11     Stream<String> streamC = Stream.of(listA, listB).flatMap(Collection::stream);
12     // 多个Stream
13     Stream<String> streamD = Stream.of(listA.stream(), listB.stream()).flatMap(Function.identity());
14     
15     // flatMap实现子元素拼接
16     List<Item> items = new ArrayList<>();
17     Stream<String> streamE = items.stream().flatMap(i -> i.getSubItems().stream());

 1     List<Integer> number = Arrays.asList(1, 2, 3);
 2     List<String> list = Arrays.asList("s1", "s2", "s3");
 3 
 4     // 排序 sort
 5     number.stream().sorted();
 6     list.stream().sorted((s1, s2) -> s1.length() - s2.length());
 7     // 汇总 reduce
 8     number.stream().reduce((x, y) -> x + y).get();
 9     list.stream().reduce((s1, s2) -> s1 + "," + s2).get();
10     // 遍历
11     number.forEach(System.out::println);
12     // 分组
13     List<Item> items = new ArrayList<>();
14     Map<String, List<Item>> groupBy1 = items.stream().collect(Collectors.groupingBy(i -> i.getItemId()));
15     // 多个分组
16     Map<String, Map<String, List<Item>>> groupBy2 = items.stream().collect(Collectors.groupingBy(i -> i.getItemId(),
17             LinkedHashMap::new, Collectors.groupingBy(i -> i.getName(), LinkedHashMap::new, Collectors.toList())));

1     // 使用IntStream生成50个连续字符
2     IntStream.rangeClosed(0, 50).mapToObj(s -> "*").collect(Collectors.joining());
3     IntStream.rangeClosed(0, 50).mapToObj(s -> "*").collect(Collectors.joining(""));
4     IntStream.rangeClosed(0, 50).mapToObj(s -> "*").reduce((s1, s2) -> s1 + s2).get();
5     IntStream.rangeClosed(0, 50).mapToObj(s -> "*").reduce(new StringJoiner("", "[", "]"), StringJoiner::add, StringJoiner::merge);