Stream流
Stream流
-
Stream流中过滤器的简单实例：
1
2
3
4
5
6
7
8
9
10
11public class StreamMain {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList();
arrayList.add("张无忌");
arrayList.add("赵敏");
arrayList.add("张三丰");
arrayList.add("周芷若");
arrayList.add("张强");
arrayList.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(System.out::println);
}
}-
filter方法就是一个过滤器，将需要的过滤的内容写在括号中
-
上述例子中，过滤器过滤掉了集合中以张开头字符串，然后在此基础上，再次过滤长度为3的字符串
-
流的获取
Stream流的思想
将需要的数据过滤出来；
Stream流的作用：
结合了Lambda表达式，简化集合，数组的操作
Stream流的使用步骤：
-
首先的到一条Stream流（流水线），将数据放入其中
获取方式 方法名 说明 单列集合 default Stream stream() Collection中默认方法 双列集合 无 需要将键或者值单独获取出来，然后进行操作 数组 public static Arrays工具类中的静态方法 一堆零散数据 public static Stream of (T…values) Stream接口中的静态方法 -
单列集合获取方式示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import java.util.ArrayList;
import java.util.stream.Stream;
public class StreamMain2 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("hello");
arrayList.add("world");
arrayList.add("你好");
arrayList.add("世界");
/*Stream流的基本获取方式*/
Stream<String> stream = arrayList.stream();
stream.forEach(string -> System.out.print(string + "\t"));
System.out.println();
/*Stream流的链式调用方式*/
arrayList.stream().forEach(name -> System.out.print(name + "\t"));
}
} -
双列集合获取方式：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public class StreamMain3 {
public static void main(String[] args) {
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("hello", 10);
hashMap.put("world", 20);
hashMap.put("你好世界", 30);
hashMap.put("have a nice day", 40);
/*获取集合中的所有键值对*/
Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
entries.stream().forEach(string -> System.out.print(string + "\t"));
System.out.println();
/*将集合中的值或者，键逐个获取出来*/
hashMap.keySet().stream().forEach(string -> System.out.print(string + "\t"));
System.out.println();
hashMap.values().stream().forEach(string -> System.out.print(string + "\t"));
}
} -
数组的获取方式
1
2
3
4
5
6public class StreamMain4 {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7};
Arrays.stream(array).forEach(string -> System.out.println(string));
}
} -
零散数据的获取方式
1
2
3
4
5public class StreamMain5 {
public static void main(String[] args) {
Stream.of("a", "b", "c").forEach(name -> System.out.println(name));
}
}
-
中间方法
-
使用中间方法对流水线上的数据进行操作
中间方法：过滤，转换
-
方法调用完毕后，还可以调用其他方法
名称 说明 Stream filter(Predicate<? super T> predicate) 过滤 Stream limit(long maxSize) 获取前几个元素 Stream skip(long n) 跳过前几个元素 static Stream Stream concat(Stream a , Stream b) 合并a和b两个流为一个流 Stream distinct() 元素去重，依赖（hashcode金额equals方法） Stream map 转换流中的数据类型 注：中间方法，返回新的Stream流，原来的Stream流只能一次，使用链式编程；修改Stream流中的数据不会影响集合或者原来集合或者数组中的数据
-
方法示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24public class StreamMain1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList();
arrayList.add("张无忌");
arrayList.add("赵敏");
arrayList.add("张三丰");
arrayList.add("周芷若");
arrayList.add("张强");
/*获取集合前三个元素*/
arrayList.stream().limit(3).forEach(name -> System.out.print(name + "\t"));
System.out.println();
/*跳过集合中的前两个元素*/
arrayList
.stream().skip(2).forEach(name -> System.out.print(name + "\t"));
System.out.println();
arrayList.stream().skip(2).limit(2).forEach(name -> System.out.print(name + "\t"));
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25public class StreamMain2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("hello-10");
list.add("world-20");
list.add("你好-30");
list.add("世界-40");
list.stream().map(new Function<String, Integer>() {
public Integer apply(String s) {
String[] array = s.split("-");
int ageString;
ageString = Integer.parseInt(array[1]);
return ageString;
}
}).forEach(string -> System.out.print(string + "\t"));
System.out.println();
System.out.println("======================================");
list.stream().map(s ->
Integer.parseInt(s.split("-")[1]))
.forEach(string -> System.out.print(string + "\t"));
}
}1
2
3
4
5
6
7
8
9
10
11public class StreamMain3 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
list1.add("hello");
list2.add("world");
list1.add("你好");
list2.add("世界");
Stream.concat(list1.stream(), list2.stream()).forEach(string -> System.out.print(string + "\t"));
}
}
-
终结方法
-
使用终结方法对流水线上的数据进行操作
-
终结方法：统计，打印
- 最后一步，调用完毕之后，不能调用其他方法
方法 说明 long count() 统计 void forEach(Consumer action) 遍历 toArray(） 收集流中的数据，放到数组当中 collect(Collector) 收集流中的数据，放到集合中 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class StreamMain4 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList();
arrayList.add("张无忌");
arrayList.add("赵敏");
arrayList.add("张三丰");
arrayList.add("周芷若");
arrayList.add("张强");
String[] strings = arrayList.stream().toArray(new IntFunction<String[]>() {
public String[] apply(int value) {
return new String[value];
}
});
System.out.println(Arrays.toString(strings));
}
}collect方法将数据收集到单列集合的应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class StreamMain5 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList();
arrayList.add("张无忌-男-18");
arrayList.add("赵敏-女-19");
arrayList.add("张三丰-男-50");
arrayList.add("周芷若-女-19");
arrayList.add("张强-男-20");
/*拉姆达表达式，切割字符串，将性别为男的过滤出来*/
List<String> strings = arrayList.stream().filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
for (String string : strings) {
System.out.println(string);
}
}
}collect方法将数据收集到双列集合的应用
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
33public class StreamMain5 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList();
arrayList.add("张无忌-男-18");
arrayList.add("赵敏-女-19");
arrayList.add("张三丰-男-50");
arrayList.add("周芷若-女-19");
arrayList.add("张强-男-20");
/*收集到Map集合*/
Map<String, Integer> map = arrayList.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors
/*转换中有两个Fuction方法，第一个是键的，
泛型中的第二个参数为键的类型，
第-个为流中的树类型*/
.toMap(new Function<String, String>() {
public String apply(String s) {
String[] array = s.split("-");
return array[0];
}
},
/*这里的Function方法为键的，第一个泛型参数为流中数据的类型
* 第二个为键值的类型*/
new Function<String, Integer>() {
public Integer apply(String s) {
String[] array = s.split("-");
return Integer.parseInt(array[2]);
}
}));
System.out.println(map);
}
}collect方法将数据收集到双列集合的应用，lambad表达式应用；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class StreamMain6 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList();
arrayList.add("张无忌-男-18");
arrayList.add("赵敏-女-19");
arrayList.add("张三丰-男-50");
arrayList.add("周芷若-女-19");
arrayList.add("张强-男-20");
/*收集到Map集合*/
Map<String, Integer> map = arrayList.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(s -> s.split("-")[0], s -> Integer.parseInt(s.split("-")[2])));
System.out.println(map);
}
} -
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 NING / MiRACLE！
