/**
* 创建流
*/
public static void createStream() {
// 方式一：使用集合创建流
List<String> list = Arrays.asList("a","b","c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流,数据和顺序无关
Stream<String> stringStream = list.parallelStream();
// 方式二：使用数组创建流
int[] array = {1,3,5,6,8};
IntStream intStream = Arrays.stream(array);
// 方式三：使用stream的静态方法创建流：of(),iterate(),generate()
Stream<Integer> integerStream = Stream.of(1, 3, 5, 6, 8);
// iterate创建stream limit限制循环次数
Stream<Integer> limit = Stream.iterate(0, (x) -> x + 3).limit(4);
limit.forEach(System.out::println);
// generate创建stream limit限制循环次数
Stream<Double> limit1 = Stream.generate(Math::random).limit(3);
limit1.forEach(System.out::println);
// parallel() 将顺序流转换成并行流
List<Integer> intList = Arrays.asList(1,4,6,9,12,7);
Optional<Integer> findFirst = intList.stream().parallel().filter(x->x>6).findFirst();
System.out.println(findFirst.get());
}
/**
* 循环遍历（foreach,find,match）
*/
public static void streamEach(){
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 遍历输出符合条件的元素
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 10).findFirst();
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 610).findAny();
// 是否包含符合特定条件元素
boolean anyMatch = list.stream().anyMatch(x -> x > 6);
System.out.println("匹配第一个值：" + findFirst.isPresent());
System.out.println("匹配任意一个值：" + findAny.isPresent());
System.out.println("是否存在大于6的值：" + anyMatch);
}
public static void filter() {
List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
Stream<Integer> stream = list.stream();
list = stream.filter(x -> x > 7).collect(Collectors.toList());
//list.forEach(System.out::println);
// 筛选员工中工资高于8000的人，并形成新的集合
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"));
List<String> collect = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
System.out.println("高于8000的员工姓名：" + collect);
}
/**
* 聚合：mix/min/count
*/
public static void collection() {
List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
// 获取最长字符串
Optional<String> max = list.stream().max(Comparator.comparing(String::length));
System.out.println("最长字符串：" + max.get());
List<Integer> integerList = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
Optional<Integer> max1 = integerList.stream().max(Integer::compareTo);
Optional<Integer> max2 = integerList.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println("自然排序的最大值：" + max1.get());
System.out.println("自定义排序的最大值：" + max2.get());
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> max3 = personList.stream().max(Comparator.comparing(Person::getSalary));
System.out.println("员工工资最大值：" + max3.get().getSalary());
List<Integer> countList = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
long count = countList.stream().filter(x -> x > 6).count();
System.out.println("countLit中大于6的元素的个数:" + count);
}
/**
* 映射：map/flatMap
*/
public static void mapping() {
// 英文字符串数组的元素全部改为大写。整数数组每个元素+3
String[] strArr = {"abcd", "bcdd", "defde", "fTr"};
// 将数组元素小写转大写，并且转成集合
List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
// 每个元素+3
List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
System.out.println("每个元素大写：" + strList);
System.out.println("每个元素+3：" + intListNew);
// 员工薪资增加10000
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"));
// 不改变原来员工集合的方式
List<Person> personListNew = personList.stream().map(person -> {
Person personNew = new Person(person.getName(),0,0,null,null);
personNew.setSalary(person.getSalary() + 10000);
return personNew;
}).collect(Collectors.toList());
System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());
// 改变原来员工集合的方式
List<Person> personListNew2 = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 10000);
return person;
}).collect(Collectors.toList());
System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew2.get(0).getSalary());
/******************************** flatMap *******************************************/
/**
* 将两个字符数组合并成一个新的字符数组
*/
// 两个字符数组
List<String> twoStrList = Arrays.asList("m,k,l,a","1,3,5,7");
List<String> listNew = twoStrList.stream().flatMap(s -> {
// 将每个元素转换成一个stream
String[] split = s.split(",");
Stream<String> s2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
System.out.println("处理前的集合：" + twoStrList);
System.out.println("处理后的集合：" + listNew);
}
/**
* 规约：是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
*
*/
public static void streamReduce() {
// 求Integer集合的元素之和、乘积和最大值
List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);
// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
// 求最大值方式二
Integer max2 = list.stream().reduce(0, Integer::max);
System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
System.out.println("list求积：" + product.get());
System.out.println("list求和：" + max.get() + "," + max2);
/*
求所有员工的工资之和和最高工资。
*/
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"));
// 求工资之和方式1
Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
// 求工资之和方式2
Integer sumSalary2 = personList.stream().reduce(0, (s, p) -> s += p.getSalary(), (s1, s2) -> s1 + s2);
// 求工资之和方式3
Integer sumSalary3 = personList.stream().reduce(0, (s, p) -> s += p.getSalary(), Integer::sum);
// 求最高工资方法1
Integer maxSalary = personList.stream().reduce(0, (m, p) -> m > p.getSalary() ? m : p.getSalary(), Integer::max);
// 求最高工资方法2
Integer maxSalary1 = personList.stream().reduce(0, (m, p) -> m > p.getSalary() ? m : p.getSalary(), (m1, m2) -> m1 > m2 ? m1 : m2);
System.out.println("工资之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);
System.out.println("最高工资：" + maxSalary + "," + maxSalary1);
}
/**
* 归集：toList/toSet/toMap
* 计数：count
* 平均值：averagingInt、averagingLong、averagingDouble
* 最值：maxBy、minBy
* 求和：summingInt、summingLong、summingDouble
* 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
*/
public static void streamCollection() {
/**
* 归集：toList/toSet/toMap
*/
List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
Set<Integer> setNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
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,Person>
Map<String, Person> mapNew = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));
System.out.println("toList:" + listNew);
System.out.println("toSet:" + setNew);
System.out.println("toMap:" + mapNew);
/*
统计员工人数、平均工资、工资总额、最高工资。
*/
List<Person> coustomerList = new ArrayList<Person>();
coustomerList.add(new Person("Tom", 8900, 23, "male", "New York"));
coustomerList.add(new Person("Jack", 7000, 25, "male", "Washington"));
coustomerList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 求总数
Long countCoustomer = coustomerList.stream().collect(Collectors.counting());
// 求平均工资
Double averageSalary = coustomerList.stream().collect(Collectors.averagingDouble(Person::getSalary));
// 求最高工资
Optional<Integer> maxSalary = coustomerList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
// 求工资之和
Integer sumSalary = coustomerList.stream().collect(Collectors.summingInt(Person::getSalary));
// 一次性统计所有信息
DoubleSummaryStatistics totalSalary = coustomerList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println("员工总数：" + countCoustomer);
System.out.println("员工平均工资：" + averageSalary);
System.out.println("员工工资总和：" + sumSalary);
System.out.println("员工工资所有统计：" + totalSalary);
/**
* 分组(partitioningBy/groupingBy)
* 将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组
*/
List<Person> groupList = new ArrayList<Person>();
groupList.add(new Person("Tom", 8900, 23,"male", "New York"));
groupList.add(new Person("Jack", 7000, 22,"male", "Washington"));
groupList.add(new Person("Lily", 7800, 30,"female", "Washington"));
groupList.add(new Person("Anni", 8200, 28,"female", "New York"));
groupList.add(new Person("Owen", 9500, 25,"male", "New York"));
groupList.add(new Person("Alisa", 7900,24,"female", "New York"));
// 将员工薪资是否高于8000分组
Map<Boolean, List<Person>> salaryMap = groupList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
// 将员工按性别分组
Map<String, List<Person>> sexMap = groupList.stream().collect(Collectors.groupingBy(Person::getSex));
// 将员工按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> sexAreaMap = groupList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.out.println("员工按薪资是否大于8000分组情况：" + salaryMap);
System.out.println("员工按性别分组情况：" + sexMap);
System.out.println("员工按性别、地区：" + sexAreaMap);
/**
* 接合：joining
* joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串
*/
List<Person> joinList = new ArrayList<Person>();
joinList.add(new Person("Tom", 8900, 23, "male", "New York"));
joinList.add(new Person("Jack", 7000, 25, "male", "Washington"));
String collect = joinList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
joinList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 拼接员工姓名
String names = joinList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
System.out.println("所有员工的姓名：" + names);
List<String> charList = Arrays.asList("A", "B", "C");
String charStr = charList.stream().collect(Collectors.joining("-"));
System.out.println("拼接后的字符串：" + charStr);
/**
* 规约:reducing
* 增加了对自定义规约的支持
*/
List<Person> reducingList = new ArrayList<Person>();
reducingList.add(new Person("Tom", 8900, 23, "male", "New York"));
reducingList.add(new Person("Jack", 7000, 25, "male", "Washington"));
reducingList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 每个员工减去起征点后的薪资之和
Integer reducingSum = reducingList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
System.out.println("员工扣税薪资总和：" + reducingSum);
// stream的reduce
Optional<Integer> reduceSum = reducingList.stream().map(Person::getSalary).reduce(Integer::sum);
System.out.println("员工薪资总和：" + reduceSum.get());
/**
* 排序：sorted,中间操作
* sorted()：自然排序，流中元素需实现Comparable接口
* sorted(Comparator com)：Comparator排序器自定义排序
*/
List<Person> sortedList = new ArrayList<Person>();
sortedList.add(new Person("Sherry", 9000, 24, "female", "New York"));
sortedList.add(new Person("Tom", 8900, 22, "male", "Washington"));
sortedList.add(new Person("Jack", 9000, 25, "male", "Washington"));
sortedList.add(new Person("Lily", 8800, 26, "male", "New York"));
sortedList.add(new Person("Alisa", 9000, 26, "female", "New York"));
// 员工薪资升序排序(自然排序)
List<String> sortList = sortedList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
// 员工工资倒序排序
List<String> reversedList = sortedList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄升序排列
List<String> salaryAgeSortList = sortedList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄自定义排序（降序）
List<String> salaryAgeSortReverseList = sortedList.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("按工资升序排序：" + sortList);
System.out.println("按工资降序排序：" + reversedList);
System.out.println("先按工资再按年龄升序排序：" + salaryAgeSortList);
System.out.println("先按工资再按年龄自定义降序排序：" + salaryAgeSortReverseList);
/**
* 提取/组合
* 流也可以进行合并、去重、限制、跳过等操作。
*/
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> streamNewList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> limitList = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip:跳过前n个数据
List<Integer> skipList = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("流合并：" + streamNewList);
System.out.println("limit：" + limitList);
System.out.println("skip：" + skipList);
}
|
