需求：
创建一个集合，存储多个字符串元素把集合中所有以"张"开头的元素存储到一个新的集合把"张"开头的集合中的长度为 3 的元素存储到一个新的集合遍历上一步得到的集合实现：
public class StreamDemo { public static void main(String[] args) { //创建一个集合，存储多个字符串元素 ArrayList<String> list = new ArrayList<String>(); list.add("林青霞"); list.add("张曼玉"); list.add("王祖贤"); list.add("柳岩"); list.add("张敏"); list.add("张无忌"); //把集合中所有以"张"开头的元素存储到一个新的集合 ArrayList<String> zhangList = new ArrayList<String>(); for (String s : list) { if (s.startsWith("张")) { zhangList.add(s); } } //把"张"开头的集合中的长度为3的元素存储到一个新的集合 ArrayList<String> threeList = new ArrayList<String>(); for (String s : zhangList) { if (s.length() == 3) { threeList.add(s); } } //遍历上一步得到的集合 for (String s : threeList) { System.out.println(s); } System.out.println("--------"); //Stream流来改进 list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println); } }运行结果：
张曼玉 张无忌 -------- 张曼玉 张无忌使用 Stream 流的方式的优点：
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为 3、逐一打印Stream 流把真正的函数式编程风格引入到 Java 中Stream 流的思想概述：
Stream 流的使用：
生成流
通过数据源(集合，数组等)生成流
list.stream()中间操作
一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
filter()终结操作
一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
forEachStream 流的常见生成方式：
Collection 体系的集合可以使用默认方法 stream() 生成流
default Stream<E> stream()Map 体系的集合间接的生成流
数组可以通过 Stream 接口的静态方法 of(T… values) 生成流
代码：
public class StreamDemo { public static void main(String[] args) { //Collection 体系的集合可以使用默认方法 stream() 生成流 List<String> list = new ArrayList<String>(); Stream<String> listStream = list.stream(); Set<String> set = new HashSet<String>(); Stream<String> setStream = set.stream(); //Map 体系的集合间接的生成流 Map<String, Integer> map = new HashMap<String, Integer>(); Stream<String> keyStream = map.keySet().stream(); Stream<Integer> valueStream = map.values().stream(); Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream(); //数组可以通过 Stream 接口的静态方法 of(T... values) 生成流 String[] strArray = {"hello", "world", "java"}; Stream<String> strArrayStream = Stream.of(strArray); Stream<String> strArrayStream2 = Stream.of("hello", "world", "java"); Stream<Integer> intStream = Stream.of(10, 20, 30); } }概念：中间操作的意思是，执行完此方法之后，Stream 流依然可以继续执行其他操作。
常见方法：
方法名说明Stream filter(Predicate predicate)用于对流中的数据进行过滤Stream limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据Stream skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流static Stream concat(Stream a, Stream b)合并 a 和 b 两个流为一个流Stream distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流Stream sorted()返回由此流的元素组成的流，根据自然顺序排序Stream sorted(Comparator comparator)返回由该流的元素组成的流，根据提供的 Comparator 进行排序Stream map(Function mapper)返回由给定函数应用于此流的元素的结果组成的流Function 接口中的方法 R apply(T t)IntStream mapToInt(ToIntFunction mapper)返回一个 IntStream 其中包含将给定函数应用于此流的元素的结果ToIntFunction 接口中的方法 int applyAsInt(T value)filter 代码演示
public class StreamDemo01 { 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(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); } }运行结果：
张曼玉 张敏 张无忌 -------- 林青霞 张曼玉 王祖贤 张无忌 -------- 张曼玉 张无忌limit 和 skip 代码演示
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：取前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); } }运行结果：
林青霞 张曼玉 王祖贤 -------- 柳岩 张敏 张无忌 -------- 王祖贤 柳岩concat 和 distinct 代码演示
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：取前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); } }运行结果：
林青霞 张曼玉 王祖贤 柳岩 张敏 张无忌sorted 代码演示
public class StreamDemo04 { 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); } }运行结果：
linqingxia liuyan wangzuxian zhangmanyu zhangmin zhangwuji -------- liuyan zhangmin zhangwuji linqingxia wangzuxian zhangmanyumap 和 mapToInt 代码演示
public class StreamDemo05 { 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"); //需求：将集合中的字符串数据转换为整数之后在控制台输出 list.stream().map(Integer::parseInt).forEach(System.out::println); // list.stream().mapToInt(Integer::parseInt).forEach(System.out::println); System.out.println("--------"); // int sum() 返回此流中元素的总和 int result = list.stream().mapToInt(Integer::parseInt).sum(); System.out.println(result); } }运行结果：
10 20 30 40 50 -------- 150概念：终结操作的意思是，执行完此方法之后，Stream 流将不能再执行其他操作。
常用方法：
方法名说明void forEach(Consumer action)对此流的每个元素执行操作long count()返回此流中的元素数代码：
public class StreamDemo { 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.stream().forEach(System.out::println); System.out.println("--------"); //需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出 long count = list.stream().filter(s -> s.startsWith("张")).count(); System.out.println(count); } }运行结果
林青霞 张曼玉 王祖贤 柳岩 张敏 张无忌 -------- 3需求：
演员类 Actor，里面有一个成员变量 name，一个带参构造方法，以及成员变量对应的 get/set 方法
现在有两个 ArrayList 集合，分别存储 6 名男演员名称和 6 名女演员名称，要求完成如下的操作 ：
男演员只要名字为 3 个字的前三人女演员只要姓林的，并且不要第一个把过滤后的男演员姓名和女演员姓名合并到一起把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据代码：
public class Actor { private String name; public Actor(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } } public class StreamDemo { public static void main(String[] args) { //创建集合 ArrayList<String> manList = new ArrayList<String>(); manList.add("周润发"); manList.add("成龙"); manList.add("刘德华"); manList.add("吴京"); manList.add("周星驰"); manList.add("李连杰"); ArrayList<String> womanList = new ArrayList<String>(); womanList.add("林心如"); womanList.add("张曼玉"); womanList.add("林青霞"); womanList.add("柳岩"); womanList.add("林志玲"); womanList.add("王祖贤"); // 男演员只要名字为 3 个字的前三人 Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3); // 女演员只要姓林的，并且不要第一个 Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1); // 把过滤后的男演员姓名和女演员姓名合并到一起 Stream<String> stream = Stream.concat(manStream, womanStream); // 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据 stream.map(Actor::new).forEach(s -> System.out.println(s.getName())); } }运行结果：
周润发 刘德华 周星驰 林青霞 林志玲概念：对数据使用 Stream 流的方式操作完毕后，可以把流中的数据收集到集合中。
常用方法：
方法名说明R collect(Collector collector)把结果收集到集合中工具类 Collectors 提供了具体的收集方式：
方法名说明public static Collector toList()把元素收集到List集合中public static Collector toSet()把元素收集到Set集合中public static Collector toMap(Function keyMapper, Function valueMapper)把元素收集到Map集合中代码：
public class CollectDemo { public static void main(String[] args) { //创建 List 集合对象 List<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> names = listStream.collect(Collectors.toList()); for (String name : names) { System.out.println(name); } System.out.println("--------"); //创建 Set 集合对象 Set<Integer> set = new HashSet<Integer>(); set.add(10); set.add(20); set.add(30); set.add(33); set.add(35); //需求3：得到年龄大于 25 的流 Stream<Integer> setStream = set.stream().filter(age -> age > 25); //需求4：把使用 Stream 流操作完毕的数据收集到 Set 集合中并遍历 Set<Integer> ages = setStream.collect(Collectors.toSet()); for (Integer age : ages) { System.out.println(age); } 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> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1]))); Set<String> keySet = map.keySet(); for (String key : keySet) { Integer value = map.get(key); System.out.println(key + " " + value); } } }运行结果：
林青霞 张曼玉 王祖贤 -------- 33 35 30 -------- 林青霞 30 王祖贤 33 张曼玉 35