stream流的用法，超全
1、循环/遍历list或map
循环 List 或 Map 可以使用 Java的 for 循环、增强 for 循环、迭代器和 Stream 流等方式。
for 循环
对于 List，可以使用经典的 for 循环来遍历：
List list = Arrays.asList("A", "B", "C");
for (int i = 0; i list.size(); i++) {
System.out.println(list.get(i));
}
对于 Map，可以先获取 key 集合，再使用 for 循环遍历：
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
for (String key : map.keySet()) {
System.out.println(key + ":" + map.get(key));
}
增强 for 循环
增强的 for 循环可以用于遍历所有实现了 Iterable 接口的集合类，比如 List、Set 和数组等。它可以简化代码，代码清晰度也会更高。
对于 List，可以使用以下方式：
List list = Arrays.asList("A", "B", "C");
for (String item : list) {
System.out.println(item);
}
对于 Map，可以使用以下方式：
<String, Integer> map = new HashMap<String, Integer>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
int value = entry.getValue();
System.out.println(key + ":" + value);
}
迭代器
迭代器可以用于遍历所有实现了 Iterable 接口的集合类，比如 List、Set 和数组等。它提供了 hasNext() 和 next() 两个方法，使得我们可以逐个访问集合中的元素。
对于 List，可以使用以下方式：
List list = Arrays.asList("A", "B", "C");
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
对于 Map，可以使用以下方式：
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Integer> entry = it.next();
String key = entry.getKey();
int value = entry.getValue();
System.out.println(key + ":" + value);
}
Stream 流中间方法
使用 Stream 流可以非常方便地对 List 和 Map 进行遍历和处理，具体可参考前面的 Stream 流循环示例。
无论使用哪种方式循环 List 或 Map，都需要注意避免在循环过程中对集合进行修改，可能会引发并发修改异常。同时，也要注意代码的可读性和性能，选择适合的方式。
使用 Stream 流可以非常方便地对 List 和 Map 进行遍历和处理。
- 遍历 List
我们可以使用 Stream 的 forEach() 方法来对 List 进行遍历：
// List list = new ArrayList<>();
// Collections.addAll(list,"A","B","C");
List<String> list = Arrays.asList("A","B","C");
list.stream().forEach(s -> System.out.println(s));
2.遍历 Map
对于 Map，我们可以使用 Stream 的 forEach() 方法或者 forEachEntry() 方法来对其进行遍历：
Map map = new HashMap();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
// 遍历 key-value 对
map.entrySet().stream().forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
// 遍历 key
map.keySet().stream().forEach(e -> System.out.println(e));
// 遍历 value
map.values().stream().forEach(e -> System.out.println(e));
除此之外，Stream 还有很多操作符，如 filter、map、reduce 等，可以方便地对集合中的元素进行处理和计算。例如：
List list = Arrays.asList(1, 2, 3, 4, 5);
// 对集合中的元素进行操作
list.stream().filter(e -> e % 2 == 0).forEach(e -> System.out.println(e));
// 对集合中的元素进行计算
int sum = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);
这样，我们就可以使用 Stream 流非常方便地遍历和操作集合了。
stream流中间方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AGuhAP24-1683621829941)(2bccbe6b5dbb084763c0f0d7246a1dbf.png)]
ArrayList<String> list = new ArrayList<>();
list.add("黄云兴");
list.add("黄飞鸿");
list.add("张三丰");
list.add("张无忌");
list.add("奥特曼");
list.stream().filter(name->name.startsWith("黄"))
.filter(name->name.length() == 3)
.forEach(name-> System.out.println(name));
System.out.println("--------------------------");
list.stream()
.limit(4)
.skip(2)
.forEach(name-> System.out.println(name));
System.out.println("--------------------------");
Long count= list.stream().count();
System.out.println(count);
System.out.println("--------------------------");
String[] arr = list.stream().toArray(value -> (new String[value]));
System.out.println(Arrays.toString(arr));
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"a-1","b-5","d-6","e-88","s-99","s-585");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"tt","yy");
list1.stream()
.distinct()
.forEach(name-> System.out.println(name));
System.out.println("========================");
Stream.concat(list1.stream(),list2.stream())
.forEach(s-> System.out.println(s));
System.out.println("====================");
list1.stream()
.map(s -> Integer.parseInt(s.split("-")[1]))//split()切割
.forEach(s-> System.out.println(s));
stream流终结方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M2R17qA6-1683621829943)(f988aa6d0ab0d68b0078f4b9268e1b04.png)]
ArrayList<Integer> arrayList = new ArrayList<>();
Collections.addAll(arrayList,1,2,2,3,4,5,6,7,8,9);
//void forEach()
arrayList.stream().forEach(s-> System.out.println(s));
System.out.println("======================");
//collect(Collector collector)收集流中的数据（List Set Map）
List<Integer> list = arrayList.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(list);
System.out.println("list======================");
Set<Integer> collect = arrayList.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toSet());
System.out.println(collect);
System.out.println("set======================");
//long count()
long count = arrayList.stream().count();
System.out.println(count);
System.out.println("======================");
//toArray()
Integer[] arr= arrayList.stream().toArray(value -> new Integer[value]);
System.out.println(Arrays.toString(arr));
ArrayList<String> arrayList = new ArrayList<>();
Collections.addAll(arrayList,"ss,25","aa,22","dd,99");
Map<String,Integer> map = arrayList.stream()
.filter(s->Integer.parseInt(s.split(",")[1])>=24)
.collect(Collectors.toMap(
s -> s.split(",")[0],
s->Integer.parseInt(s.split(",")[1])));
System.out.println(map);
System.out.println("======================");
String[] array = arrayList.stream().toArray(value ->new String[value]);
System.out.println(Arrays.toString(array));
收集到list集合和收集到set集合有什么区别？
收集到list集合没有去重效果，而收集到set集合有去重效果# 1、循环/遍历list或map
循环 List 或 Map 可以使用 Java的 for 循环、增强 for 循环、迭代器和 Stream 流等方式。
for 循环
对于 List，可以使用经典的 for 循环来遍历：
List list = Arrays.asList("A", "B", "C");
for (int i = 0; i list.size(); i++) {
System.out.println(list.get(i));
}
对于 Map，可以先获取 key 集合，再使用 for 循环遍历：
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
for (String key : map.keySet()) {
System.out.println(key + ":" + map.get(key));
}
增强 for 循环
增强的 for 循环可以用于遍历所有实现了 Iterable 接口的集合类，比如 List、Set 和数组等。它可以简化代码，代码清晰度也会更高。
对于 List，可以使用以下方式：
List list = Arrays.asList("A", "B", "C");
for (String item : list) {
System.out.println(item);
}
对于 Map，可以使用以下方式：
<String, Integer> map = new HashMap<String, Integer>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
int value = entry.getValue();
System.out.println(key + ":" + value);
}
迭代器
迭代器可以用于遍历所有实现了 Iterable 接口的集合类，比如 List、Set 和数组等。它提供了 hasNext() 和 next() 两个方法，使得我们可以逐个访问集合中的元素。
对于 List，可以使用以下方式：
List list = Arrays.asList("A", "B", "C");
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
对于 Map，可以使用以下方式：
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Integer> entry = it.next();
String key = entry.getKey();
int value = entry.getValue();
System.out.println(key + ":" + value);
}
Stream 流中间方法
使用 Stream 流可以非常方便地对 List 和 Map 进行遍历和处理，具体可参考前面的 Stream 流循环示例。
无论使用哪种方式循环 List 或 Map，都需要注意避免在循环过程中对集合进行修改，可能会引发并发修改异常。同时，也要注意代码的可读性和性能，选择适合的方式。
使用 Stream 流可以非常方便地对 List 和 Map 进行遍历和处理。
- 遍历 List
我们可以使用 Stream 的 forEach() 方法来对 List 进行遍历：
// List list = new ArrayList<>();
// Collections.addAll(list,"A","B","C");
List<String> list = Arrays.asList("A","B","C");
list.stream().forEach(s -> System.out.println(s));
2.遍历 Map
对于 Map，我们可以使用 Stream 的 forEach() 方法或者 forEachEntry() 方法来对其进行遍历：
Map map = new HashMap();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
// 遍历 key-value 对
map.entrySet().stream().forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
// 遍历 key
map.keySet().stream().forEach(e -> System.out.println(e));
// 遍历 value
map.values().stream().forEach(e -> System.out.println(e));
除此之外，Stream 还有很多操作符，如 filter、map、reduce 等，可以方便地对集合中的元素进行处理和计算。例如：
List list = Arrays.asList(1, 2, 3, 4, 5);
// 对集合中的元素进行操作
list.stream().filter(e -> e % 2 == 0).forEach(e -> System.out.println(e));
// 对集合中的元素进行计算
int sum = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);
这样，我们就可以使用 Stream 流非常方便地遍历和操作集合了。
stream流中间方法
ArrayList<String> list = new ArrayList<>();
list.add("黄云兴");
list.add("黄飞鸿");
list.add("张三丰");
list.add("张无忌");
list.add("奥特曼");
list.stream().filter(name->name.startsWith("黄"))
.filter(name->name.length() == 3)
.forEach(name-> System.out.println(name));
System.out.println("--------------------------");
list.stream()
.limit(4)
.skip(2)
.forEach(name-> System.out.println(name));
System.out.println("--------------------------");
Long count= list.stream().count();
System.out.println(count);
System.out.println("--------------------------");
String[] arr = list.stream().toArray(value -> (new String[value]));
System.out.println(Arrays.toString(arr));
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"a-1","b-5","d-6","e-88","s-99","s-585");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"tt","yy");
list1.stream()
.distinct()
.forEach(name-> System.out.println(name));
System.out.println("========================");
Stream.concat(list1.stream(),list2.stream())
.forEach(s-> System.out.println(s));
System.out.println("====================");
list1.stream()
.map(s -> Integer.parseInt(s.split("-")[1]))//split()切割
.forEach(s-> System.out.println(s));
stream流终结方法
ArrayList<Integer> arrayList = new ArrayList<>();
Collections.addAll(arrayList,1,2,2,3,4,5,6,7,8,9);
//void forEach()
arrayList.stream().forEach(s-> System.out.println(s));
System.out.println("======================");
//collect(Collector collector)收集流中的数据（List Set Map）
List<Integer> list = arrayList.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(list);
System.out.println("list======================");
Set<Integer> collect = arrayList.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toSet());
System.out.println(collect);
System.out.println("set======================");
//long count()
long count = arrayList.stream().count();
System.out.println(count);
System.out.println("======================");
//toArray()
Integer[] arr= arrayList.stream().toArray(value -> new Integer[value]);
System.out.println(Arrays.toString(arr));
A`在这里插入代码片`rrayList<String> arrayList = new ArrayList<>();
Collections.addAll(arrayList,"ss,25","aa,22","dd,99");
Map<String,Integer> map = arrayList.stream()
.filter(s->Integer.parseInt(s.split(",")[1])>=24)
.collect(Collectors.toMap(
s -> s.split(",")[0],
s->Integer.parseInt(s.split(",")[1])));
System.out.println(map);
System.out.println("======================");
String[] array = arrayList.stream().toArray(value ->new String[value]);
System.out.println(Arrays.toString(array));
收集到list集合和收集到set集合有什么区别？
收集到list集合没有去重效果，而收集到set集合有去重效果