1.1 体验Stream流
需求： 按照下面的要求完成集合的创建和遍历
- 创建一个集合，存储多个字符串元素
- 把集合中所有以“张”开头的元素存储到一个新的集合
- 把“张”开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合
使用Stream流的方式完成过滤操作
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
import java.util.ArrayList;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("张五");
list.add("张三三");
//把所有“张”开头的元素存储到一个新的集合
ArrayList<String> zhangList = new ArrayList<>();
for (String s :
list) {
if (s.startsWith("张")){
zhangList.add(s);
}
}
System.out.println(zhangList);
//把“张”开头的集合中的长度为3的元素存储到一个新的集合
ArrayList<String> threeList = new ArrayList<>();
for (String s :
zhangList) {
if (s.length()==3){
threeList.add(s);
}
}
System.out.println(threeList);
//遍历集合
for (String s :
threeList) {
System.out.println(s);
}
System.out.println("------------Stream流------------");
//Stream流改进
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
}
}1.2 Stream流的生成方式
Stream流的使用
- 生成流
- 通过数据源（集合，数组等）生成流
- list.stream()
- 中间操作
- 一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
- filter()
- 终结操作
- 一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
- forEach()
Stream流的常见生成方式
- Collection体系的集合可以使用默认的方法stream()生成流
- default Stream< E > stream()
- Map体系的集合间接的生成流
- 数组可以通过Stream接口的静态方法of(T… values)生成流
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
//Collection体系的集合可以使用默认方法stream()生成流
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 = {"hello","world","java"};
Stream<String> strArrayStream = Stream.of(strArray);
}
}1.3 Stream流常见的中间操作方法
- Stream< T > filter(Predicate predicate)：用于对流中的数据进行过滤
- Predicate接口中的方法：
- boolean test(T t)：对给定的参数进行判断，返回一个布尔值
- Stream< T > limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
- Stream< T > skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
import java.util.*;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五五");
list.add("张五");
list.add("张三三");
//Stream< T > filter(Predicate predicate)：用于对流中的数据进行过滤
//需求1：把list集合中以张开头的元素在控制台输出
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
System.out.println("---------------------------");
//需求2：把list集合中长度为3的元素在控制台输出
list.stream().filter(s -> s.length()==3).forEach(System.out::println);
System.out.println("---------------------------");
//需求3：把list集合中以张开头，长度为3的元素在控制台输出
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
System.out.println("=============================================");
//Stream< T > limit(long maxSize)：- 截取前指定参数个数的数据
//Stream< T > skip(long n)：返回由该流的剩余元素组成的流
//需求1：取前三个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("---------------------------");
//需求2：跳过三个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(System.out::println);
System.out.println("---------------------------");
//需求3：跳过两个元素，把剩下的元素中前两个在控制台输出
list.stream().skip(2).limit(2).forEach(System.out::println);
}
}- static< T > Stream< T > concat(Stream a, Stream b)：合并a和b两个流为一个流
- Stream < T > distinct()：返回由该流的不同元素（底层根据Object.equals(Object)）组成的流
import java.util.*;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五五");
list.add("张五");
list.add("张三三");
//需求1：取前四个数据组成流
Stream<String> s1 = list.stream().limit(4);
//需求2：跳过两个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//需求3：合并需求1和需求2得到的流，并把结果在控制台输出
// Stream.concat(s1, s2).forEach(System.out::println);
System.out.println("----------------------");
//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(s1, s2).distinct().forEach(System.out::println);
}
}- Stream< T > sorted()：返回由此流的元素组成的流，根据自然顺序排序
- Stream< T > sorted(Comparator comparator)：返回由此流的元素组成的流，根据提供的Comparator进行排序
import java.util.*;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五五");
list.add("张五");
list.add("张三三");
//需求1：按照字母顺序把数据在控制台输出
list.stream().sorted().forEach(System.out::println);
System.out.println("---------------------");
//需求2：按照字符串长度把数据在控制台输出
list.stream().sorted((s1,s2)->{
int num = s1.length()-s2.length();
int num2 = num==0?s1.compareTo(s2):num;
return num2;
}).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)
import java.util.*;
public class StreamDemo {
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().mapToInt(s->Integer.parseInt(s)).forEach(System.out::println);
//int sum() 返回此流中元素的总和
int resut = list.stream().mapToInt(s -> Integer.parseInt(s)).sum();
System.out.println(resut);
}
}1.4 Stream流的常见终结操作方法
Stream流的常见zhongjie操作方法
- void forEach(Consumer action)：对此流的每个元素执行操作
- Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
- long count()：返回此流中的元素数
import java.util.*;
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五五");
list.add("张五");
list.add("张三三");
//需求1：把集合中的元素在控制台输出
list.stream().forEach(System.out::println);
//需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
long i = list.stream().filter(s -> s.startsWith("张")).count();
System.out.println("以张开头的元素有："+i+"个");
}
}1.5 Stream流的练习
现在有两个ArrayList集合，分别存储6名难以按原名称和6名女演员名称，要求完成如下操作
- 男演员只要名字为3个字的前三任
- 女演员只要姓张的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
- 演员类Actor已经提供，李明友一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
import java.util.*;
import java.util.stream.Stream;
public class StreamTest {
public static void main(String[] args) {
ArrayList<String> manList = new ArrayList<>();
manList.add("周润发");
manList.add("成龙");
manList.add("刘德华");
manList.add("吴京");
manList.add("周星驰");
manList.add("李连杰");
ArrayList<String> womanList = new ArrayList<>();
womanList.add("林心如");
womanList.add("张曼玉");
womanList.add("林青霞");
womanList.add("柳岩");
womanList.add("林志玲");
womanList.add("王祖贤");
//男演员只要名字三个字的前三人
Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
//女演员只要姓林的，并且不要第一个
Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
//把过滤后的男演员名和女演员名合并到一起
Stream<String> stream = Stream.concat(manStream, womanStream);
//把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数组
// stream.forEach(s -> {
// Actor actor = new Actor(s);
// System.out.println("符合条件的演员有"+actor.getName());
// });
stream.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 Collector toMap(Functioc keyMapper, Function valueMapper)：把元素收集到Map集合中
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTest {
public static void main(String[] args) {
//List集合
List<String> manList = new ArrayList<>();
manList.add("周润发");
manList.add("成龙");
manList.add("刘德华");
manList.add("吴京");
manList.add("周星驰");
manList.add("李连杰");
//需求：得到名字为三个字的流，收集到List集合中并遍历
manList.stream().filter(s -> s.length() == 3).collect(Collectors.toList()).forEach(System.out::println);
//Set集合
Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(40);
set.add(50);
set.add(60);
//需求：得到年龄大于25的流，收集到Set集合中并遍历
set.stream().filter(s -> s>25).collect(Collectors.toSet()).forEach(System.out::println);
//字符串数组
String[] strArray = {"周润发,10", "成龙,20", "刘德华,30", "吴京,40", "周星驰,50", "李连杰,60"};
//需求：得到字符串中数据大于20的流，收集到Map集合中并遍历
Map<String, Integer> map = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 30).collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
Set<String> keySet = map.keySet();
for (String s :
keySet) {
System.out.println(s+","+map.get(s));
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
