Java 8 Java 8多谓词摘要
考虑以下使用注释注释的pojo类Java 8 Java 8多谓词摘要,java-8,java-stream,Java 8,Java Stream,考虑以下使用注释注释的pojo类 @Setter @Getter @Builder @ToString public class User { private String firstName; private String lastName; private Gender gender; private Integer age; private Integer points; } 要求获取以下谓词的“points”属性的LongSummaryStati
@Setter
@Getter
@Builder
@ToString
public class User {
private String firstName;
private String lastName;
private Gender gender;
private Integer age;
private Integer points;
}
LongSummaryStatisticsPredicate adultMenPredicate=user->Gender.MALE==user.getGender&&user.getAge（）>18Predicate adultWomenPredicate=user->Gender.FEMALE==user.getGender&&user.getAge（）>18Predicate minorPredicate=user->user.getAge（）
public static void main(String [] args) {
List<User> users = ImmutableList.of(new User("a", "s", MALE, 19, 22),
new User("a", "s", MALE, 15, 49),
new User("a", "s", MALE, 22, 11),
new User("a", "s", FEMALE, 19, 1),
new User("a", "s", MALE, 12, 22));
Map<Type, Integer> collect = users.stream()
.map(u -> Tuple.tuple(u, resolveType(u)))
.collect(Collectors.groupingBy(Tuple::right, Collectors.summingInt(t -> t.left().points)));
System.out.println(collect);
}
public static Type resolveType(final User user) {
if (user.gender == MALE && user.age > 18) {
return Type.ADULT_MALE;
} else if (user.gender == FEMALE && user.age > 18) {
return Type.ADULT_FEMALE;
} else {
return Type.MINOR;
}
}
public enum Type {
ADULT_MALE, ADULT_FEMALE, MINOR
}
@ToString
@EqualsAndHashCode
public class Tuple<L, R> {
public static <L, R> Tuple<L, R> tuple(L left, R right) {
return new Tuple<>(left, right);
}
private final L left;
private final R right;
private Tuple(L left, R right) {
this.left = left;
this.right = right;
}
public L left() {
return left;
}
public R right() {
return right;
}
}
我想你不必担心性能，除非你要处理大量的收藏
//编辑
我只是想说清楚。我的元组实现如下所示：
public static void main(String [] args) {
List<User> users = ImmutableList.of(new User("a", "s", MALE, 19, 22),
new User("a", "s", MALE, 15, 49),
new User("a", "s", MALE, 22, 11),
new User("a", "s", FEMALE, 19, 1),
new User("a", "s", MALE, 12, 22));
Map<Type, Integer> collect = users.stream()
.map(u -> Tuple.tuple(u, resolveType(u)))
.collect(Collectors.groupingBy(Tuple::right, Collectors.summingInt(t -> t.left().points)));
System.out.println(collect);
}
public static Type resolveType(final User user) {
if (user.gender == MALE && user.age > 18) {
return Type.ADULT_MALE;
} else if (user.gender == FEMALE && user.age > 18) {
return Type.ADULT_FEMALE;
} else {
return Type.MINOR;
}
}
public enum Type {
ADULT_MALE, ADULT_FEMALE, MINOR
}
@ToString
@EqualsAndHashCode
public class Tuple<L, R> {
public static <L, R> Tuple<L, R> tuple(L left, R right) {
return new Tuple<>(left, right);
}
private final L left;
private final R right;
private Tuple(L left, R right) {
this.left = left;
this.right = right;
}
public L left() {
return left;
}
public R right() {
return right;
}
}
@ToString
@EqualsAndHashCode
公共类元组{
公共静态元组（左，右）{
返回新元组（左、右）；
}
二等兵，我走了；
私权；
私有元组（左左，右）{
this.left=左；
这个。右=右；
}
公共左{
左转；
}
公权{
返还权；
}
}
我想出了这样的办法：
public static void main(String [] args) {
List<User> users = ImmutableList.of(new User("a", "s", MALE, 19, 22),
new User("a", "s", MALE, 15, 49),
new User("a", "s", MALE, 22, 11),
new User("a", "s", FEMALE, 19, 1),
new User("a", "s", MALE, 12, 22));
Map<Type, Integer> collect = users.stream()
.map(u -> Tuple.tuple(u, resolveType(u)))
.collect(Collectors.groupingBy(Tuple::right, Collectors.summingInt(t -> t.left().points)));
System.out.println(collect);
}
public static Type resolveType(final User user) {
if (user.gender == MALE && user.age > 18) {
return Type.ADULT_MALE;
} else if (user.gender == FEMALE && user.age > 18) {
return Type.ADULT_FEMALE;
} else {
return Type.MINOR;
}
}
public enum Type {
ADULT_MALE, ADULT_FEMALE, MINOR
}
@ToString
@EqualsAndHashCode
public class Tuple<L, R> {
public static <L, R> Tuple<L, R> tuple(L left, R right) {
return new Tuple<>(left, right);
}
private final L left;
private final R right;
private Tuple(L left, R right) {
this.left = left;
this.right = right;
}
public L left() {
return left;
}
public R right() {
return right;
}
}
我想你不必担心性能，除非你要处理大量的收藏
//编辑
我只是想说清楚。我的元组实现如下所示：
public static void main(String [] args) {
List<User> users = ImmutableList.of(new User("a", "s", MALE, 19, 22),
new User("a", "s", MALE, 15, 49),
new User("a", "s", MALE, 22, 11),
new User("a", "s", FEMALE, 19, 1),
new User("a", "s", MALE, 12, 22));
Map<Type, Integer> collect = users.stream()
.map(u -> Tuple.tuple(u, resolveType(u)))
.collect(Collectors.groupingBy(Tuple::right, Collectors.summingInt(t -> t.left().points)));
System.out.println(collect);
}
public static Type resolveType(final User user) {
if (user.gender == MALE && user.age > 18) {
return Type.ADULT_MALE;
} else if (user.gender == FEMALE && user.age > 18) {
return Type.ADULT_FEMALE;
} else {
return Type.MINOR;
}
}
public enum Type {
ADULT_MALE, ADULT_FEMALE, MINOR
}
@ToString
@EqualsAndHashCode
public class Tuple<L, R> {
public static <L, R> Tuple<L, R> tuple(L left, R right) {
return new Tuple<>(left, right);
}
private final L left;
private final R right;
private Tuple(L left, R right) {
this.left = left;
this.right = right;
}
public L left() {
return left;
}
public R right() {
return right;
}
}
@ToString
@EqualsAndHashCode
公共类元组{
公共静态元组（左，右）{
返回新元组（左、右）；
}
二等兵，我走了；
私权；
私有元组（左左，右）{
this.left=左；
这个。右=右；
}
公共左{
左转；
}
公权{
返还权；
}
}
不适用于流。从计算的角度来看，在列表上迭代三次的操作是常量，因此忽略性能问题。保持原样，更具可读性和可测试性。如果你真的（真的）需要性能，那么通过构建你自己的统计数据和流中的If-then-else-for-eachNot-for-eachNot-for-streams来为每一个构建一个for-each。从计算的角度来看，在列表上迭代三次的操作是常量，因此忽略性能问题。保持原样，更具可读性和可测试性。如果你真的（真的）需要表现，通过构建您自己的统计数据，然后在for each中使用a for each，然后在for each中使用else，我们如何获得最小最大平均值等，这是LongSummary统计数据的属性
？但我认为我们可以使用groupingBy，而不是这里提到的元组：我已经使用了groupingBy收集器，但我在元组的左侧字段进行分组。这里使用元组是因为我需要访问用户和解析类型。我使用summingit嵌套收集器获得点的总和。让我们来看看这个课程。有许多收集器可能对您有所帮助，如：Averagint、minBy、maxBy等。元组
类型与强制执行其必要性的.map
步骤一样过时。只需使用users.stream（）.collect（Collectors.groupingBy（u->resolveType（u），Collectors.summingit（User:：getPoints））
（或users.stream（）.collector（Collectors.groupingBy（u->resolveType（u），Collectors.summaringlong（User:：getPoints））
即可获得长摘要统计数据。除此之外，我不会在resolveType
中使用流，而只是返回user.getAge（）<18？Type.MINOR:user.getGender（）==男性？成年型男性：成年型女性注意，检查=18
两次…@Holger:是的，你是对的。我刚刚习惯了使用元组（scala）。在这种情况下，Tuple+map是不必要的，但当您使用Tuple时，它会使代码更具可读性（至少对我来说）。检查如何获得min-max average etc，这是Longsummary Statistics
的属性？但我认为我们可以使用groupingBy而不是这里提到的元组：我已经使用groupingBy collector，但我使用元组的左字段分组。这里使用元组是因为我需要访问用户和解析类型。我使用summingit嵌套收集器获得点的总和。让我们来看看这个课程。有许多收集器可能对您有所帮助，如：Averagint、minBy、maxBy等。元组
类型与强制执行其必要性的.map
步骤一样过时。只需使用users.stream（）.collect（Collectors.groupingBy（u->resolveType（u），Collectors.summingit（User:：getPoints））
（或users.stream（）.collector（Collectors.groupingBy（u->resolveType（u），Collectors.summaringlong（User:：getPoints））
即可获得长摘要统计数据。除此之外，我不会在resolveType
中使用流，而只是返回user.getAge（）<18？Type.MINOR:user.getGender（）==男性？成年型男性：成年型女性注意，检查=18
两次…@Holger:是的，你是对的。我刚刚习惯了使用元组（scala）。在这种情况下，Tuple+map是不必要的，但当您使用Tuple时，它会使代码更具可读性（至少对我来说）。检查