目录
Stream流的操作过程：
1.Stream流的生成方式
1.Collection体系的集合可以根据使用默认方法stream()生成流
例如：list.stream()
2.Map体系的集合间接生成流
例如：
keySet().stream()
values().stream()
entrySet().stream()
3.数组可以通过Stream的接口的静态方法of(T...values)生成流
例如：
Stream.of(strArray)
Stream.of(10,20,30)
代码演示：
//Collection体系的集合可以根据使用默认方法stream()生成流
ArrayList<String> list = new ArrayList<>();
Stream<String> listStream = list.stream();
HashSet<String> set = new HashSet<>();
Stream<String> setStream = set.stream();
//Map体系的集合间接生成流
HashMap<String,Integer> map = new HashMap<String,Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
//数组可以通过Stream的接口的静态方法of(T...values)生成流
String[]strArray = {"helllo","world","java"};
Stream<String> strArrayStream1 = Stream.of(strArray);
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream.of(10,20,30);
2.Stream流的中间操作
1.Stream<T> filter(Predicate predicate):用于对数据的过滤
Predicate接口中的方法boolean test(T t):对给定参数进行判断，返回布尔值
2.Stream<T> limit(long maxSize) : 返回此流中的元素组成的流，截取前指定参数的数据
3.Stream<T> skip(long n) : 跳过指定参数的数据，返回由该流的剩余元素组成的流
代码演示：
ArrayList<String> list = new ArrayList<>();
list.add("小王");
list.add("小张");
list.add("小李子");
list.add("老赵");
//对数据进行过滤
list.stream().filter(s -> s.startsWith("小")).filter(s -> s.length() == 3).forEach(System.out::println);
//取前几个
list.stream().limit(3).forEach(System.out::println);
System.out.println("---------");
//跳过前某个数据
list.stream().skip(3).forEach(System.out::println);
System.out.println("---------");
list.stream().skip(1).limit(2).forEach(System.out::println);
System.out.println("---------");
4.static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)：创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
5.Stream<T> distinct()：(去重)返回由该流的不同元素（根据 Object.equals(Object) ）组成的流
代码演示：
ArrayList<String> list = new ArrayList<>();
list.add("小王");
list.add("小张");
list.add("小李");
list.add("小赵");
//取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//合并前面两个得到的流，并在控制台输出
// Stream.concat(s1, s2).forEach(System.out::println);
//合并前两个得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(System.out::println);
6.Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序。
7.Stream<T> sorted(Comparator<? super T> comparator)：返回由该流的元素组成的流，根据提供的 Comparator进行排序。
代码演示：
ArrayList<String> list = new ArrayList<>();
list.add("wangzhiyi");
list.add("wangchongyang");
list.add("wangda");
list.add("shangyike");
list.add("zhangmanyu");
list.add("wangzuxian");
//按照字母顺序把数据在控制台输出
list.stream().sorted().forEach(System.out::println);
System.out.println("--------");
//按照字符串长度把数据在控制台输出
// list.stream().sorted((o1, o2) -> o1.length() - o2.length()).forEach(System.out::println);
list.stream().sorted((o1, o2) -> {
int num = o1.length() - o2.length();
int num2 = num == 0 ? o1.compareTo(o2):num;
return num2;
}).forEach(System.out::println);
8.<R> Stream<R> map(Function<? super T,? extends R> mapper)：返回由给定函数应用于此流的元素的结果组成的流。
9.IntStream mapToInt(ToIntFunction<? super T> mapper):返回一个 IntStream ，其中包含将给定函数应用于此流的元素的结果。
IntStream:int sum():返回此流中元素的总和。
代码演示：
ArrayList<String> list = new ArrayList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
//将集合中的字符串数据转换为整数后在控制台输出
list.stream().map(Integer::parseInt).forEach(System.out::println);
System.out.println("--------");
list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
// IntStream:int sum()
// 返回此流中元素的总和。
// int result = list.stream().mapToInt(Integer::parseInt).sum();
// System.out.println(result);
3.Stream流的终结操作
1.void forEach(Consumer<? super T> action)：对此流的每个元素执行操作。
2.long count()：返回此流中的元素数。
代码演示：
ArrayList<String> list = new ArrayList<>();
list.add("小王");
list.add("大王");
list.add("小张");
list.add("小李子");
//把集合中的元素在控制台输出
list.stream().forEach(System.out::println);
//统计集合中有几个以王开头的元素，并把统计结果在控制台输出
long num = list.stream().filter(s -> s.startsWith("王")).count();
System.out.println(num);4.补充：
将Stream流中的数据加载到集合
<R,A> R collect(Collector<? super T,A,R> collector)
使用 Collector对此流的元素执行 mutable reduction Collector 。
static <T> Collector<T,?,List<T>> toList()
返回一个 Collector ，它将输入元素 List到一个新的 List 。
static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
返回一个 Collector ，它将元素累加到一个 Map ，其键和值是将所提供的映射函数应用于输入元素的结果。
static <T> Collector<T,?,Set<T>> toSet()
返回一个 Collector ，将输入元素 Set到一个新的 Set 。
代码演示：
ArrayList<String> list = new ArrayList<>();
list.add("张曼玉");
list.add("林青霞");
list.add("柳岩");
list.add("王祖贤");
//得到名字为3个字的流
Stream<String> stringStream = list.stream().filter(s -> s.length() == 3);
//把使用Stream流操作完毕的数据收集到list集合中并遍历
List<String> list1 = stringStream.collect(Collectors.toList());
// for (String s : list1) {
// System.out.print(s + " ");
// }
//创建Set集合对象
HashSet<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(33);
set.add(35);
//得到年龄大于25的流
Stream<Integer> integerStream = set.stream().filter(s -> s > 25);
// System.out.println();
//把使用Stream流操作完毕的数据收集到Set集合中并遍历
Set<Integer> list2 = integerStream.collect(Collectors.toSet());
// for (int i : list2) {
// System.out.print(i + " ");
// }
//定义一个字符串数组，每一个字符串数据由姓名和年龄组合而成
String[]strArray = {"王志毅,20","王崇阳,26","尚艺柯,18","彭梦圆,15"};
//得到字符串中年龄大于20的流
Stream<String> mapStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 20);
//把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串作为键，年龄作为值
// static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
Map<String, String> list3 = mapStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> s.split(",")[1]));
for(String key:list3.keySet()){
System.out.println(key+","+list3.get(key));5.相关案例：
1.需求：
现在由两个ArrayList集合，分别储存6名男演员和6名女演员名称，完成如下操作：
1.男演员只要名字为3个字的前三个人
2.女演员只要姓林的，并且不要第一个
3.把过滤后的男演员姓名和女演员姓名合并到一起
4.把上一步操作后的元素作为构造方法的参数创建对象，遍历数据
2.代码实现：
import java.util.ArrayList;
import java.util.stream.Stream;
public class StreamTest {
public static void main(String[] args) {
ArrayList<String> manlist = new ArrayList<>();
ArrayList<String> womanlist = new ArrayList<>();
manlist.add("周润发");
manlist.add("成龙");
manlist.add("刘德华");
manlist.add("吴京");
manlist.add("周星驰");
manlist.add("李连杰");
womanlist.add("林心如");
womanlist.add("张曼玉");
womanlist.add("林青霞");
womanlist.add("柳岩");
womanlist.add("林志玲");
womanlist.add("王祖贤");
//男演员中名字为三个字的前三人
// Stream<String> man = manlist.stream().filter(s -> s.length() == 3).limit(3);
//
// //女演员中姓林的除去第一个
// Stream<String> woman = womanlist.stream().filter(s -> s.startsWith("林")).skip(1);
//
// //过滤后的男女演员
// Stream<String> concat = Stream.concat(man, woman);
// concat.map(Actor::new).forEach(p -> System.out.println(p.getName()));
Stream.concat(manlist.stream().filter(s -> s.length() == 3).limit(3)
, womanlist.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new)
.forEach(p -> System.out.println(p.getName()));
}
}演员类：
public class Actor {
private String name;
public Actor(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
3.运行结果：
总结：
以上内容属于自学，可能不是很全面，但为了方便日后的观看和复习，在此发文，如发现有错误请联系博主，欢迎指正。
3166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
