Stream流代码总结

Stream流代码总结

1.把集合转换为流示例

public class Demo01Getstream {
    public static void main(String[] args) {
        //把集合转换为流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map = new HashMap<>();
        //获取键
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        //获取值
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //获取键与值得映射关系
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        Stream<Map.Entry<String,String>> stream5 = entrySet.stream();

        //把数组转换为stream流
        Stream<Integer> stream6 = Stream.of(1,2,3,4,5);
        //可变参数传递数组
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] str = {"123","456","789"};
        Stream<String> stream8 = Stream.of(str);
    }
}

2.Stream流的filter方法示例

public class Demo02StreamFilter {
    public static void main(String[] args) {
        //创建一个流 两种方式
        Stream<String> stream = Stream.of("张三丰", "张翠山", "周芷若", "赵敏", "张无忌");
        //对stream流中元素过滤
        Stream<String> stream1 = stream.filter((String name) -> {
            return name.startsWith("张");
        });
        //遍历
        stream1.forEach(name->System.out.println(name));
        /**
         * stream流属于管道流，只能被消费一次
         * 第一个stream流调用完毕，数据就会流到下一个stream流上
         * 而这时第一个stream流已经使用完毕，就会关闭了
         * 所以第一个stream流就不能再调用方法
         */

        //错误的
        stream.forEach(name->System.out.println(name));
    }
}

3.Stream的Foreach方法示例

用来遍历流中的数据，是一个终结方法，即遍历之后不能再调用流中其他方法

public class Demo02StreamForeach {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "田七");
        //使用foreach
        stream.forEach(name-> System.out.println(name));
    }
}

4.Stream流的Map方法示例

public class Demo04StreamMap {
    public static void main(String[] args) {
        //map 方法
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法，把字符串类型的整数转换(映射)为Integer类型
        Stream<Integer> stream1 = stream.map((String s) -> {
            return Integer.parseInt(s);
        });
        //遍历一下
        stream1.forEach(s->System.out.println(s));
    }
}

5.Stream流的Count方法示例

public class Demo05StreamCount {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

也是一个终结方法

6.Stream流的limit方法示例

limit方法：对流进行截取，只取前n个。是一个延迟方法，返回的是一个新的流，使用后可以调用流的其他方法

public class Demo06StreamLimit {
    public static void main(String[] args) {
        String[] arr = {"Mei","koda","daswsx","dxaaaaa"};
        Stream<String> stream = Stream.of(arr);
        //使用limit方法  只要前三个元素
        Stream<String> stream1 = stream.limit(3);
        stream1.forEach(name->System.out.println(name));
    }
}

7.Stream的skip方法示例

Skip方法：跳过几个元素

public class Demo07StreamSkip {
    public static void main(String[] args) {
        String[] arr = {"Mei","koda","daswsx","dxaaaaa"};
        Stream<String> stream = Stream.of(arr);
        Stream<String> stream1 = stream.skip(3);
        stream1.forEach(name->System.out.println(name));
    }
}

8.Stream的Concat方法示例

Concat方法：合并流

public class Stream08Concat {
    public static void main(String[] args) {
        String[] arr = {"Mei","koda","daswsx","dxaaaaa"};
        Stream<String> stream1 = Stream.of(arr);
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //把两个流组合为一个流
        Stream<String> concat = Stream.concat(stream, stream1);
        concat.forEach(name->System.out.println(name));
    }
}

9.应用

需求:
现有两个ArrayList集合存储队伍中的多个成员姓名，要求使用传统的方式来进行如下操作：

•  1.第一个队伍只要名字为三个字的成员姓名，存储到一个新集合中；
  

•  2.第一个队伍筛选之后只要前三个人，存储到一个新集合中；
  

•  3.第二个队伍只要姓张的成员姓名，存储到一个新集合中；
  

•  4.第二个队伍筛选之后不要前2个人，存储到一个新集合中；
  

•  5.将两个队伍合并为一个队伍，存储到一个新集合中；
  

•  6.根据姓名创建Person对象，存储到一个新集合中；
  

•  7.打印整个队伍的person对象信息；
  

传统方式

public class DemoChuantong {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石头");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        ArrayList<String> two = new ArrayList<>();
        two.add("张无忌");
        two.add("张三丰");
        two.add("张强");
        two.add("张伯伦");
        two.add("李思强");
        two.add("王桑");
        two.add("黄倩");
        two.add("周武");
        two.add("郭凯");

