package stream;
import model.Student;
import org.junit.jupiter.api.Test;
import java.util.*;
import java.util.stream.Collectors;
/**
* 使用Stram流操作集合信息
* @auther minghao
* @date 2019.02.11
*/
public class studyStream {
/**
*
*/
@Test
public void test3() {
//1.创建实体类准备数据
List<Student> students = new ArrayList<Student>() {
{
add(new Student(20160001, "孔明", 20, 1, "土木工程", "武汉大学"));
add(new Student(20160002, "伯约", 21, 2, "信息安全", "武汉大学"));
add(new Student(20162001, "仲谋", 19, 3, "土木工程", "浙江大学"));
add(new Student(20162001, "仲谋", 25, 3, "土木工程", "浙江大学"));
add(new Student(20162001, "仲谋", 28, 3, "土木工程", "浙江大学"));
add(new Student(20160003, "玄德", 22, 3, "经济管理", "武汉大学"));
add(new Student(20160004, "云长", 21, 2, "信息安全", "武汉大学"));
add(new Student(20161001, "翼德", 21, 2, "机械与自动化", "华中科技大学"));
add(new Student(20161002, "元直", 23, 4, "土木工程", "华中科技大学"));
add(new Student(20161003, "奉孝", 23, 4, "计算机科学", "华中科技大学"));
add(new Student(20162001, "仲谋", 22, 3, "土木工程", "浙江大学"));
add(new Student(20162002, "鲁肃", 23, 4, "计算机科学", "浙江大学"));
add(new Student(20163001, "丁奉", 24, 5, "土木工程", "南京大学"));
}
};
/**
* 方式一：前面例子中使用的方式
* 获取计算机科学专业学生的年龄总和
*/
int totalAge = students.stream().filter(student -> "计算机科学".equals(student.getMajor())).mapToInt(Student::getAge).sum();
/**
* 方式二：归约操作 reduce
* 获取计算机科学专业学生的年龄总和
*/
int totalAge2 = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
.mapToInt(Student::getAge).reduce(0,(a,b) -> a+b);
/**
* 方式三：归约操作（进一步简化） reduce
* 获取计算机科学专业学生的年龄总和
*/
int reduceAges = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
.mapToInt(Student::getAge).reduce(0,Integer::sum);
/**
* 方式四：归约操作（进一步简化） reduce
* 采用无初始值的重载版本，需要注意返回Optional
* 获取计算机科学专业学生的年龄总和
*/
Optional optAges = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student::getAge).reduce(Integer::sum);
/**
* 求学生的总数
*/
long count = students.stream().collect(Collectors.counting());
//进一步简化
long count1 = students.stream().count();
/**
* 求年龄的最大值和最小值
*/
//求最大年龄
Optional<Student> collect = students.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));
//进一步简化 求最大年龄
Optional<Student> collect1 = students.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getAge)));
//求最小年龄
Optional<Student> collect2 = students.stream().collect(Collectors.minBy(Comparator.comparing(Student::getAge)));
/**
* 求年龄总和
*/
Integer sunAges = students.stream().collect(Collectors.summingInt(Student::getAge));
/**
* 求年龄的平均值
*/
Double avgAge = students.stream().collect(Collectors.averagingInt(Student::getAge));
/**
* 一次性得到元素(年龄)的个数、总和、均值、最大值、最小值
*/
IntSummaryStatistics collect3 = students.stream().collect(Collectors.summarizingInt(Student::getAge));
/**
* 字符串拼接,拼接所有对象的名字
*/
String join = students.stream().map(Student::getName).collect(Collectors.joining());
String join2 = students.stream().map(Student::getName).collect(Collectors.joining(","));
/**
* 按照学校进行分组(一级分组)
*/
Map<String, List<Student>> groupbySchool = students.stream().collect(Collectors.groupingBy(Student::getSchool));
/**
* 按照学校进行分组，再按照专业分组(多级分组)
*/
Map<String,Map<String,List<Student>>> groupbySchoolAndMajor = students.stream().collect(
Collectors.groupingBy(Student::getSchool, //一级分组
Collectors.groupingBy(Student::getMajor) //二级分组（二级套在一级里面）
));
/**
* 传递一个Collector.counting，用以统计每个组的个数：
* 统计根据学校分组，每组的数量
*/
Map<String, Long> counting = students.stream().collect(Collectors.groupingBy(Student::getSchool, Collectors.counting()));
/**
* 使用分区Collectors.partitioningBy()
* 将学生分为武大学生和非武大学生
*/
Map<Boolean, List<Student>> isWhuSchool = students.stream().collect(Collectors.partitioningBy(student -> "武汉大学".equals(student.getSchool())));
System.out.println();
}
/**
*
*/
@Test
public void test2(){
//1.创建实体类准备数据
List<Student> students = new ArrayList<Student>() {
{
add(new Student(20160001, "孔明", 20, 1, "土木工程", "武汉大学"));
add(new Student(20160002, "伯约", 21, 2, "信息安全", "武汉大学"));
add(new Student(20162001, "仲谋", 19, 3, "土木工程", "浙江大学"));
add(new Student(20162001, "仲谋", 25, 3, "土木工程", "浙江大学"));
add(new Student(20162001, "仲谋", 28, 3, "土木工程", "浙江大学"));
add(new Student(20160003, "玄德", 22, 3, "经济管理", "武汉大学"));
add(new Student(20160004, "云长", 21, 2, "信息安全", "武汉大学"));
add(new Student(20161001, "翼德", 21, 2, "机械与自动化", "华中科技大学"));
add(new Student(20161002, "元直", 23, 4, "土木工程", "华中科技大学"));
add(new Student(20161003, "奉孝", 23, 4, "计算机科学", "华中科技大学"));
add(new Student(20162001, "仲谋", 22, 3, "土木工程", "浙江大学"));
add(new Student(20162002, "鲁肃", 23, 4, "计算机科学", "浙江大学"));
add(new Student(20163001, "丁奉", 24, 5, "土木工程", "南京大学"));
}
};
/**
* 2.使用stream流的filter过滤，通过lambda表达式从集合students中筛选出所有武汉大学的学生
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* collect(): 终端操作
* Conllect.toList()： 将结果封装成为一个list集合
*/
List<Student> whustudents = students.stream().filter(student -> "武汉大学".equals(student.getSchool())).collect(Collectors.toList());
/**
* 3.使用stream流的filter + limit，通过lambda表达式从集合students中获取2个专业为土木工程专业的学生
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* limit()：限制返回的数量
* collect(): 终端操作
* Conllect.toList()： 将结果封装成为一个list集合
*
*/
List<Student> limitStudents = students.stream().filter(a -> "土木工程".equals(a.getMajor())).limit(2).collect(Collectors.toList());
/**
* 4.使用stream流的filter + limit + sorted，
* 通过lambda表达式从集合students中获取2个专业为土木工程专业的学生,
* 并按年龄从小到大排序，筛选出年龄最小的两个学生
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* limit()：限制返回的数量
* sorted()：对两个值进行排序
* collect(): 终端操作
* Conllect.toList()： 将结果封装成为一个list集合
*
*/
List<Student> sortedStudents = students.stream().filter(student -> "土木工程".equals(student.getMajor()))
.sorted((s1,s2) -> s1.getAge() - s2.getAge()).limit(2).collect(Collectors.toList());
/**
* 5.使用stream流 filter + skip 找出排序在2之后的土木工程专业的学生
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* skip()：对筛选出来的结果，排除前面N个数量
* collect(): 终端操作
* Conllect.toList()： 将结果封装成为一个list集合
*/
List<Student> skipStudents = students.stream().filter(student -> "土木工程".equals(student.getMajor()))
.skip(2).collect(Collectors.toList());
/**
* 1.使用stream流 filter + map 通过map将学生实体映射成为学生姓名字符串
* 获取专业为计算机科学的所有学生姓名
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* .map(Student :: getName)：获取当前实体类的姓名，返回给list集合
* collect(): 终端操作
* Conllect.toList()： 将结果封装成为一个list集合
*/
List<String> names = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student :: getName).collect(Collectors.toList());
/**
* 2.使用stream流 filter + map 通过map将学生实体映射成为学生年龄
* 获取专业为计算机科学的所有学生年龄
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* .map(Student :: getAge)：获取当前实体类的年龄，返回给list集合
* collect(): 终端操作
* Conllect.toList()： 将结果封装成为一个list集合
*/
List<Integer> ages = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
.map(Student :: getAge).collect(Collectors.toList());
/**
* 3.使用stream流 filter + maptoInt 通过map将学生实体映射成为学生年龄 的总和
* 获取专业为计算机科学的所有学生年龄 的总和（年龄相加）
*
* stream()：将students集合转为stream流
* filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
* .map(Student :: getAge)：获取当前实体类的年龄，返回给list集合
* sum(): 返回年龄的总和（年龄相加）
*/
int agesSum = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
.mapToInt(Student :: getAge).sum();
String[] strs = {"java8", "is", "easy", "to", "use"};
/**
* 将数组strs 中的每个元素使用split 拆分成为数组
* 返回list<String[]>的集合数组
* 注：distinct只有对于一个包含多个字符的流进行操作才能达到我们的目的
* 因此，下面两行代码效果一致
*/
List<String[]> distinctStrs = Arrays.stream(strs).map(str -> str.split("")).distinct().collect(Collectors.toList());
List<String[]> Strs = Arrays.stream(strs).map(str -> str.split("")).collect(Collectors.toList());
/**
* 将数组strs 中的每个元素使用split 拆分成为数组
* flatMap()：将数组的多个元素转换成为一个元素进行输出
*
* flatMap与map的区别在于 flatMap是将一个流中的每个值都转成一个个流，然后再将这些流扁平化成为一个流 。
*/
List<String> flatMapStrs = Arrays.stream(strs).map(str -> str.split("")) //得到List<String[]>
.flatMap(Arrays::stream).collect(Collectors.toList()); //将List<String[]> 转化为List<String>
String a = flatMapStrs.toString();
/**
* allMatch()：判断当前集合中所有人的年龄是否大于等于18岁
* true 全部大于/等于
* false 相反
*/
boolean isAdult = students.stream().allMatch(student -> student.getAge() >= 18);
/**
* anyMatch()：判断当前集合中是否存在个别人的年龄是否大于等于18岁
* true 一个或多个存在
* false 一个也不存在
*/
boolean hasWhu = students.stream().anyMatch(student -> student.getAge() >= 18);
/**
* noneMatch()：判断当前集合是否不存在filter指定的元素
* true 不存在
* false 存在
*/
boolean noneCs = students.stream().noneMatch(student -> "计算机科学".equals(student.getMajor()));
/**
* findFirst()：返回返回满足条件的第一个元素
*/
Optional<Student> optstu = students.stream().filter(student -> "土木工程".equals(student.getMajor())).findFirst();
/**
* findAny()：返回返回满足条件的任意一个元素
*/
Optional<Student> anyoptstu = students.stream().filter(student -> "土木工程".equals(student.getMajor())).findAny();
System.out.println();
}
/**
* 初步使用stream流完集合遍历
*/
@Test
public void test(){
//1.准备数据
List<Integer> nums = new ArrayList<>();
for (int i = 1; i <= 20;i++){
nums.add(i);
}
for (int i = 10; i <= 20;i++){
nums.add(i);
}
//2.使用foreach筛选偶数
List<Integer> evens = new ArrayList<>();
for (Integer num: nums) {
if (num % 2 == 0)
evens.add(num);
}
/**
* 3.1：使用stream流完成筛选偶数 返回list集合 filter() +collect()
*
* 一个流的处理分为三部分：转换成流 ——> 中间操作(自定义) ——> 终端操作
* 例如：
* stream()：将集合转换成流
* filter()：指定我们自定义的筛选处理/自定义其他处理
* collect()：对结果进行封装处理
* Collectors.toList()：指定其筛选流结果，封装成一个List集合进行返回
*/
List<Integer> StreamEvens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
System.out.println();
/**
* 3.2：使用stream流完成筛选偶数，并去掉重复 返回list集合 filter() + distinct() + collect()
*
* stream()：将集合转换成流
* filter()：指定我们自定义的筛选处理/自定义其他处理
* collect()：对结果进行封装处理
* distinct()：去掉重复
* Collectors.toList()：指定其筛选流结果，封装成一个List集合进行返回
*/
List<Integer> distinctEvens = nums.stream().filter(num -> num % 2 == 0).distinct().collect(Collectors.toList());
/**
* 使用stream流+foreach遍历输出 集合中的所有数据
*/
nums.stream().forEach(num -> System.out.println(num));
System.out.println();
}
}