Java之Stream流的基础讲解
Posted bfhonor
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java之Stream流的基础讲解相关的知识，希望对你有一定的参考价值。
一、Stream流
（一）体验
- 需求：按照下面的要求完成集合的创建和遍历
①、创建一个集合，存储多个字符串元素
②、把集合中所有以"张"开头的元素存储到一个新的集合
③、把"张"开头的集合中的长度为3的元素存储到一个新的集合
④、遍历上一步得到的集合
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("张敏");
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流进行改写
list.stream()
.filter(s -> s.startsWith("张"))
.filter(s -> s.length() == 3)
.forEach(s -> System.out.println(s));
}
}
- 使用Stream流的方式完成过滤操作
①、list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
②、直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。
③、Stream流把真正的函数式编程风格引入到Java中
（二）Stream流的思想和生成方式
1. Stream流的思想概述
2. Stream流的使用
- 生成流
通过数据源(集合,数组等)生成流
list.stream() - 中间操作
一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
filter() - 终结操作
一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
forEach
3. Stream流的思想和生成方式
- 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<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
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);
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);
}
}
（三）Stream流的常见中间操作方法
Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
①、Predicate接口中的方法boolean test(T t)：对给定的参数进行判断，返回一个布尔值
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("张敏");
list.add("张无忌");
//需求1：把list集合中以张开头的元素在控制台输出
list.stream().filter((String s) -> {
return s.startsWith("张");
}).forEach(System.out::println);
System.out.println("-----------");
//需求2：把list集合中长度为3的元素在控制台输出
list.stream().filter((String s) ->{
return 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);
}
}
运行结果：
张曼玉
张敏
张无忌
-----------
林青霞
张曼玉
王祖贤
张无忌
-----------
张曼玉
张无忌
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("张敏");
list.add("张无忌");
//需求1：取前3个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("----------");
//需求2：跳过3个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(System.out::println);
System.out.println("----------");
//需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
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("张敏");
list.add("张无忌");
//需求1：取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//需求2：跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//需求3：合并需求1和需求2得到的流，并把结构在控制台输出
//Stream.concat(s1,s2).forEach(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.*;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<>();
list.add("linqinxia");
list.add("zhangmanyu");
list.add("wangzuxian");
list.add("liuyan");
list.add("zhangmin");
list.add("zhangwuji");
//需求1：按照字母顺序把数据在控制台输出
list.stream().sorted().forEach(System.out::println);
//需求2：按照字符串长度把数据在控制台输出
list.stream().sorted((s1,s2) -> s1.length()-s2.length()).forEach(System.out::println);
//先按照长度排序,在当长度相同的时候,在按照字母排序
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);
//list.stream().map(Integer::parseInt).forEach(System.out::println);
//list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
//int sum()返回此流中元素的总和
int result = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(result);
}
}
（四）Stream流的常见终结操作方法
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("张敏");
list.add("张无忌");
//需求1：把集合中的元素在控制台输出
list.stream().forEach(System.out::println);
//需求2：统计集合中有几个以张开头的元素,并把统计结果在控制台输出
long count = list.stream().filter(s -> s.startsWith("张")).count();
System.out.println(count);
}
}
（五）Stream流的练习
- 现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
①、男演员只要名字为3个字的前三人
②、女演员只要姓林的，并且不要第一个
③、把过滤后的男演员姓名和女演员姓名合并到一起
④、把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
import java.util.*;
import java.util.stream.Stream;
class Actor{
private String name;
public <以上是关于Java之Stream流的基础讲解的主要内容，如果未能解决你的问题，请参考以下文章