55-stream

获取Stream流的方式     1Stream<E> stream(): 获取Collection集合对象的Stream流对象
可以是ArrayList/LinkedList/HashSet/LinkedHashSet对象
2获取数组对应的Stream流对象 of(T... values): 获取方法可变参数对应的Stream流对象  
参数列表:  T... values: 可变参数,可以传递参数列表,可以传递数组,还可以不传参
 ### Stream的forEach方法 对Stream流对象中的元素遍历 传递匿名内部类对象 传递lambda表达式
Stream<T> filter 判断型型接口,传递匿名内部类对象,lambda表达式  根据T类型的数据获取boolean类型的结果 
 Stream<T>  long count(): 获取Stream流对象中的元素的个数 
        注意:   此方法没有参数,调用时不需要传递参数,根不能再写lambda表达式了 
Stream<T>  Stream<T> limit(long n):  获取Stream流对象中的前n个元素,返回一个新的Stream流对象 Stream<T> skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象
共同的参数:   long n: 表示数字  
    练习:  步骤一: 只要前7个 Stream<String> s2 = s.limit(7);
        步骤二: 跳过前4个  Stream<String> s3 = s2.skip(4);
        步骤三: 遍历输出
Stream<T> concat(Stream<T> a, Stream<T> b):
            把方法参数指定的两个Stream流对象合并成一个Stream流对象返回
      String str = "hello";   str = str.concat("world");      
 Stream<R> map(Function<T, R> mapper)流中的元素映射到另一个流中
 该方法需要一个Function函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流.
 按照方法参数mapper指定的方式把Stream流对象中的T类型的元素转换成R类型,返回新的Stream流 
 apply(T t)根据方法参数T类型的t,获取R类型的数据 转换前:T类型apply(String personInfo) 转换后: R类型      
   //1.获取Lis/Sett集合对象对应的Stream流对象  
public class Demo02GetStream {
    public static void main(String[] args) {
        //1.获取List集合对象对应的Stream流对象
        List<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();
        System.out.println(s1); 
        //2.获取Set集合对象对应的Stream流对象
        Set<Integer> set = new HashSet<>();
        Stream<Integer> s2 = set.stream();
        System.out.println(s2); 
        //Map集合
        Map<String,String> map = new HashMap<>(); 
        //3.获取Map集合键对应的Set集合对象对应的Stream流对象
        Set<String> set2 = map.keySet();
        Stream<String> s3 = set2.stream();
        System.out.println(s3); 
        //4.获取Map集合值对应的Collection集合对象对应的Stream流对象
        Collection<String> coll = map.values();
        Stream<String> s4 = coll.stream();
        System.out.println(s4); 
        //5.获取Map集合键值对对应的Set集合对象对应的Stream流对象
        Set<Map.Entry<String, String>> set3 = map.entrySet();
        Stream<Map.Entry<String, String>> s5 = set3.stream();
        System.out.println(s5);
        System.out.println("---------------------"); 
        String[] arr = {"张无忌", "张翠山", "张三丰", "张一元"};
        //获取数组对应的Stream流对象
        Stream<String> s6 = Stream.of(arr);
        System.out.println(s6); 
        Stream<String> s7 = Stream.of("大娃", "二娃", "三娃", "四娃", "五娃", "六娃", "七娃", "爷爷", "蛇精", "蝎子精");
        System.out.println(s7);
    }
}
public class Demo03ForEach {
    public static void main(String[] args) {
        Stream<String> s = Stream.of("大娃", "二娃", "三娃", "四娃", "五娃", "六娃", "七娃", "爷爷", "蛇精", "蝎子精"); 
         s.forEach((String name)->{
            System.out.println(name);
        });  
    }
}
//Stream流遍历Collection集合
public class Demo07CollectionForeach {
    public static void main(String[] args) {
        //创建Collection集合
        Collection<String> coll = new ArrayList<>();
        //添加元素
        Collections.addAll(coll, "Hello", "Java", "C++", "Python");

        //单列和双列集合内部都有foreach方法,直接调用即可
        //单列集合调用forEach方法,传递匿名内部类对象
        coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //单列集合调用forEach方法,传递lambda表达式标准格式
        coll.forEach((String s)->{
            System.out.println(s);
        });  
    }
}
/Map集合的forEach方法
public class Demo08MapForeach {
    public static void main(String[] args) {
        //创建Map集合对象,并添加键值对
        Map<String, String> map = new HashMap<>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "柳岩");

        //Map集合有forEach方法
        //双列集合调用forEach方法,传递匿名内部类对象
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key + "::::" + value);
            }
        });
        //双列集合调用forEach方法,传递lambda表达式标准格式
        map.forEach((String key, String value) -> {
            System.out.println(key + "==" + value);
        });
        //双列集合调用forEach方法,传递lambda表达式简化格式
        map.forEach((key, value) -> System.out.println(key + "==" + value));
    }
}
 练习: 步骤一: 过滤出所有带娃的  步骤二: 遍历输出结果 
