Stream流属于管道流，只能被消费（使用）一次，第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这时第一个Stream流已经使用完毕，就会关闭，所以第一个Stream流就不能再调用方法了
1、使用Stream流遍历集合

 public static void main(String[] args) { 
    /* 创建一个集合，对集合中的任务姓名进行筛选，只输出名字姓张且只有三位的名字 */ ArrayList<String> list = new ArrayList<>(); list.add("张三丰"); list.add("张无忌"); list.add("张三"); list.add("周芷若"); list.add("灭绝师太"); // 传统遍历 for (String s : list) { 
    if (s.startsWith("张") && s.length() == 3) { 
    System.out.println(s); } } // 使用Stream流方式遍历集合 list.stream().filter(new Predicate<String>() { 
    @Override public boolean test(String s) { 
    return s.startsWith("张"); } }).filter(new Predicate<String>() { 
    @Override public boolean test(String s) { 
    return s.length() == 3; } }).forEach(new Consumer<String>() { 
    @Override public void accept(String s) { 
    System.out.println(s); } }); // 简化使用Stream流方式遍历集合 list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s)); } 

2、 获取Stream流的方式
java.util.stream.Stream是java 8 新加入的最常用的流接口（非函数式接口）
2.1 第一种：
所有的Collection集合都可以通过调用stream默认方法获取流对象
default Stream stream()
2.2 第二种：
Stream接口的静态方法of可以获取数组对应的流
static Stream of (T… values)
参数是一个可变参数，所以需要传递一个数组

讯享网 public static void main(String[] args) { 
    // 把集合转换为流 ArrayList<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> s = map.keySet(); Stream<String> stream3 = s.stream(); Collection<String> values = map.values(); Stream<String> stream4 = values.stream(); Set<Map.Entry<String, String>> entries = map.entrySet(); Stream<Map.Entry<String, String>> stream5 = entries.stream(); // 把数组转换为流 Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5); int[] arr = { 
   1, 2, 3, 4, 5}; Stream<int[]> stream7 = Stream.of(arr); } 

3、 常用方法
3.1 、延迟方法：
返回值类型仍然是Stream接口自身类型的方法，支持链式调用
3.1.1 filter方法：
Stream filter(Predicate<? super T> predicate);
filter方法的参数Predicate是一个函数式接口，可以传递Lambda表达式，对数据进行过滤
Predicate中的抽象方法：
boolean test(T t);

 Stream<String> stream = Stream.of("张三丰", "张无忌", "张翠山", "赵敏", "周芷若"); Stream<String> filterStream = stream.filter(name -> name.startsWith("张")); filterStream.forEach(name -> System.out.println(name)); 

3.1.2 map方法：
Stream map(Function<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换成为另一种R类型的流。
Function中的抽象方法：
R apply(T t);

讯享网 // 将字符串整型转换为Integer类型 Stream<String> stream = Stream.of("1", "2", "3", "4", "5"); Stream<Integer> integerStream = stream.map(s -> Integer.parseInt(s)); integerStream.forEach(i -> System.out.println(i)); 

3.1.3 limit方法：
limit方法用于截取流中的元素
limit方法可以对流进行截取，只取前n个
Stream limit(long maxSize);
参数是一个long类型，如果集合当前长度大于参数则进行截取，否则不进行操作

讯享网

 // 截取 Stream<String> stream = Stream.of("1", "2", "3", "4", "5"); Stream<String> limit = stream.limit(3); limit.forEach(s -> System.out.println(s)); 

3.1.4 skip方法：
skip方法用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流
Stream skip(long n);
如果流的长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

讯享网 // 跳过元素 Stream<String> stream = Stream.of("1", "2", "3", "4", "5"); Stream<String> skip = stream.skip(3); skip.forEach(s -> System.out.println(s)); 

3.1.5 concat方法：
aoncat方法用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
static Stream concat(Stream<? extends T> a, Stream<? extends T> b);

 // 合并两个流 Stream<String> stream1 = Stream.of("1", "2", "3", "4", "5"); Stream<String> stream2 = Stream.of("6", "7", "8", "9"); Stream<String> concat = Stream.concat(stream1, stream2); concat.forEach(s -> System.out.println(s)); 

3.2、 终结方法：
返回值类型不再是Stream接口自身类型的方法，不支持链式调用
3.2.1 forEach方法：
void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口，会将每一个流元素交给该函数进行处理。
Consumer接口是一个消费型的函数式接口，可以传递lambda表达式消费数据
简单来说forEach方法就是用来遍历数据的

讯享网 Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5); stream6.forEach(i -> System.out.println(i)); 

3.2.2 count方法：
count方法用于统计Stream流中元素的个数
long count();

 // 统计Stream流中元素的个数 Stream<String> stream = Stream.of("1", "2", "3", "4", "5"); long num = stream.count(); System.out.println(num);