JDK8 新特性 Stream流基本方法

学习了stream，特此记录下来自己所学，一遍以后复习。

1.stream的创建

创建流的方式有很多种，比如：

1.1Arrays.stream 、

        int[] array = {1,2,3,4,5,6,7,8};
        IntStream stream = Arrays.stream(array);
        stream.forEach(System.out::print);

---

结果：

12345678

1.2Stream.of

        String[] strArray = { "熊大", "熊二", "光头强" };
        Stream<String> strArray1 = Stream.of(strArray);
        strArray1.forEach(System.out::print);

结果

熊大熊二光头强

1.3Collection.stream

        ArrayList<String> strings = new ArrayList<>();
        strings.add("熊大");
        strings.add("熊二");
        strings.add("光头强");
        Stream<String> stream1 = strings.stream();
        stream1.forEach(System.out::print);

  HashMap<Integer, String> map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            map.put(i,"map"+i);
        }
        Stream<Integer> stream2 = map.keySet().stream();
        Stream<Map.Entry<Integer, String>> stream3 = map.entrySet().stream();
        System.out.println();
        stream2.limit(5).forEach(System.out::print);
        System.out.println();
        stream3.limit(5).forEach(System.out::println);

结果

熊大熊二光头强
01234
0=map0
1=map1
2=map2
3=map3
4=map4

1.4Stream.iterate

  Stream<Integer> streamIt = Stream.iterate(1,(x) -> x*2);
  stream.limit(5).forEach(System.out::println);

结果

0
2
4
6
8
10
12
14
16
18

1.5Stream.generate，

Stream.generate(() ->Math.random()).limit(5).forEach(System.out::println);

结果：

2
0
4
4
1

常用的则是根据 Collection.stream()，从集合中创建流

2.stream对数据的处理-中间操作符

流方法	含义
filter	用于通过设置的条件过滤出元素
distinct	返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。
limit	会返回一个不超过给定长度的流。
skip	返回一个扔掉了前n个元素的流。
map	接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。
flatMap	使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。
sorted	返回排序后的流

2_1.filter过滤集合中不符合条件的元素

    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered = strings.stream().filter(str->str.contains("f")).collect(Collectors.toList());
    System.out.println(filtered);

2_2distinct去重

    List<String> strings = Arrays.asList("abc", "bc", "bc", "efg", "abcd","", "jkl", "jkl");
    List<String> distincted = strings.stream().distinct().collect(Collectors.toList());
    System.out.println(distincted);
    //---------------------------------------------------------
    List<User> users = new ArrayList<>();
    users.add(new User(1,"z"));
    users.add(new User(1,"z"));
    users.add(new User(2,"s"));
    List<User> distinctedUser = users.stream().distinct().collect(Collectors.toList());
    System.out.println(distinctedUser);

2_3limit获取流中前n个元素

 List<String> strings = Arrays.asList("abc", "bc", "bc", "efg", "abcd","", "jkl", "jkl");
    List<String> limited = strings.stream().limit(2).collect(Collectors.toList());
    System.out.println(limited);

2_4skip获取流中除去前n个元素的其他所有元素

    List<String> strings = Arrays.asList("abc", "bc", "bc", "efg", "abcd","", "jkl", "jkl");
    List<String> skipped = strings.stream().skip(2).collect(Collectors.toList());
    System.out.println(skipped);

2_5map对流中所有元素做统一处理

 List<String> strings = Arrays.asList("abc", "bc", "bc", "efg", "abcd","", "jkl", "jkl");
    List<String> mapped = strings.stream().map(str -> "itheima_"+str).collect(Collectors.toList());
    System.out.println(mapped);

2_6flatMap

    List<String> strings = Arrays.asList("abc", "bc", "bc", "efg", "abcd","", "jkl", "jkl");
    List<Character> flatmaped = strings.stream().flatMap(str -> Java8StreamTest.getCharacterByString(str)).collect(Collectors.toList());
    System.out.println(flatmaped);

