Java8新特性 Stream流式思想(三)
Stream接口中的常用方法
forEach()方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
* forEach方法练习
* void forEach(Consumer<? super T> action) 对此流的每个元素执行操作。
* 参数 ：
* Consumer 是一个函数式接口，会将每一个流元素交给该函数去处理；
* 它是一个消费型函数式接口，由于是一个函数是接口，所以可以使用Lambda表达式。
* 作用：
* 遍历数据。
* 注意：
* 它是一个终结方法，使用之后就不能再使用Stream流中的其他方法了，否则会抛出异常。
* */
public class Test01StreamForeach {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
list.add("田七");
list.add("王八");
// 1、先将list转换为Stream流
Stream<String> stream = list.stream();
// 2、使用Stream的forEach方法遍历集合
stream.forEach(s -> System.out.print(s + " "));// 输出结果 ：张三 李四 王五 赵六 田七 王八
// 3、如果在此使用该流会怎样？
stream.filter(s -> s.startsWith("张"));
// 将抛出这个异常 ： java.lang.IllegalStateException: stream has already been operated upon or closed
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
filter()方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.stream.Stream;
/*
* Stream的filter()方法的使用
* Stream<T> filter(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的元素组成的流。
* 参数 ：
* 该方法的参数接收的是一个函数式接口，所以可以使用Lambda表达式
* 作用：进行元素的过滤
*
* Stream流的特点 ：
1、属于管道流 只能被消费（使用）一次
2、第一个Stream 流调用完毕方法数据就会流转到下一个Stream流上 此时第一个 Stream 已经使用完毕就会关闭了
此时第一个stream流就不能调用方法类了
我们的stream流只能使用一次
* */
public class Test02StreamFilter {
public static void main(String[] args) {
// 创建一个流
Stream<String> streamA = Stream.of("张三", "李四", "王五", "赵六", "田七", "王八");
// 我只需要姓 “张”的 所以 调用 Stream流的方法 filter进行过滤
streamA.filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));// 输出结果 ：张三
// 注意
Stream<String> streamB = Stream.of("小明", "李华", "王二");
Stream<String> streamC = streamB.filter(s -> s.startsWith("李"));
// streamB.forEach(s-> System.out.println(s));//此时在使用之前的流会抛出异常 IllegalStateException
streamC.forEach(s -> System.out.println(s));// 输出结果 ：李华
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
map()方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.stream.Stream;
/*
* <R> Stream<R> map(Function<? super T,? extends R> mapper) 返回由给定函数应用于此流的元素的结果组成的流。
* 参数 ：
* 一个 函数式接口 Function ，可以将函数中T类型的数据类型转换为R类型的流
* 可以将一种类型转换为另一种类型，就叫映射。
* 作用：
* map 映射 ： 如果需要将流中的元素映射到另一个流中 ， 就使用map方法
* */
public class Test03StreamMap {
public static void main(String[] args) {
// 需求 ： 将字符串类型的整数转换为 Integer类型的整数
Stream<String> stringStream = Stream.of("1", "2", "1", "3");
Stream<Integer> integerStream = stringStream.map(s -> Integer.parseInt(s));
integerStream.forEach(s -> System.out.println(s));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
count()方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
* Stream流中的方法 long count() 返回此流中的元素数。
*
* 作用：
* 用于统计Stream流中元素的个数
* 注意：
* count方法是一个终结方法，使用完它之后就不能在使用 Stream流中的其他方法
*
* */
public class Test04StreamCount {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
list.add("田七");
list.add("王八");
Stream<String> streamList = list.stream();
// long count = streamList.count();
long count = streamList.count();//调用它之后就不能再调用流中的其他方法了
System.out.println(count);//6
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
limit()方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
* Stream 方法中的 Stream<T> limit(long maxSize) 返回由此流的元素组成的流，截短长度不能超过 maxSize 。
* 参数：
* 参数是一个long类型的数据 如果 集合的长度大于 参数的长度 则进行截取 否则不进行任何操作
* 作用：
* limit方法可以对 流中的元素进行截取 只取前n个
* */
public class Test06StreamLimit {
public static void main(String[] args) {
// 获取一个Stream流
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
list.add("田七");
Stream<String> stream = list.stream();
// 使用limit方法对stream流中的元素进行截取，只要前2个元素 并对流进行遍历
stream.limit(2).forEach(s-> System.out.println(s));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
skip()方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
* Stream 方法中的 Stream<T> skip(long n) 在丢弃流的第一个 n元素后，返回由该流的剩余元素组成的流。
* 参数 ：
* 是一个long类型的数据
* 作用：
* 如果希望跳过前n个元素就是用Stream的skip方法 获取一个截取之后的流
* 如果流的当前长度大于n，则跳过前n个否则的到一个长度为0的流。
* */
public class Test06StreamSkip {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("赵四");
list.add("王五");
list.add("赵六");
list.add("田七");
list.add("王八");
Stream<String> stream = list.stream();
stream.skip(3).forEach(s -> System.out.print(s + " "));//输出结果：赵六 田七 王八
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
concat方法
package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
/*
* Stream接口中的static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
* 创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
* 参数：
* 两个流
* 作用：
* 如果你有两个流，你希望合并为一个流，那么就可以使用Stream流的静态方法concat
* */
public class Test07StreamConcat {
public static void main(String[] args) {
List<String> listA = new ArrayList<>();
listA.add("张三");
listA.add("李四");
listA.add("王五");
listA.add("赵六");
listA.add("田七");
listA.add("王八");
List<String> listB = new ArrayList<>();
listB.add("小明");
listB.add("张强");
listB.add("李华");
Stream<String> streamA = listA.stream();
Stream<String> streamB = listB.stream();
Stream<String> concatAB = Stream.concat(streamA, streamB);
concatAB.forEach(s -> System.out.print(s + " "));//张三 李四 王五 赵六 田七 王八 小明 张强 李华
}
}
---------------------
