Stream流

Stream流

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库现有的弊端

流式思想概述

思路: 流式思想类似于工厂车间的“生产流水线”

特点: 只能使用一次,流是一次性的，就是流结束了

入门案例

//需求:
// * 创建一个集合，存储多个字符串元素
// * 把集合中所有以"张"开头的元素存储到一个新的集合
// * 把"张"开头的集合中的长度为3的元素存储到一个新的集合
// * 遍历上一步得到的集合


// 使用Stream流的方式,遍历集合,对集合中的数据进行过滤:

ArrayList<String> list = new ArrayList();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");

//集合获取stream流

filter过滤方法中的接口对集合中的每一个元素过滤出符合条件的 对过滤后的流再用流方法中的过滤 forEach中的接口对此流的每个元素执行打印操作
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(e -> System.out.println(e));
 

步骤

1.首先是获取Stream流，流中就是存的就是集合或数组中的数据

2.用流中的方法操作集合，Stream流中间操作方法，执行完此方法之后，Stream流依然可以继续执行其他流的操作。

流的终结方法和流的收集都可以结束流

3.使用流的终结方法结束流，执行完此方法之后，Stream流将不能再执行其他操作。

4.Stream流的收集操作，可以直接把流收集到集合中

1.首先是获取Stream流，流中就是存的就是集合或数组中的数据

获取stream流的三种形式

1.List和Set集合
2.Map集合
3.数组

//1.List和Set集合
//获取List集合的stream
ArrayList<Object> list = new ArrayList<>();
Stream<Object> listStream = list.stream();

//获取Set集合的stream
HashSet<Object> set = new HashSet<>();
Stream<Object> setStream = set.stream();

//2.Map集合
//获取Map集合的stream
//Map中没有相关的方法直接获取Stream，1.可以间接的通过keySet获取set集合进行获取
//2.也可以通过entrySet获取的键值对的set集合进行获取
HashMap<Object, Object> map = new HashMap<>();
Set<Object> ketSet = map.keySet();
Stream<Object> stream = ketSet.stream();
Set<Map.Entry<Object, Object>> entrySet = map.entrySet();

//3.数组
//Stream中有一些静态方法可以将数组转换成Stream
String[] strings={"a","b"};
Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<String> strings1 = Stream.of(strings);
Stream<String> stream1 = Arrays.stream(strings);

//要用基本类型的包装类
Integer[] inte={1,2,3};
Stream<Integer> integerStream = Stream.of(1, 2, 3);
Stream<Integer> integerStream1 = Stream.of(inte);
Stream<Integer> stream2 = Arrays.stream(inte);

2.用流中的方法操作集合，Stream流只能消费一次，结束了不能用

常见方法

方法名	说明
Stream<T> filter(Predicate predicate)	用于对流中的数据进行过滤， 筛选出符合条件的元素
Stream<T> limit(long maxSize)	limit方法可以对流进行截取，只取用前n个，参数是一个long型。如果传入的参数, 大于集合的长度, 那么返回的结果, 将会是集合中所有的数据。如果传入的是一个负数的参数, 那么会出现异常.
Stream<T> skip(long n)	如果希望跳过前几个元素，可以使用 skip 方法获取一个跳过之后的新流，返回由该流的剩余元素组成的流。如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流
static <T> Stream<T> concat(Stream a, Stream b)	Stream.concat() : 静态方法, 将两个流, 合并为一个流.
Stream<T> distinct()	返回由该流的不同元素 去除流中的重复的元素（根据Object.equals(Object) ）组成的流
Stream<T> sorted() Stream<T> sorted(Comparator comparator)	返回由此流的元素组成的流，根据自然顺序排序 还可以用sorted(Comparator comparator)方法: 根据提供的Comparator进行排序
<R> Stream<R> map(Function mapper)	返回由给定函数应用于此流的元素的结果组成的流 map映射方法(转换型方法)：需要将流中的元素映射到另一个流中，可以使用 map 方法
IntStream mapToInt(ToIntFunction mapper)	返回一个IntStream其中包含将给定函数应用于此流的元素的结果

filter方法演示 筛选出符合条件的元素

ArrayList<String> list = new ArrayList();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");

//获取流
Stream<String> stream = list.stream();

//需求1：把list集合中以张开头的元素在控制台输出
Stream<String> stream1 = stream.filter(s -> s.startsWith("张"));
//需求2：把list集合中长度为3的元素在控制台输出
Stream<String> stream2 = stream1.filter(s -> s.length() == 3);
//需求3：把list集合中以张开头的，长度为3的元素在控制台输出

forEach方法是属于终结操作的方法，也就是说这个流到此就不能用了
stream2.forEach(s -> System.out.println(s));

limit截取方法、skip跳过方法

ArrayList<String> list = new ArrayList();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");


