标签：需求 fir jdk8 override equals out get tor rev
1）：对象 List<User> 转 Map<String,Object>
案例如下：
public class User {
private Integer id;
private String age;
User(Integer id, String age) {
this.id = id;
this.age = age;
}
}
List<User> userList = new ArrayList<User>() {{
add(new User(1, "1111"));
add(new User(1, "1111"));
add(new User(2, "2222"));
}};
// 方式一（不推荐）：遇到重复的 id 值。 会抛异常 java.lang.IllegalStateException: Duplicate key User
Map<Integer, User> maps = userList.stream().collect(Collectors.toMap(User::getId, Function.identity()));
// 方式二：（推荐）
Map<Integer, User> maps = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(), (key1, key2) -> key2));
2）：================START=======================
测试数据如下：
public class TestStreamModel implements Serializable {
private int id;
private String name;
private int grade;
private int classes;
private double score;
public TestStreamModel(int id, String name, int grade, int classes, double score) {
this.id = id;
this.name = name;
this.grade = grade;
this.classes = classes;
this.score = score;
}
get|set...省略
@Override
public String toString() {
return "TestStreamModel{" +
"id=" + id +
", name=‘" + name + ‘\‘‘ +
", grade=" + grade +
", classes=" + classes +
", score=" + score +
‘}‘;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TestStreamModel that = (TestStreamModel) o;
return id == that.id &&
grade == that.grade &&
classes == that.classes &&
Double.compare(that.score, score) == 0 &&
Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name, grade, classes, score);
}
}
// 初始化数据
List<TestStreamModel> list = new ArrayList<TestStreamModel>() {{
add(new TestStreamModel(1, "李四", 1, 1, 60));
add(new TestStreamModel(2, "张三", 1, 1, 80));
add(new TestStreamModel(3, "王二麻子", 1, 2, 90));
add(new TestStreamModel(4, "王五", 1, 3, 59.5));
add(new TestStreamModel(5, "小红", 2, 2, 99));
add(new TestStreamModel(6, "小白", 2, 1, 88.8));
add(new TestStreamModel(7, "小黑", 2, 2, 45));
add(new TestStreamModel(8, "小明", 1, 1, 79.5));
add(new TestStreamModel(8, "小明", 1, 1, 79.5));
}};
2-1）：去重-去除重复对象（每个属性的值都一样的），需要注意的是要先重写对象 TestStreamModel 的 equals 和 hashCode 方法
System.out.println("集合数量：" + list.size() + "-->每个属性的值都一样的-->去重前：" + list);
List<TestStreamModel> distinctList = list.stream().distinct().collect(Collectors.toList());
System.out.println("集合数量：" + distinctList.size() + "-->每个属性的值都一样的-->去重后：" + distinctList);
2-2）：去重，去除重复对象（根据对象其中一个属性进行去重）
ArrayList<TestStreamModel> collect = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(TestStreamModel::getId))), ArrayList::new));
2-3）：排序，按id升续排列，如果要降续则改成：(a, b) -> b.getId() - a.getId(); a和b都是变量名（可以按自己意愿取名字），都是list中的对象的实例
List<TestStreamModel> sortList = list.stream().sorted((a, b) -> a.getId() - b.getId()).collect(Collectors.toList());
2-4）：过滤，按照自己的需求来筛选list中的数据，比如我筛选出不及格的（小于60分）的人,t为实例
List<TestStreamModel> filterList = list.stream().filter(t -> t.getScore() < 60).collect(Collectors.toList());
2-5）：Map, 提取对象中的某一元素，例子中我取的是每个人的name，注意list中类型对应，如果取的是id或者班级，就应该是integer类型
List<String> mapList = list.stream().map(t -> t.getName()).collect(Collectors.toList());
2-6）：统计，统计所有人分数的和, 主要我设置的分数属性是double类型的，所以用mapToDouble，如果是int类型的，则需要用mapToInt
double sum = list.stream().mapToDouble(t -> t.getScore()).sum();
int count = list.stream().mapToInt(t -> t.getId()).sum();
2-7）：分组， 按照字段中某个属性将list分组
Map<Integer, List<TestStreamModel>> map = list.stream().collect(Collectors.groupingBy(t -> t.getGrade()));
System.out.println("按年级分组" + map);
/*然后再对map处理，这样就方便取出自己要的数据*/
for (Map.Entry<Integer, List<TestStreamModel>> entry : map.entrySet()) {
System.out.println("key:" + entry.getKey());
System.out.println("value:" + entry.getValue());
}
2-8）：多重分组，先按年级分组，再按班级分组
Map<Integer/*年级id*/, Map<Integer/*班级id*/, List<TestStreamModel>>> groupMap = list.stream().collect(Collectors.groupingBy(t -> t.getGrade(), Collectors.groupingBy(t -> t.getClasses())));
System.out.println("按照年级再按班级分组：" + groupMap);
System.out.println("取出一年级一班的list：" + groupMap.get(1).get(1));
2-9）：多重分组，一般多重分组后都是为了统计，比如说统计每个年级，每个班的总分数
Map<Integer/*年级id*/, Map<Integer/*班级id*/, Double>> sumMap = list.stream().collect(Collectors.groupingBy(t -> t.getGrade(), Collectors.groupingBy(t -> t.getClasses(), Collectors.summingDouble(t -> t.getScore()))));
System.out.println(sumMap);
System.out.println("取出一年级一班的总分：" + sumMap.get(1).get(1));
2-10）：多重分组，一般多重分组后都是为了统计，比如说统计每个年级，每个班的总分数
Map<Integer/*年级*/, Map<Integer/*班级*/, Long/*人数*/>> integerMap = list.stream().filter(t -> t.getScore() >= 60).collect(Collectors.groupingBy(t -> t.getGrade(), Collectors.groupingBy(t -> t.getClasses(), Collectors.counting())));
System.out.println("取出一年级一班及格人数：" + integerMap.get(1).get(1));
2-11）：逗号拼接，去重 将每个ID以逗号方式拼接 & 对象重写 equals和hashCode
String dou = list.stream().distinct().map(mark -> mark.getId().toString()).filter(x -> !ObjectUtils.isEmpty(x)).collect(Collectors.joining(","));
System.out.println("逗号拼接，将每个ID以逗号方式拼接:={}"+dou);
2-12）：limit 返回前几个元素信息 获取大于50前三位学生信息
Collections.sort(list, Comparator.comparing(TestStreamModel::getScore).reversed());// 倒序排列，删除 reversed()为正序
List<TestStreamModel> models = list.stream().filter(a -> a.getScore() > 50).limit(3).collect(Collectors.toList());
System.out.println("limit 获取大于50分的前三位学生:={}"+models);
2-13）：skip 获取跳过几个元素后的信息 获取大于50前三位学生信息
Collections.sort(list, Comparator.comparing(TestStreamModel::getScore).reversed());// 倒序排列，删除 reversed()为正序
List<TestStreamModel> model = list.stream().filter(a -> a.getScore() > 50).skip(3).collect(Collectors.toList());
System.out.println("limit 获取大于50分的前三位学生:={}"+model);
=====================END========================
3-1）：flatMap
flatMap与map的区别在于* flatMap是将一个流中的每个值都转成一个个流，然后再将这些流扁平化成为一个流 。
举例说明，假设我们有一个字符串数组String[] strs = {"java8", "is", "easy", "to", "use"};
我们希望输出构成这一数组的所有非重复字符，那么我们可能首先会想到如下实现：
String[] strs = {"java8", "java8", "is", "easy", "to", "use"};
List<String[]> distinctStrs = Arrays.stream(strs)
.map(str -> str.split("")) // 映射成为Stream<String[]>
.distinct()
.collect(Collectors.toList());
System.out.println("映射处理flatMap:操作之后的数据为{}：");
distinctStrs.stream().forEach(ex -> {
System.out.println(Arrays.stream(ex).collect(Collectors.joining(",")));
});
返回结果：
j,a,v,a,8
j,a,v,a,8
i,s
e,a,s,y
t,o
u,s,e
distinct只有对于一个包含多个字符的流进行操作才能达到我们的目的，即对Stream<String>进行操作。此时flatMap就可以达到我们的目的：
List<String> dis = Arrays.stream(strs)
.map(str -> str.split("")) // 映射成为Stream<String[]>
.flatMap(Arrays::stream) // 扁平化为Stream<String>
.distinct()
.collect(Collectors.toList());
System.out.println("映射处理flatMap:操作之后的数据为{}：");
dis.stream().forEach(s1 -> System.out.print(s1));
返回结果：jav8iseytou
4-1）：allMatch ： 查询所有学生成绩是否都大于 44 分
boolean isAdult = list.stream().allMatch(student -> student.getScore() >= 44);// 满足返回 true System.out.println("查找 allMatch:" + isAdult);
4-2）：anyMatch ：查询所有学生是否有成绩是否都大于 44 分
boolean hasWhu = list.stream().anyMatch(student -> student.getScore() >= 98);// 满足返回 false System.out.println("查找 anyMatch:" + hasWhu);
4-3）：noneMatch ：查询所有学生是否不存在大于98分的
boolean noneCs = list.stream().noneMatch(student -> student.getScore() >= 98); // 不存在返回 true ，否则 false System.out.println("查找 noneMathch:" + noneCs);
4-4）：findFirst ： 查询满足条件排在第一位的学生信息
TestStreamModel findFirst = list.stream().filter(student -> student.getScore() >= 60).findFirst().orElse(new TestStreamModel()); System.out.println("查找 findFirst:" + findFirst);
4-5）：findAny : 查询满足条件随机一个的学生信息
TestStreamModel findAny = list.stream().filter(student -> student.getScore() >= 60).findAny().orElse(new TestStreamModel()); System.out.println("查找 findAny:" + findAny);
标签：需求 fir jdk8 override equals out get tor rev
原文地址：https://www.cnblogs.com/codingmode/p/12178089.html