        //1.
        ArrayList<String> one1 = new ArrayList<>();
        for(String key:one){
            if(key.length()==3){
                one1.add(key);
            }
        }
        System.out.println("第一个需求,只要名字为三字的："+one1);

        //2.
        ArrayList<String> one2 = new ArrayList<>();
        for (String key : one1) {
            if(one1.indexOf(key)<3){
                one2.add(key);
            }else{
                break;
            }
        }
        System.out.println("第二个需求，取新集合前三个元素:"+one2);

        //3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
        ArrayList<String> two3 = new ArrayList<>();
        for (String key:two) {
            if(key.contains("张")){
                two3.add(key);
            }
        }
        System.out.println("第三个需求，第二个集合只要含张的元素:"+two3);

        //4.第二个队伍筛选之后不要前2个人，存储到一个新集合中；
        ArrayList<String> two4 = new ArrayList<>();
        for (String key:two3) {
            if(two3.indexOf(key)<2){
                continue;
            }else {
                two4.add(key);
            }
        }
        System.out.println("第四个需求，筛选之后不要前两个人:"+two4);


        //5.将两个队伍合并为一个队伍，存储到一个新集合中；
        ArrayList<String> list = new ArrayList<>();
        one.addAll(two);
        for (String key : one) {
            list.add(key);
        }
        System.out.println("第五个需求,合并两个集合:"+list);

        //6.根据姓名创建Person对象，存储到新集合中
        ArrayList<Person> persons = new ArrayList<>();
        for (String name : list) {
            Person person = new Person();
            person.setName(name);
            persons.add(person);
        }
        System.out.print("第六七个需求存储信息到Person对象，并打印其信息，Person集合中每个人的名字:");
        for(Person p : persons){
            System.out.print(p.getName()+"   ");
        }
    }
}

传统方式大家简单看下即可，有些地方写的不太规整，见谅。

Stream方式

public class DemoStream {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石头");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        ArrayList<String> two = new ArrayList<>();
        two.add("张无忌");
        two.add("张三丰");
        two.add("张强");
        two.add("张伯伦");
        two.add("李思强");
        two.add("王桑");
        two.add("黄倩");
        two.add("周武");
        two.add("郭凯");

//      1.第一个队伍只要名字为三个字的成员姓名，存储到一个新集合中；
//      2.第一个队伍筛选之后只要前三个人，存储到一个新集合中；
        Stream<String> stream1 = one.stream().filter(name -> name.length() == 3).limit(3);
        //stream1.forEach(name->System.out.print(name+" "));

        System.out.println();
        //3.第二个队伍只要姓张的成员姓名，存储到一个新集合中；
        //4.第二个队伍筛选之后不要前2个人，存储到一个新集合中；
        Stream<String> stream2 = two.stream().filter(name -> name.contains("张")).skip(2);
        //stream2.forEach(name->System.out.print(name+" "));

        System.out.println();
//        5.将两个队伍合并为一个队伍，存储到一个新集合中；
// *      6.根据姓名创建Person对象，存储到一个新集合中；
// *      7.打印整个队伍的person对象信息；

        System.out.println();
        Stream.concat(stream1,stream2).map(name->new Person(name)).forEach(p->System.out.println(p));
    }
}

PS:若要完成第5、6、7个需求，就不能再之前对流进行foreach操作，因为foreach是一个终结方法，若使用，则之后不能再使用concat方法。