//需求1：取前3个数据在控制台输出
list.stream().limit(3L).forEach(s -> System.out.println(s));
//需求2：跳过3个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(s -> System.out.println(s));
//需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));

concat合并、distinct去重方法

ArrayList<String> list = new ArrayList();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");


//需求1：取前4个数据组成一个流
Stream<String> limit = list.stream().limit(4);
//需求2：跳过2个数据组成一个流
Stream<String> skip = list.stream().skip(2);

//需求3：合并需求1和需求2得到的流，并把结果在控制台输出
Stream<String> concat = Stream.concat(limit, skip);
//concat.forEach(t-> System.out.println(t)); 需要把这个注释掉才能演示下面的

//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
concat.distinct().forEach(t-> System.out.println(t));

sorted自然顺序排序方法

ArrayList<String> list = new ArrayList();
list.add("linqingxia");
list.add("zhangmanyu");
list.add("wangzuxian");
list.add("liuyan");
list.add("zhangmin");
list.add("zhangwuji");

//需求1：按照字母顺序把数据在控制台输出
list.stream().sorted().forEach(s -> System.out.println(s));

map转换型方法

ArrayList<String> list = new ArrayList();

list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");

// 需求：将集合中的字符串数据转换为整数之后在控制台输出,这个打印出来也不知道是不是Integer类型
list.stream().map(s -> { return Integer.parseInt(s);}).forEach(s-> System.out.println(s));

//int sum() 返回此流中元素的总和
IntStream intStream =
list.stream().mapToInt(s -> {return Integer.parseInt(s);});
//IntStream中有求和的方法
int sum = intStream.sum();
System.out.println(sum); //150

来一个综合案例

//案例需求
//现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作

ArrayList<String> manList = new ArrayList<String>();
manList.add("周润发");
manList.add("成龙");
manList.add("刘德华");
manList.add("吴京");
manList.add("周星驰");
manList.add("李连杰");


ArrayList<String> womanList = new ArrayList<String>();
womanList.add("林心如");
womanList.add("张曼玉");
womanList.add("林青霞");
womanList.add("柳岩");
womanList.add("林志玲");
womanList.add("王祖贤");

//1.男演员只要名字为3个字的前三人
Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
//2.女演员只要姓林的，并且不要第一个
Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
//3.把过滤后的男演员姓名和女演员姓名合并到一起
Stream<String> concatStream = Stream.concat(manStream, womanStream);
//4.把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
//将字符串姓名-->封装为Actor对象
concatStream.map(s->new Actor(s)).forEach(a-> System.out.println(a));
//Actor{name='周润发'}
//Actor{name='刘德华'}
//Actor{name='周星驰'}
//Actor{name='林青霞'}
//Actor{name='林志玲'}

Actor类

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;
}

@Override
public String toString() {
return "Actor{" +
"name='" + name + '\'' +
'}';
}

3.使用流的终结方法结束流，执行完此方法之后，Stream流将不能再执行其他操作。

相关方法

方法名	说明
void forEach(Consumer action)	对此流的每个元素逐一操作的方法
long count()	返回此流中的元素数

forEach 上面的打印用的都是foreach

就不再演示了

区分:

当前的forEach是一个方法, 并不是增强for循环，依赖于的是函数式接口

增强for, 依赖的是迭代器.

count返回此流中的元素数

ArrayList<String> list = new ArrayList();

list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");

long count = list.stream().count();
System.out.println(count);//5

4.对数据使用Stream流的方式操作完毕后，可以直接把流收集到集合中

因为流不保存数据，而且是一次性的，收集是一个持久化保存的操作

常用方法

方法名	说明
R collect(Collector collector)	把结果收集到集合中

工具类Collectors提供了具体的收集方式

方法名	说明
public static <T> Collector toList()	把元素收集到List集合中
public static <T> Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

//创建List集合对象
List<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");

//需求1：得到名字为3个字的流
Stream<String> nameStream = list.stream().filter(name -> name.length() == 3);
//需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
List<String> nameList = nameStream.collect(Collectors.toList());
for (String s : nameList) {
System.out.println(s);
}

System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

//创建Set集合对象
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(20);
set.add(30);
set.add(33);
set.add(35);

// 需求3：得到年龄大于25的流
Stream<Integer> ageStream = set.stream().filter(age -> age > 25);
// 需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
Set<Integer> ageSet = ageStream.collect(Collectors.toSet());
for (Integer integer : ageSet) {
System.out.println(integer);
}

System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

//定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};

//需求5：得到字符串中年龄数据大于28的流
Stream<String> ageArrayStream = Arrays.stream(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
//需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
Map<String, Integer> map = ageArrayStream.collect(Collectors.toMap(
s -> s.split(",")[0],
a -> Integer.parseInt(a.split(",")[1])));
System.out.println(map);