一 概述
Stream操作符分为两类中间操作和终止操作。
中间操作：返回一个Stream流
终止操作：返回非Stream类型的对象
注意点：在终止操作调用之前，中间操作并不执行。
stringList.stream()
.map(it -> {
String result = it.substring(0, 1).toUpperCase() + it.substring(1);
System.out.println("test");
return result;
});
//运行上面的例子并不会打印"test",原因在与这个Stream操作没有终止操作。
stringList.stream()
.map(it -> {
String result = it.substring(0, 1).toUpperCase() + it.substring(1);
System.out.println("test");
return result;
})
.forEach(System.out::println);
//运行上面的离职，在打印每一个元素之前，会打印test字符串
//因为，forEach是终止操作，会将中间操作激活执行。
二 常见操作符介绍
filter(Predicate predicate)
predicate：接受一个参数，返回一个boolean值。用于判断参数是否满足给定的断言条件。
含义：返回一个新的流，流中的元素是旧流中满足predicate的元素。见名知意--->过滤
属性：返回一个流，因此就是中间操作。
实例：
//打印一个数字集合中所有的奇数元素
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(2, 4, 1, 4, 3, 6, 7, 10, 23);
//原有的方式
for (int i = 0; i < integerList.size(); i++) {
if (integerList.get(i) % 2 != 0)
System.out.println(integerList.get(i));
}
//Stream方式
integerList.stream()//创建流
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
return integer % 2 != 0;
}
})//给定筛选条件 第一处
.forEach(System.out::println);//打印符合的元素
//Stream方式
integerList.stream()//创建流
.filter(it -> it % 2 != 0)//给定筛选条件 第二处
.forEach(System.out::println);//打印符合的元素
}
}
//第一处
Predicate 的类型是接受一个参数，返回一个boolean。(T t)->{boolean}
因此lambda表达式就是 第二处 it的含义就是元素
map(Function mapper)
mapper：接受一个参数，返回一结果。用于将参数类型按着给定的行为转为结果类型
含义：返回一个新的流，流中的元素是旧流中元素mapper之后的元素。见名知意--->转换
属性：返回一个流，因此就是中间操作。
实例：
//将数字集合中的元素平方后打印
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(2, 4, 1, 4, 3, 6, 7, 10, 23);
integerList.stream()//创建流
.map(it->it*it)//转换操作 it就是带转换的元素 it*it就是转换的方式
.forEach(System.out::println);// 遍历 打印
}
}
flatMap(Function mapper)
mapper：接受一个参数，返回一结果。用于将参数类型按着给定的行为转为结果类型。但是接受的参数是T，返回的类型的Stream。也就是说：将T类型转为Stream流。比如我可以将List、数组、字符串等转为一个单独的流。
含义：返回一个新的流，新流中的元素是旧流中的元素mapper之后的流。也就是新流的初始元素是流，至于开发者对流如何操作，那么结果就会不同。 见名知意--->扁平转换,将旧流中的元素构造出子流(开发者编写)，子流汇总成总流(JDK完成)
属性：返回一个流，因此就是中间操作。
实例：将集合中的单词拆开输出
public class StreamTest {
public static void main(String[] args) {
List<String> stringList = Arrays.asList("Hello", "Java");
//目标：将集合中的单词拆开输出
//匿名类
stringList.stream()
.flatMap(new Function<String, Stream<?>>() {
@Override
public Stream<?> apply(String s) {//第一处
return Arrays.stream(s.split(""));//第二处
}
})
.forEach(System.out::println);
//flatMap是一个中间操作，会产生一个流（总流），总流是由第二处的子流汇聚而成。
//就是说 flatMap是一个汇总的流。至于是由什么子流汇总的，就需要开发者再第二处定义出来
//上面的例子分析
//单词有字符组成，用单词构成数组子流，然后数组子流汇总成总流
//第一处的参数s 就是我们旧流中的元素，这里是Hello Java字符串
//第二处，我们就需要根据字符串生成数组子流。
//为什么不用字符数组呢，因为Stream的静态方法不支持
//lambda表达式
stringList.stream()
.flatMap(it->Arrays.stream(it.split("")))
.forEach(System.out::println);
}
}
distinct()
无参
含义：返回一个新的流，流中的元素是旧流中元素去重复的结果，元素相等的条件是equals方法。 见名知意--->去重
属性：返回一个流，因此就是中间操作。
实例：数字集合去重后打印
public class StreamTest {
public static void main(String[] args) {
Arrays.asList(1,2,3,4,1,1)
.stream()
.distinct()
.forEach(System.out::println);
}
}
sorted()
无参
含义：返回一个新的流，流中的元素是旧流中元素自然排序的结果。 见名知意--->排序
属性：返回一个流，因此就是中间操作。
实例：数字集合排序后打印
public class StreamTest {
public static void main(String[] args) {
Arrays.asList(1,2,3,4,1,1)
.stream()
.sorted()
.forEach(System.out::println);
}
}
peek(Consumer action)
action：接受一个参数，不返回结果。用于将参数执行一个处理
含义：返回一个新的流，流中的元素不变。见名知意--->瞥
属性：返回一个流，因此就是中间操作。
实例：
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 1, 1);
integerList.stream()
.peek(it -> {//第一处
it += 1;
System.out.println(it);
System.out.println("-");
}).forEach(System.out::println);
//peek只是对元素执行个处理，并不影响顶层源，也不影响新生成的流的元素。
//也就是瞥一下，执行一个方法内的处理
}
}
上述的执行的结果
2
-
1
3
-
2
4
-
3
第一个元素为例
第一个是1，首先加1就是第一行的1，然后打印-，接着打印新生成的流的元素，打印的还是1。
综上，peek不影响新生成的流元素，这就是和map的区别。
limit(long maxSize)
maxSize：最大长度
含义：返回一个新的流，流中元素的个数小于等于maxSize。如果旧流的元素大于等于maxSize，新的流就取前maxSize个。如果旧流元素个数小于maxSize，新流元素就是所有的元素。见名知意--->限制个数
属性：返回一个流，因此就是中间操作。
实例：取集合前两个元素
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(1, 2, 3,3,4);
integerList.stream()
.limit(2)
.forEach(System.out::println);
}
}
skip(long n)
n：个数
含义：返回一个新的流，流中元素跳过了旧流中的前n个元素。见名知意--->跳过n个元素
属性：返回一个流，因此就是中间操作。
实例：跳过集合前两个元素遍历
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(1, 2, 3,3,4);
integerList.stream()
.skip(2)
.forEach(System.out::println);
}
}
forEach(Consumer action)
action：接受一个参数，不返回结果的行为
含义：对流中的每一个元素，执行action。见名知意--->遍历执行
属性：不返回流，因此就是终止操作（及早求值）
实例：集合遍历等等
Object[] toArray()
无参
含义：根据流中元素生成一个数组。见名知意--->生成数组
属性：不返回流，因此就是终止操作（及早求值）
实例：
T reduce(T identity, BinaryOperator<T> accumulator)
identity：初始值
accumulator：升级版的BiFunction,接受两个参数，生成一个结果，其中参数类型和结果类型相同。
含义：将流中元素聚合成一个结果，聚合的初始值就是identity，聚合的函数就是accumulator。见名知意--->聚合
属性：不返回流，因此就是终止操作（及早求值）
实例：求数字集合的总和
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(1, 2, 3, 3, 4);
//匿名类的方式
integerList.stream()
.reduce(0, new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) {
return integer + integer2;//第一处
}
});
//identity是初始值 BinaryOperator是聚合函数:用什么方式去聚合
//第一处的两个参数的含义
//integer 是上次计算的结果（第一次执行的时候改值是初始值） integer2是流中的元素
//Lambda表达式
integerList.stream()
.reduce(0, (left, right) -> left + right);
//常见的求和、最值、均值、字符串拼接都是聚合操作
//他还可以支持并行的计算
}
}
R collect(Supplier<R> supplier,
BiConsumer<R,T>accumulator,
BiConsumer<R, R>combiner)
supplier：不接受参数，返回一个结果
accumulator：接受两个参数，无返回值
combiner：接受一个两个参数，无返回值
泛型：R就是返回的类型，T就是流中元素的类型
含义：将流中元素收集成一个结果，结果就是supplier返回值，收集的方式就是accumulator和combiner(并行流时起作用)。见名知意--->收集
属性：不返回流，因此就是终止操作（及早求值）
实例：将集合中的String拼接
public class StreamTest {
public static void main(String[] args) {
List<String> stringList = Arrays.asList("Hello", " Java", ",", " I", " am", " fine");
//Lambda
stringList.stream()
.collect(() -> new StringBuilder(),//第一处
(builder, it) -> builder.append(it),//第二处
(left, right) -> left.append(right))
.toString();//第三处
//第一处 提供返回的结果 StringBuilder() 无参构造方法
//第二处 提供收集的方式 append元素
//第三处 并行时才有用，用于将多线程执行的结果汇总拼接
//方法引用
stringList.stream()
.collect(StringBuilder::new, //无参
StringBuilder::append, //调用者时lambda的第一个参数，参数是第一个参数之后的参数
StringBuilder::append) //同上
.toString();
// R result = supplier.get(); 返回的结果
// for (T element : this stream)
// accumulator.accept(result, element);//收集的行为
// return result;
}
}
boolean anyMatch(Predicate predicate)
predicate：接受一个参数，返回一个boolean值
含义：判断流中是否存在满足predicate的条件的元素。见名知意--->有一个满足就返回true
属性：不返回流，因此就是终止操作（及早求值）
实例：判断集合元素是否存在奇元素
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(2, 3, 4, 6, 8, 10);
boolean match = integerList.stream()
.anyMatch(it -> it % 2 != 0);
System.out.println(match);
//返回ture
}
}
Optional<T> findFirst()
无参
含义：返回流中的第一个元素，需要配合Optional使用。见名知意--->找到第一个元素
属性：不返回流，因此就是终止操作（及早求值）
实例：找到集合中的第一个元素
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(2, 3, 4, 6, 8, 10);
integerList.stream()
.findFirst()
.ifPresent(System.out::println);
//返回的类型是Optional
//Optional是值的封装，用于避免空指针异常
//ifPresent 用于判断值是否存在
}
}
concat(Stream a, Stream b)
该方法是静态方法，用于创建流，参数是两个流对象
含义：返回一个新的流，新的流是a和b的拼接，需要a和b的类型一致。见名知意--->拼接
属性：返回一个流
实例：将两个集合拼接
public class StreamTest {
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(2, 3, 4, 6, 8, 10);
List<Integer> integerList1 = Arrays.asList(11, 12, 13, 14, 15, 16);
Stream.concat(integerList.stream(), integerList1.stream())
.forEach(System.out::println);
}
}
iterate(final T seed, final UnaryOperator f)
该方法是静态方法，用于创建流
seed产生流的种子
UnaryOperator的类型是接受一个参数，返回一个结果
含义：根据seed和f生成一个流，流的生成是这样的第一个是seed，第二个是f(seed),第三个是f(f(seed))以此类推。见名知意--->重演，流中的元素是无限产生的
属性：返回一个流，需要配合limit使用
实例：按着一定规则创建流
public class StreamTest {
public static void main(String[] args) {
Stream.iterate(2, it -> it + 2)
.limit(6)
.forEach(System.out::println);
}
}
