Java基础00-Stream流34

1. Stream流

Stream流

1.1 体验Stream流

　　 

代码示例：

//需求:按照下面的要求完成集合的创建和遍历
public class StreamDemo {
    public static void main(String[] args) {
        // 1:创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        // 2:把集合中所有以"张“开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<String>();
        // boolean startsWith(String prefix); 测试此字符串是否以指定的前缀开头。
        for (String s : list) {
            if (s.startsWith("张")) {
                zhangList.add(s);
            }
        }
//        System.out.println(zhangList);

        // 3:把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList = new ArrayList<String>();
        for (String s : zhangList) {
            if (s.length() == 3) {
                threeList.add(s);
            }
        }
//        System.out.println(threeList);

        // 4:遍历上一步得到的集合
        for (String s : threeList) {
            System.out.println(s);
        }
        System.out.println("---------------");
        // Stream流来改进
//        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);        
    }
}

运行结果：

　　

1.2 Stream流的思想和生成方式

　　 

　　

　　

代码示例：

//Stream流的常见生成方式
public class StreamDemo01 {
    public static void main(String[] args) {
        // 1:Collection体系的集合可以使用默认方法stream ()生成流
        // default Stream<E> stream ()
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();

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

        // 2:Map体系的集合间接的生成流
        Map<String, Integer> map = new HashMap<String, Integer>();
        // 使用key值间接生成Stream流
        Stream<String> keyStream = map.keySet().stream();
        // 使用value值间接生成Stream流
        Stream<Integer> valueStream = map.values().stream();
        // 使用键值对间接生成Stream流
        Stream<Entry<String, Integer>> entryStream = map.entrySet().stream();

        // 3:数组可以通过Stream接口的静态方法of (T... values)生成流
        String[] strArray = { "hello", "world", "java" };
        Stream<String> strArrayStream = Stream.of(strArray);
        // 也可以直接使用参数生成Stream流
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        // int类型也可以
        Stream<Integer> streamStream3 = Stream.of(10, 20, 30);

    }
}

1.3 Stream流的常见中间操作方法

 　　

1.3.1 filter

filter(Predicate predicate)：方法使用Predicate接口（Lambda表达式）过滤

　　

代码示例：

public class StreamDemo02 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        // 需求1:把list集合中以张开头的元素在控制台输出
//        list.stream().filter((String s) -> {
//            return s.startsWith("张");
//        }).forEach(System.out::println);
        //使用简化的
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("---------------");
        // 需求2:把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("---------------");
        // 需求3:把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

运行结果：

　　

1.3.2 limit && skip

limit(long maxSize)：使用该方法可以截取maxSize个数据
skip(long n)：使用该方法可以跳过n个数据

　　

代码示例：

public class StreamDemo03 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        // 需求1:取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------------------------");
        // 需求2:跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------------------------");
        // 需求3:跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

运行结果：

　　

1.3.3 concat && distinct

concat(Stream a,Stream b) :将a和b两个流合并
distinct()：返回时将重复的元素去掉

　　

代码示例：

public class StreamDemo04 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        // 需求1:取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        // 需求2:跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        // 需求3:合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(s1, s2).forEach(System.out::println);
        // 需求4:合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
    }
}

运行结果：

　　

1.3.4 sorted() && sorted(Comparator comparator)

sorted()：将结果安装自然规则排序
sorted(Comparator comparator)：排序规则可以根据，Lambda表达式Comparator，自己定义

　　

代码示例： 

public class StreamDemo05 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");

        // 需求1:按照字母顺序把数据在控制台输出
        list.stream().sorted().forEach(System.out::println);
        System.out.println("--------------------");

        // 需求2:按照字符串长度把数据在控制台输出
        list.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            int num2 = num == 0 ? s1.compareTo(s2) : num;
            return num2;
        }).forEach(System.out::println);
    }
}

运行结果：

1.3.5 map && mapToInt 

　　

代码示例：

public class StreamDemo06 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        // 需求:将集合中的字符串数据转换为整数之后在控制台输出
        // <R>Stream<R> map (Function mapper): 返回由给定函数应用于此流的元素的结果组成的流
//        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);

        System.out.println("----------------");

        // 使用IntStream mapToInt (ToIntFunction mapper):
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        
        System.out.println("----------------");
        
        // int sum () 返回此流中元素的总和
        // 该方法是是IntStream类独有的方法
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

    }
}

运行结果：

　　

1.4 Stream流的常见终结操作方法

　　
代码示例：

public class StreamDemo06 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        // 需求:将集合中的字符串数据转换为整数之后在控制台输出
        // <R>Stream<R> map (Function mapper): 返回由给定函数应用于此流的元素的结果组成的流
//        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);

        System.out.println("----------------");

        // 使用IntStream mapToInt (ToIntFunction mapper):
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        
        System.out.println("----------------");
        
        // int sum () 返回此流中元素的总和
        // 该方法是是IntStream类独有的方法
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

    }
}

运行结果：

　　

1.5 Stream流的练习

　　
代码示例：

public class StreamDemo06 {
    public static void main(String[] args) {
        // 创建一个集合存储对个字符串
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        // 需求:将集合中的字符串数据转换为整数之后在控制台输出
        // <R>Stream<R> map (Function mapper): 返回由给定函数应用于此流的元素的结果组成的流
//        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);

        System.out.println("----------------");

        // 使用IntStream mapToInt (ToIntFunction mapper):
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        
        System.out.println("----------------");
        
        // int sum () 返回此流中元素的总和
        // 该方法是是IntStream类独有的方法
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

    }
}

运行结果：

　　

1.6 Stream流的收集操作（将数据收集到集合中）

　　
代码示例： 

public class CollertDemo {
    public static void main(String[] args) {
        // 创建List集合
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");

        // 需求1:得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

        // 需求2:把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> listCollect = listStream.collect(Collectors.toList());
        for (String s : listCollect) {
            System.out.println(s);
        }

        // 创建Set集合
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);
        System.out.println("-----------------");
        // 需求3:得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(i -> i > 25);
        // 需求4:把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> setCollect = setStream.collect(Collectors.toSet());
        for (Integer i : setCollect) {
            System.out.println(i);
        }
        System.out.println("-----------------");
        // 定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = { "林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25" };

        // 需求5:得到字符串中年龄数据大于28的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        // 需求6:把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> mapStream = arrayStream
                .collect(Collectors.toMap((key -> key.split(",")[0]), value -> Integer.parseInt(value.split(",")[1])));

        // 遍历mapStream
        Set<String> keySet = mapStream.keySet();
        for (String key : keySet) {
            Integer value = mapStream.get(key);
            System.out.println(key + "." + value);
        }

    }
}

运行结果：