2_7sorted

   //-----------------------字母排序--------------------------------------
    List<String> string1 = Arrays.asList("abc", "bc", "bcf", "efg", "abcd","bca", "jkl", "jkl");
    List<String> sorted = string1.stream().sorted().collect(Collectors.toList());
    System.out.println(sorted);
    //------------------------数字排序--------------------------------------
    List<Integer> ints = Arrays.asList(50,10,2,40,-9,8);
    List<Integer> collect = ints.stream().sorted().collect(Collectors.toList());
    System.out.println(collect);
    //-------------------------汉字排序-------------------------------------------
    List<String> strings2 = Arrays.asList("张三", "李四", "王五", "赵柳", "张哥","李哥", "王哥");
    List<String> collect1 = strings2.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
    System.out.println(collect1);

}

3.stream的终端造作

流方法	含义
anyMatch	检查是否至少匹配一个元素，返回boolean。
allMatch	检查是否匹配所有元
noneMatch	检查是否没有匹配所有元素，返回boolean。
findAny	将返回当前流中的任意元素。
findFirst	返回第一个元素
forEach	遍历流
collect	收集器，将流转换为其他形式。
reduce	可以将流中元素反复结合起来，得到一个值。
count	返回流中元素总数。

示例代码

3_1anyMatch判断集合中是否至少存在一个元素满足条件

    List<String> string = Arrays.asList("abc", "bc", "bcf", "efg", "abcd","bca", "jkl", "jkl");
    boolean bc = string.stream().anyMatch(s -> s.contains("q"));
    System.out.println(bc);

3_2allMatch判断集合中是否所有元素都满足条件

    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().allMatch(s -> s == "abc");
    out.println(b);

3_3noneMatch判断集合中是否所有元素都不满足条件

    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().noneMatch(s -> s == "abc");
    out.println(b);

3_4findAny返回当前流中任意元素

        List<String> string = Arrays.asList("abc", "bc", "bcf", "efg", "abcd","bca", "jkl", "jkl");
        for (int i = 0; i < 1000; i++) {
            Optional<String> any = string.stream().findAny();      //stream串行的总拿第一个
            if(any.isPresent()) System.out.print(any.get());
        }
        System.out.println();
        System.out.println("============parallelStream().findAny()==============");
        for (int i = 0; i < 1000; i++) {
            Optional<String> any = string.parallelStream().findAny();//parallelStream并行的随机拿
            if(any.isPresent()) System.out.println(any.get());
        }

3_5findFirst返回当前流中第一个元素

List<String> stringw = Arrays.asList("abc", "bcf", "efg", "abcd","bca", "jkl", "jkl");
for (int i = 0; i < 1000; i++) {
Optional<String> any = string.parallelStream().findFirst();
if(any.isPresent()) System.out.println(any.get());
		}
System.out.println();
System.out.println("=============Stream().findFirst()=============");
for (int i = 0; i < 1000; i++) {
Optional<String> any = string.stream().findFirst();
if(any.isPresent()) System.out.print(any.get());
        }

串行，并行都只拿第一个

3_6forEach java 遍历流

    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    strings.stream().forEach(s -> out.println(s));

3_7collect流转换为其他形式

    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Set<String> set = strings.stream().collect(Collectors.toSet());
    List<String> list = strings.stream().collect(Collectors.toList());
    Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
    out.println(set);
    out.println(list);
    out.println(map);

3_8reduce将流中元素反复结合起来，得到一个值

    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    //reduce方法一
    Optional<String> reduce1 = strings.stream().reduce((acc,item) -> {return acc+item;});
    //reduce方法二
    String reduce2 = strings.stream().reduce("itcast", (acc, item) -> {
    	return acc + item;
    });

3_9count返回流中元素总数

    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    long count = strings.stream().count();
    out.println(count);