1.Stream流
1.1 体验Stream流
需求:按照下面的要求完成集合的创建和遍历
① 创建一个集合,存储多个字符串元素
② 把集合中所有以“R”开头的元素存储到一个新的集合
③ 把“R”开头的集合中的长度为6的元素存储到一个新的集合
④ 遍历上一步得到的集合
使用Stream流的方式完成过滤操作
array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6).forEach(System.out::println);
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:生成流、过滤R开头、过滤长度为6、逐一打印
Stream流把真正的函数式编程风格引入到Java中
public class StreamDemo1 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
array.add("Rarity");
array.add("TwilightSparkle");
array.add("RainbowDash");
array.add("FlutterShy");
array.add("AppleJack");
array.add("PinkiePie");
ArrayList<String> rList = new ArrayList<>();
for(String s : array){
if(s.startsWith("R")){
rList.add(s);
}
}
ArrayList<String> finallyList = new ArrayList<>();
for(String s : rList){
if(s.length() == 6 ){
finallyList.add(s);
}
}
for(String s : finallyList){
System.out.println(s);
}
System.out.println("--------");
//利用Stream流来进行改进
array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6).forEach(s -> System.out.println(s));
array.stream().filter(s -> s.startsWith("R")).filter(s -> s.length() == 6).forEach(System.out::println);
}
}
1.2 Stream流的生成方式
Stream流的使用
● 生成流
通过数据源(集合,数组等)生成流
list.stream()
● 中间操作
一个流后面可以跟随零个或多个中间操作,其目的主要是打开流,做出某种程度的数据过滤/映射,然后返回一个新的流,交给下一个操作使用
filter()
● 终结操作
一个流只能有一个终结操作,当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作
forEach()
Stream流的常见生成方式
● Collection体系的集合可以使用默认方法stream()生成流
default Stream< E> stream()
● Map体系的集合间接的生成流
● 数组可以通过Stream接口的静态方法of(T…values)生成流
public class generateStream {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<>();
Stream<String> setStream = set.stream();
//Map体系的集合间接的生成流
Map<String,Integer> map = new HashMap<>();
//键的生成流
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 = {"Rarity","TwilightSparkle","RainbowDash"};
Stream<String> strArrayStream = Stream.of(strArray);
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
}
}
1.3 Stream流的常见中间操作方法
● Stream< T> filter(Predicate predicate):用于对流中的数据进行过滤
Predicate接口中的方法 boolean test(T t):对给定的参数进行判断,返回一个布尔值
依赖于Predicate接口中的方法boolean test(T t)来对数据进行判断过滤
public class OperateStream {
public static void main(String[] args) {
ArrayList<String> list= new ArrayList<>();
list.add("Rarity");
list.add("TwilightSparkle");
list.add("RainbowDash");
list.add("PinkiePie");
list.add("AppleJack");
list.add("FlutterShy");
list.add("SunsetShimmer");
list.add("StarlightGlimmer");
list.add("Spike");
//需求1:把list集合中以S开头的元素在控制台输出
list.stream().filter(s -> s.startsWith("S")).forEach(s -> System.out.println(s));
System.out.println("---------");
//需求2:把list集合中长度为13的元素在控制台输出
list.stream().filter(s -> s.length() ==13).forEach(s -> System.out.println(s));
//需求3:把list集合中以S开头的,长度为13的元素在控制台输出
System.out.println("--------");
list.stream().filter(s -> s.length() == 13).filter(s -> s.startsWith("S")).forEach(System.out::println);
}
}
● Stream< T> limt(long maxSize):返回此流中的元素组成的流,截取前指定参数个数的数据
● Stream< T> skip(long n):跳过指定参数个数的数据,返回由该流的剩余元素组成的流
public class OperateStream2 {
public static void main(String[] args) {
ArrayList<String> list= new ArrayList<>();
list.add("Rarity");
list.add("TwilightSparkle");
list.add("RainbowDash");
list.add("PinkiePie");
list.add("AppleJack");
list.add("FlutterShy");
list.add("SunsetShimmer");
list.add("StarlightGlimmer");
list.add("Spike");
//需求1:取前3个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("--------");
//需求2:跳过3个元素,把剩下的元素在控制台输出
list.stream().skip(3).forEach(s -> System.out.println(s));
System.out.println("--------");
//需求3:跳过2个元素,把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(s -> System.out.println(s));
}
}
● static < T> Stream< T> concat(Stream a, Stream b):合并a和b两个流为一个流
● Stream< T> distinct():返回由该流的不同元素(根据Object.equals(Object))组成的流
//需求3:合并需求1和需求2得到的流,并把结果在控制台输出
// Stream.concat(stream1,stream2).forEach(System.out::println);
System.out.println("--------");
//需求4:合并需求1和需求2得到的流,并把结果在控制台输出,要求字符串元素不能重复
Stream.concat(stream1,stream2).distinct().forEach(s -> System.out.println(s));
● Stream< T> sorted():返回由此流的元素组成的流,根据自然顺序排序
● Stream< T> sorted(Comparator comparator):返回由该流的元素组成的流,根据提供的Comparator进行排序
public class OperateStream4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Rarity");
list.add("TwilightSparkle");
list.add("RainbowDash");
list.add("PinkiePie");
list.add("AppleJack");
list.add("FlutterShy");
list.add("SunsetShimmer");
list.add("StarlightGlimmer");
list.add("Spike");
list.stream().sorted().forEach(System.out::println);
System.out.println("--------");
list.stream().sorted((s1, s2) -> {
int num = s1.length() - s2.length();
int num1 = num == 0 ? s1.compareTo(s2) : num;
return num1;
}).forEach(System.out::println);
}
}
● < R> Stream< R> map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
Function接口中的方法 R apply(T t)
● IntStream mapToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果
IntStream:表示原始int流
ToIntFunction接口中的方法 int applyAsInt(T value)
public class OperateStream5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
//需求:将集合中的字符串数据转换为整数之后在控制台输出
list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
System.out.println("--------");
list.stream().map(Integer::parseInt).forEach(System.out::println);
System.out.println("--------");
list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//int sum() 是IntStream中特有的方法
int sum = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(sum);
}
}
1.4 Stream流的常见终结操作方法
Stream流的常见终结操作方法
● void forEach(Consumer action):对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t):对给定的参数执行此操作
● long count():返回此流中的元素数
//需求1:把集合中的元素在控制台输出
list.stream().forEach(s-> System.out.println(s));
//需求2:统计集合中有几个以R开头的元素,并把统计结果在控制台输出
long count = list.stream().filter(s -> s.startsWith("R")).count();
System.out.println(count);
1.5 Stream流的练习
现在有两个ArrayList集合,分别存储6名男演员名称和6名女演员名称,要求完成如下操作
● 男演员只要名字为3个字的前三人
● 女演员只要姓林的,并且不要第一个
● 把过滤后的男演员姓名和女演员姓名合并到一起
● 把上一步操作后的元素作为构造方法的参数创建演员对象啊,遍历数据
演员类Actor已经提供,里面有一个成员变量,一个带参构造方法,以及成员变量对应的get/set方法
public class StreamPractice {
public static void main(String[] args) {
ArrayList<String> manList = new ArrayList<String>();
manList.add("刘德华");
manList.add("吴彦祖");
manList.add("成龙");
manList.add("吴京");
manList.add("李连杰");
manList.add("周星驰");
ArrayList<String> womenList = new ArrayList<String>();
womenList.add("林志玲");
womenList.add("奥黛丽·赫本");
womenList.add("林青霞");
womenList.add("王祖贤");
womenList.add("张柏芝");
womenList.add("林心如");
/* //男演员只要名字为3个字的前三人
Stream<String> menStream = manList.stream().filter(s -> s.length() == 3).limit(3);
//女演员只要姓林的,并且不要第一个
Stream<String> womenStream = womenList.stream().filter(s -> s.startsWith("林")).skip(1);
//把过滤后的男演员姓名和女演员姓名合并到一起
Stream<String> actorStream = Stream.concat(menStream, womenStream);
//把上一步操作后的元素作为构造方法的参数创建演员对象啊,遍历数据
actorStream.map(Actor::new).forEach(p -> System.out.println(p.getName()));*/
Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3), womenList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).forEach(s->System.out.println(s.getName()));
}
}
1.6 Stream流的收集操作
对数据使用Stream流的方式操作完毕后,我想把流中的数据收集到集合中,该怎么办呢?
Stream流的收集方法
● R collect(Collector collector)
● 但是这个收集方法的参数是一个Collector接口
工具类Collectors提供了具体的收集方式
● public static <T> Collector toList()
:把元素收集到List集合中
● public static <T> Collector toSet()
:把元素收集到Set集合中
● public static Colletor toMap(Function keyMapper,Function valueMapper
:把元素收集到Map集合中