JDK8中的stream流

1、创建Stream流

　　通过List集合

2、方法

　　Intermediate：

　　　　filter:过滤

　　　　map:重整

　　　　sorted:排序

　　　　limit：取固定数目数据

　　　　skip：跳过（删除）x条数据

　　　　distinct:去重复数据

　　　　peek

　　　　parallel:

　　　　sequential:

　　　　unordered:

　　Terminal：

　　　　count:统计数据数量

　　　　forEach:对流中每个数据都执行传入的方法

　　　　allMach:匹配所有，返回bool

　　　　anyMach:至少一个匹配，返回bool

　　　　noneMatch:

　　　　collect:可以传入集合中的常用方法

　　　　reduce：进行归约操作

　　　　toArray:

　　　　reduce:

　　　　min:

　　　　max:

　　　　findFirst:

　　　　findAnt:

　　　　iterator:

 

代码：

 private static void printMap() {
        //转成大写
        List<String> wordList =Arrays.asList("a","b","c");
        List<String> output = wordList.stream().
                map(String::toUpperCase).
                collect(Collectors.toList());
        output.forEach(System.out::println);

        //平方数
        List<Integer> nums = Arrays.asList(1, 2, 3, 4);
        List<Integer> squareNums = nums.stream().
                map(n -> n * n).
                collect(Collectors.toList());
        squareNums.forEach(System.out::println);
   //过滤
        List<String> lines = Arrays.asList("spring", "node", "mkyong");
        List<String> result1 = lines.stream()
                .filter(line -> !"mkyong".equals(line))
                .collect(Collectors.toList());

        result1.forEach(System.out::println);

        BufferedReader reader = new BufferedReader(new FileReader(""));
        //把每行读取内容的单词读出来
        List<String> read = reader.lines().
                flatMap(line -> Stream.of(line.split(" "))).
                filter(word ->word.length()>0).
                collect(Collectors.toList());

        //把男性打印出来
　　　　　//  roster.stream().filter(p -> p.getGender() == Person.Sex.MALE).forEach(p -> System.out.println(p.getName()));

        //找出全文的单词，转小写，并排序
        List<String> words = reader.lines().flatMap(line -> Stream.of(line.split(" "))).
                filter(word -> word.length()>0).map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());

        //Match
        List<Person> persons = new ArrayList();
        persons.add(new Person(1, "name" + 1, 10));
        persons.add(new Person(2, "name" + 2, 21));
        persons.add(new Person(3, "name" + 3, 34));
        persons.add(new Person(4, "name" + 4, 6));
        persons.add(new Person(5, "name" + 5, 55));
        boolean isAllAdult = persons.stream().
                allMatch(p -> p.getAge() > 18);
        System.out.println("All are adult? " + isAllAdult);
        boolean isThereAnyChild = persons.stream().
                anyMatch(p -> p.getAge() < 12);
        System.out.println("Any child? " + isThereAnyChild);

　　　　 

　　　　//将一个List中元素的某一属性取出来作为一个list，并做过滤
　　　　List<Long> names=  users.stream().filter(Objects::nonNull).map(User::getId).collect(Collectors.toList());

　　　　//将List转换成Map
　　　　//key:id value:name
　　　　Map<Long, String> map = users.stream().collect(Collectors.toMap(p -> p.getId(), p -> p.getName()));
　　　　//或者,第三个参数表示如果key重复保留k1,舍弃k2。
　　　　Map<Long, String> map2 = users.stream().collect(Collectors.toMap(User::getId,User::getName,(k1,k2)->k1));
　　　　//key:id value:user
　　　　Map<Long, User> map3 = users.stream().collect(Collectors.toMap(p -> p.getId(), p->p));
　　　　//遍历map，包括k,v。map.values.forEach()不能遍历Key
　　　　map3.forEach((k,v)-> System.out.println("k:v="+k+":"+v));

　　　　//使用sorted对List排序
　　　　//降序，默认是升序
　　　　List<User> list=users.stream().sorted(Comparator.comparing(User::getId).reversed()).collect(Collectors.toList());

　　　　//对List分组存入一个Map
　　　　//按照性别分组
　　　　Map<String,List<User>> map=users.stream().collect(Collectors.groupingBy(User::getSex));
　　　　map.forEach((k,v)-> System.out.println("k:v="+k+":"+v));

　　　　//flatMap和map
　　　　//map
　　　　List<String> str = Arrays.asList("a,b,c", "d,e", "f");
　　　　List<String[]> list1 = str.stream().map(s -> s.split(",")).collect(Collectors.toList());
　　　　list1.forEach(p-> System.out.print(Arrays.toString(p)+","));//[a, b, c],[d, e],[f]

　　　　//flatMap
　　　　List<String> list2 = str.stream().map(s -> s.split(",")).flatMap(Arrays::stream).sorted(Comparator.comparing(p->p.toString()).reversed()).collect(Collectors.toList());
　　　　System.out.println(list2);//[f, e, d, c, b, a]

　　　　//flatMap与map的区别在于 flatMap是将一个流中的每个元素都转成一个个流，flatMap之后得到的是每个流中元素的总的集合，即对每个流进行了二次遍历取出其中的元素，融合到总的集合中。

　　　　//anyMatch
　　　　Map<Long, String> map = new HashMap<>();
　　　　map.put(1L, "1号");
　　　　map.put(2L, "2号");
　　　　map.put(3L, "3号");
　　　　List<User> list = Lists.newArrayList();
　　　　list.add(new User(1L,10,"1号","",""));
　　　　list.add(new User(2L,10,"2号","",""));
　　　　list.add(new User(3L,10,"3号","",""));
　　　　boolean f = false;
　　　　//所有都匹配的时候才会返回true
　　　　for(Map.Entry<Long,String> entry:map.entrySet()){
    　　　　f = list.stream().anyMatch(p ->
            　　　　Objects.equals(entry.getKey(), p.getId())
    　　);
　　　　}

　　　　
　　　　//从一种类型转换成另一种类型

　　　　List<String> list1 = Arrays.asList(ids);

　　　　List<ObjectId> collect = list1.stream().map(id -> {
    　　　　return new ObjectId(id);
　　　　}).collect(Collectors.toList());

}

有借鉴，若有侵权请告知，谢谢