流

不同的数据有不同的方式得到其stream

• 单列集合：使用Collection中的默认方法：default Stream<E> stream
• 双列集合：没有直接获取stream的方法，只能把他转化为单列集合
• 数组：Arrays中的静态方法：public static <T> Stream<T> stream(T[] array)
• 一堆零散的数据：这些数据必须同质，使用Stream接口中的方法：public static<T> Stream<T> of(T ...values)

中间方法

• 使用中间方法，会返回一个新的流
• stream只能使用一次，最好使用链式编程
• 修改Stream中的数据，不会改变原集合中的数据

filter

Stream<T> filter(Predicate<? super T> predicate)

按照某种规则过滤元素。

匿名内部类写法：

Stream<String> stream = list.stream().filter(new Predicate<String>() {@Overridepublic boolean test(String s) {if (s.startsWith("")) {return true;}return false;}
});

lambda表达式写法：

Stream<String> stream = list.stream().filter(s -> s.startsWith(""));

limit

Stream<T> limit(long maxSize)

获取前maxSize个元素

skip

Stream<T> skip(long n)

跳过前n个元素

distinct

Stream<T> distinct()

元素去重，依赖于hashcode和equals方法，因为其底层是使用HashSet实现的。

concat

static <T> Stream<T> concat(Stream a, Stream b)

将a和b合并为一个流

map

Stream<T> map(Function<T, R> mapper)

转换流中的数据类型

匿名内部类写法：

// Function<T, R>，则apply方法的返回值是R，接收的stream的泛型也得是R
Stream<Integer> stream = list.stream().map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s);}
});

lambda表达式写法：

Stream<Integer> stream = list.stream().map(s -> Integer.parseInt(s));

终结方法

• 终结方法的返回值不是stream

forEach

void for Each(Consumer action)

用来遍历流，可以进行一些操作

// 匿名内部类的写法
// accept的参数s代表的是流上的每一个数据，也就是list中的每一个元素
list.stream().forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}
});// lambda表达式的写法
list.stream().forEach(s -> System.out.println(s));

count

long count()

统计流上数据个数，也就是原数据元素的个数

toArray

toArray()

收集流中的数据，放在数组中

// IntFunction的泛型值得是具体的类型数组
// apply的参数是流中数据的个数，需要与数组的长度保存一致
list.stream().toArray(new IntFunction<String[]>() {@Overridepublic String[] apply(int value) {return new String[value];}
});// lambda表达式的写法
list.stream().toArray(value -> new String[value]);

collect

collect(Collector collector)

收集流中的数据，放在集合中。在收集前也可以使用一些中间方法进行筛选

• 收集到List中，参数是Collectors.toList()

list.stream().collect(Collectors.toList());

• 收集到Set中，参数是Collectors.toSet()

 list.stream().collect(Collectors.toSet());

• 收集到Map中，参数是Collectors.toMap(a,b)，其中a和b是两个匿名内部类，第一个对应健的生成规则，第二个对应值的生成规则

// 使用匿名内部类
list.stream().collect(Collectors.toMap(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s);}}, new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s);}}
));// 使用lambda表达式
list.stream().collect(Collectors.toMap(s -> Integer.parseInt(s), s -> Integer.parseInt(s)));