public class Demo04Filter {
    public static void main(String[] args) {
        //创建Stream流对象
        Stream<String> s = Stream.of("大娃", "二娃", "三娃", "四娃", "五娃", "六娃", "七娃", "爷爷", "蛇精", "蝎子精"); 
        //1.匿名内部类的方式
        /*Stream<String> s2 = s.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("娃");
            }
        });*/

        //2.使用lambda表达式的标准格式
         Stream<String> s2 = s.filter((String name) -> {
            return name.contains("娃");
        });  
        //遍历输出
        s2.forEach((String name)->{
            System.out.println(name);
        }); 
    }
}   
     
 Stream<T>  long count(): 获取Stream流对象中的元素的个数 
        注意:   此方法没有参数,调用时不需要传递参数,根不能再写lambda表达式了 
public class Demo05Count {
    public static void main(String[] args) {
        //创建Stream流对象
        Stream<String> s = Stream.of("大娃", "二娃", "三娃", "四娃", "五娃", "六娃", "七娃", "爷爷", "蛇精", "蝎子精"); 
        //获取Stream流对象中的元素的个数
        long num = s.count();
        System.out.println("Stream流对象中的元素的个数: "+num); 
    }
}
 Stream流综合练习
    要求:
        1. 第一个队伍只要名字为3个字的成员姓名；
        2. 第一个队伍筛选之后只要前3个人；
        3. 第二个队伍只要姓张的成员姓名；
        4. 第二个队伍筛选之后不要前2个人；
        5. 将两个队伍合并为一个队伍；
        6. 打印整个队伍的姓名信息。

    按照Stream流 + lambda表达式标准格式
 */
public class Demo04StreamTest {
    public static void main(String[] args) {
        List<String> o = new ArrayList<>();
        o.add("迪丽热巴");
        o.add("宋远桥");
        o.add("苏星河");
        o.add("老子");
        o.add("庄子");
        o.add("孙子");
        o.add("洪七公");  
        //获取第一个队伍的Stream流对象
        Stream<String> os1 = o.stream(); 
        //1. 第一个队伍只要名字为3个字的成员姓名；
        Stream<String> os2 = os1.filter((String name) -> {
            return name.length() == 3;   
        }); 
        //2. 第一个队伍筛选之后只要前3个人；
        Stream<String> os3 = os2.limit(3); 
        List<String> t = new ArrayList<>();
        t.add("古力娜扎");
        t.add("张无忌");
        t.add("张三丰");
        t.add("赵丽颖");
        t.add("张二狗");  
        //获取第二个队伍的Stream流对象
        Stream<String> ts1 = t.stream(); 
        //3. 第二个队伍只要姓张的成员姓名；
        Stream<String> ts2 = ts1.filter((String name) -> {
            return name.startsWith("张");
        }); 
        //4. 第二个队伍筛选之后不要前2个人；
        Stream<String> ts3 = ts2.skip(2); 
        //5. 将两个队伍合并为一个队伍；
        Stream<String> ots3 = Stream.concat(os3, ts3);  
        //6. 打印整个队伍的姓名信息。
        ots3.forEach((String name)->{
            System.out.println(name);
        });
    }
} 
public class Demo08StreamMap {
    public static void main(String[] args) { 
        //创建List集合对象strList,存储数据类型String
        List<String> strList = new ArrayList<>();
        //添加多个字符串,每个字符串代表一个Person对象的信息
        Collections.addAll(strList,"张三:18","李四:38","王五:28"); 
        strList.stream()
                .map((String personInfo)->{
                    //把字符串按照:进行切割
                    String[] array = personInfo.split(":");
                    //把切割后的数组信息封装成Person对象并返回
                    return new Person(array[0], Integer.parseInt(array[1]));
                })
                .forEach((Person p)->{
                    System.out.println(p);
                }); 
    }
} 
对流操作完成之后,如果需要将结果进行收集,例如获取对应的集合/数组等,如何操作? 
       //利用collect方法把Stream流对象,转换成List集合对象
        list = Stream流对象.collect(Collectors.toList());	
        set = Stream流对象.collect(Collectors.toSet());转换为Set集合  
Stream流对象中的内容收集到数组中:  Object[] toArray()  
public class Demo09StreamCollect {
    public static void main(String[] args) {
        //创建List集合对象,并添加数据
        List<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person("张三", 18),
                new Person("李四", 38),
                new Person("王五", 28)); 
        //获取List集合对象的Stream流对象
        Stream<Person> s = list.stream(); 
        //利用map方法,把每个Person对象的年龄增加两岁后,存储到新的Stream流对象中
        Stream<Person> s2 = s.map(new Function<Person, Person>() {
            @Override
            public Person apply(Person person) {
                //把年龄增加两岁
                person.setAge(person.getAge() + 2);
                return person;
            }
        }); 
        //利用collect方法把Stream流对象,转换成List集合对象
        list = Stream流对象.collect(Collectors.toList()); 
        list = list.stream().map((Person person) -> {
            person.setAge(person.getAge() + 2);
            return person;
        }).collect(Collectors.toList()); 
        //遍历新的List集合
        list.forEach(p-> System.out.println(p));
    }
}
public class Demo04Filter {
    public static void main(String[] args) {
        //创建Stream流对象
        Stream<String> s = Stream.of("大娃", "二娃", "三娃", "四娃", "五娃", "六娃", "七娃", "爷爷", "蛇精", "蝎子精"); 
        Object【】 objArray=stream.toArray();
    }
}