1、Stream流
java.util.stream.Stream是Java 8新加入的最常用的流接口（并不是一个函数式接口）
获取一个流非常简单，有以下几种常用的方式：
-所有的Collection集合都可以通过stream默认方法获取流；
default Stream stream( )
-Stream接口的静态方法可以获取数组对应的流。
static Stream of (T…values)
参数是一个可变参数，那么我们就可以传递一个数组
代码演示：
import java.util.*;
import java.util.stream.Stream;
public class Demo01Stream {
public static void main(String[] args) {
//把集合转换为Stream流
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream1 = set.stream();
Map<String,String> map = new HashMap<>();
//获取键，存储到一个Set集合中
Set<String> keySet = map.keySet();
Stream<String> stream2 = keySet.stream();
//获取值，存储到一个Collection集合中
Collection<String> values = map.values();
Stream<String> stream3 = values.stream();
//获取键值对(键与值的映射关系 entrySet)
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String, String>> stream4 = entries.stream();
//把数组转换为Stream流
Stream<Integer> stream5 = Stream.of(1, 2, 3, 4, 5);
//可变参数可以传递数组
Integer[] arr = {
1, 2, 3, 4, 5};
Stream<Integer> stream6 = Stream.of(arr);
String[] arr2 = {
"a", "b", "c"};
Stream<String> stream7 = Stream.of(arr2);
}
}
2、Stream流常用方法forEach
常用方法可以分为两种：
延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用(除了终结方法外，其余方法均为延迟方法。)
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。终结方法包括count和forEach方法等。
Stream流中的常用方法——forEach
void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式，消费数据
简单记：
forEach方法，用来遍历流中的数据，是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法。
forEach方法简单使用：
import java.util.stream.Stream;
public class Demo02StreamForEach {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "田七");
//使用Stream流中的方法forEach对Stream流中的数据进行遍历
stream.forEach((String name)->{
System.out.println(name); //张三 李四 王五 赵六 田七
});
}
}
3、Stream流常用方法filter
Stream流常用方法filter(过滤)可以将一个流转换成另一个子集流。
Stream filter(Predicate<? super T> predicate);
filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式对数据进行过滤
Predicate中的抽象方法：
boolean test(T t);
使用举例：
import java.util.stream.Stream;
public class Demo03StreamFilter {
public static void main(String[] args) {
//创建一个Stream流
Stream<String> stream = Stream.of("张三丰", "张伟", "李宇", "王雷");
Stream<String> stream1 = stream.filter((String name) -> {
return name.startsWith("张");
});
//遍历stream1流
stream1.forEach((name)-> System.out.println(name));
}
}
3、Stream流的特点——只能使用一次。
Stream流属于管道流，只能被消费(使用)一次
第一个Stream流调用完毕方法，数据就会流转到下一个Stream流上
而这时第一个Stream流已经使用完毕就会关闭了
所以第一个Stream流就不能再调用方法了。
4、Stream流的常用方法——map方法
如果需要将流中的元素映射到另一个流当中，可以使用map方法
Stream map(Faunction<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
Function中的抽象方法：
R apply(T t);
示例：
import java.util.stream.Stream;
public class Demo04StreamMap {
public static void main(String[] args) {
//获取一个String类型的Stream流
Stream<String> stream = Stream.of("2", "3", "5", "6");
Stream<Integer> stream1 = stream.map((String s) -> {
return Integer.parseInt(s);
});
stream1.forEach((s)->{
System.out.println(s);
});
}
}
5、Stream流常用方法——count
Stream流的常用方法count：用于统计Stream流中元素的个数
long count( );
count方法是一个终结方法，返回值是一个long类型的整数
所以不能再继续调用Stream流中的其他方法了。
示例：
import java.util.stream.Stream;
public class Demo05StreamCount {
public static void main(String[] args) {
Stream<String> stream = Stream.of("张三风", "张无忌", "王雷", "陈雷");
long count = stream.count();
System.out.println(count);
}
}
6、Stream流的常用方法——limit
Stream流中的常用方法limit：用于截取流中的元素
limit方法可以对流进行截取，只取用前n个。
方法签名：Stream limit(long maxSize);
参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作。
limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法。
示例：
import java.util.stream.Stream;
public class Demo06StreamLimit {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream = Stream.of("1", "3", "4", "6", "7", "8");
//使用limit方法对Stream流中的元素进行截取
Stream<String> stream1 = stream.limit(3);
stream1.forEach((String n)->{
System.out.println(n);
});
}
}
7、Stream流常用方法——Skip
Stream流中的常用方法skip：如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
Stream skip(long n);
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。
示例：
import java.util.stream.Stream;
public class Demo07StreamSkip {
public static void main(String[] args) {
//获取Stream流
Stream<String> stream = Stream.of("1", "2", "3", "4", "5", "6", "7");
Stream<String> skip = stream.skip(3);
skip.forEach((String n)->{
System.out.println(n);
});
}
}
8、Stream流常用方法——concat
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat：
static Stream concat(Stream<? extends T> a, Stream<? extends T> b)
示例：
import java.util.stream.Stream;
public class Demo09StreamConcat {
public static void main(String[] args) {
Stream<String> stream = Stream.of("aaa", "bbb");
Stream<String> stream1 = Stream.of("ccc", "ddd");
//合并以上两个流
Stream<String> concat = Stream.concat(stream, stream1);
concat.forEach((String n)-> System.out.println(n));
}
}
Stream流练习：集合元素处理（Stream流方式）
题目：现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用传统的for循环(或增强for循环)依次进行以下若干操作步骤：
1、第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
2、第一个队伍筛选之后只需要前三个人，存储到一个新集合中。
3、第二个队伍只需要姓张的成员姓名；存储到一个新集合中。
4、第二个队伍筛选之后不要前两个人，存储到一个新集合中。
5、将两个队伍合并为一个队伍；存储到一个新集合中。
6、根据姓名创建Person对象；存储到一个新集合中。
7、打印整个队伍的Person对象信息。
Person类：
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
主函数代码：
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo10StreamTest {
public static void main(String[] args) {
ArrayList<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//1 2
Stream<String> oneStream = one.stream().filter((String name) -> name.length() == 3).limit(3);
ArrayList<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖");
two.add("张三丰");
two.add("尼古拉斯赵四");
two.add("张天爱");
two.add("张二狗");
//3 4
Stream<String> twoStream = two.stream().filter((name) -> name.startsWith("张")).skip(2);
Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach((n)-> System.out.println(n));
}
}
运行结果：
