案例使用的员工类这是后面案例中使用的员工类：
List personList = new ArrayList();
personList.add(new Person(“Tom”, 8900, “male”, “New York”));
personList.add(new Person(“Jack”, 7000, “male”, “Washington”));
personList.add(new Person(“Lily”, 7800, “female”, “Washington”));
personList.add(new Person(“Anni”, 8200, “female”, “New York”));
personList.add(new Person(“Owen”, 9500, “male”, “New York”));
personList.add(new Person(“Alisa”, 7900, “female”, “New York”));
class Person {
private String name; // 姓名
private int salary; // 薪资
private int age; // 年龄
private String sex; //性别
private String area; // 地区
// 构造方法
public Person(String name, int salary, int age,String sex,String area) {
this.name = name;
this.salary = salary;
this.age = age;
this.sex = sex;
this.area = area;
}
// 省略了get和set，请自行添加
}
- 3.1 遍历/匹配（foreach/find/match）
Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。// import已省略，请自行添加，后面代码亦是
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 遍历输出符合条件的元素 大于6
Optional<Integer> first = list.stream().filter(e -> e > 6).findFirst();
System.out.println(first.get());
// 匹配第一个获取第一个大于6的元素
Optional<Integer> first = list.stream().filter(e -> e > 6).findFirst();
System.out.println(first.get());
// 匹配任意（用并行流） 大于6的元素
Integer integer1 = list.parallelStream().filter(e -> e > 6).findFirst().get();
// 是否包含符合特定条件的元素 判断是否存在大于6的元素 提示返回值是布尔类型
boolean b = list.stream().anyMatch(e -> e > 6);
System.out.println(b);
}
}
- 3.2 筛选（filter）筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
//测验一：筛选出Integer集合中大于7的元素，并打印出来 //完成
list.stream().filter(e->e>7).forEach(System.out::println);
}
}
预期结果：8 9
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
//测验一:筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（
List<String> list2 = personList.stream()
.filter(p -> p.getSalary() > 8000)
.map(Person::getName)
.collect(Collectors.toList());
//很感谢大家，大家代码逻辑都很强。
运行结果：高于8000的员工姓名：[Tom, Anni, Owen]
- 3.3 聚合
（max/min/count)max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。
//测验一：获取String集合中最长的元素。
public class StreamTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
输出结果：最长的字符串：weoujgsd
//测验2：获取Integer集合中的最大值
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
list.stream().sorted().forEach(System.out::println);
输出结果：自然排序的最大值：11自定义排序的最大值：11
测验：获取员工工资最高的人。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
Optional<Person> max = personList.stream().max((p1, p2) -> Integer.compare(p1.getSalary(), p2.getSalary()));
System.out.println("员工薪资最大值"+max.get().getSalary());
输出结果：员工工资最大值：9500
// 案例四：计算Integer集合中大于6的元素的个数。
List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
long count = list.stream()
.filter(e -> e > 6)
.count();
输出结果：list中大于6的元素个数：4
- 3.4 映射(map/flatMap)
映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
//测验：1英文字符串数组的元素全部改为大写。
2整数数组每个元素+3。
String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
List<String> strings = Arrays.asList(strArr);
List<String> collect = strings.stream().map(String::toUpperCase).collect(Collectors.toList());
//2、
intList.stream().map(e->e+3).forEach(System.out::println);
输出结果：每个元素大写：[ABCD, BCDD, DEFDE, FTR]每个元素+3：[4, 6, 8, 10, 12, 14]
//案例二：将员工的薪资全部增加1000。
Stream<Integer> after = personList.stream().map(e -> e.getSalary() + 1000);
输出结果：一次改动前：Tom–>8900一次改动后：Tom–>18900二次改动前：Tom–>18900二次改动后：Tom–>18900
//案例三：将两个字符数组合并成一个新的字符数组。 提示:将每个元素转换成一个stream 后生成新的单个元素集合
List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
String[] words = new String[]{"Hello","World"};
List<String> a = Arrays.stream(words)
.map(word -> word.split(""))
.flatMap(Arrays::stream)
.distinct()
.collect(toList());
//这边偷懒了
输出结果：处理前的集合：[m-k-l-a, 1-3-5]处理后的集合：[m, k, l, a, 1, 3, 5]3.5 归约(reduce)归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
- 3.6 收集
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
//获取能够整除2的元素 - >形成新的集合list
List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
//获取能够整除2的元素 - >形成新的集合set
Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
//获取工资大于7800的人的map集合 key 为名字 value 为工资
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
Map<String, Integer> personMap = personList
.stream()
.filter(p -> p.getSalary() > 7800)
.collect(Collectors.toMap(Person::getName, Person::getSalary));
System.out.println(personMap);
//说实话，有点成就感
运行结果：toList：[6, 4, 6, 6, 20]toSet：[4, 20, 6]toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}3.6.2 统计(count/averaging)Collectors提供了一系列用于数据统计的静态方法：计数：count平均值：averagingInt、averagingLong、averagingDouble最值：maxBy、minBy求和：summingInt、summingLong、summingDouble统计以上所有：summarizingInt、summarizingLong、summarizingDouble
测验：统计员工人数、平均工资、工资总额、最高工资。
案例：将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组
//性别
Map<String, List<Person>> sexMap = personList.stream().collect(Collectors.groupingBy(Person::getSex));
//性别地区（有先后）
Map<String, Map<String, List<Person>>> map =
personList
.stream()
.collect(Collectors.groupingBy(Person::getSex,
Collectors.groupingBy(Person::getArea)));
3.6.4 接合(joining)joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。 - 学习
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
System.out.println("所有员工的姓名：" + names);
List<String> list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("-"));
System.out.println("拼接后的字符串：" + string);
}
}
运行结果：所有员工的姓名：Tom,Jack,Lily拼接后的字符串：A-B-C3.6.5 归约(reducing)Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。
学习:
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 每个员工减去起征点后的薪资之和（这个例子并不严谨，但一时没想到好的例子）
Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
System.out.println("员工扣税薪资总和：" + sum);
// stream的reduce
Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
System.out.println("员工薪资总和：" + sum2.get());
}
}
运行结果：员工扣税薪资总和：8700员工薪资总和：237003.7 排序(sorted)sorted，中间操作。有两种排序：sorted()：自然排序，流中元素需实现Comparable接口sorted(Comparator com)：Comparator排序器自定义排序
案例：将员工按工资由高到低（工资一样则按年龄由大到小）排序
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
personList.add(new Person("Lily", 8800, 26, "male", "New York"));
personList.add(new Person("Alisa", 9000, 26, "female", "New York"));
// 按工资升序排序（自然排序）
List<String> newList =
// 按工资倒序排序
List<String> newList2 =
// 先按工资再按年龄升序排序
List<String> newList3 =
// 先按工资再按年龄自定义排序（降序） 参考
List<String> newList4 = personList.stream().sorted((p1, p2) -> {
if (p1.getSalary() == p2.getSalary()) {
return p2.getAge() - p1.getAge();
} else {
return p2.getSalary() - p1.getSalary();
}
}).map(Person::getName).collect(Collectors.toList());
System.out.println("按工资升序排序：" + newList);
System.out.println("按工资降序排序：" + newList2);
System.out.println("先按工资再按年龄升序排序：" + newList3);
System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
}
}
运行结果：按工资自然排序：[Lily, Tom, Sherry, Jack, Alisa]按工资降序排序：[Sherry, Jack, Alisa,Tom, Lily]先按工资再按年龄自然排序：[Sherry, Jack, Alisa, Tom, Lily]先按工资再按年龄自定义降序排序：[Alisa, Jack, Sherry, Tom, Lily]3.8 提取/组合流也可以进行合并、去重、限制、跳过等操作。
学习
public class StreamTest
public static void main(String[] args) {
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip：跳过前n个数据
List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("流合并：" + newList);
System.out.println("limit：" + collect);
System.out.println("skip：" + collect2);
}
}
运行结果：流合并：[a, b, c, d, e, f, g]limit：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]skip：[3, 5, 7, 9, 11]
440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
