Java 8 summarise durch mehr Prädikat

Question

sich die folgende pojo Klasse Lombok Anmerkungen

@Setter 
@Getter 
@Builder 
@ToString 
public class User { 
    private String firstName; 
    private String lastName; 
    private Gender gender; 
    private Integer age; 
    private Integer points; 
} 

Anforderung kommentierte Verwendung ist für folgende Prädikate LongSummaryStatistics von 'Punkten' Attribute zu erhalten:

1. Predicate<User> adultMenPredicate = user -> Gender.MALE == user.getGender && user.getAge()>18
2. Predicate<User> adultWomenPredicate = user -> Gender.FEMALE == user.getGender && user.getAge()>18
3. Predicate<User> minorPredicate = user -> user.getAge()<18

Meine aktuelle Implementierung ist:

private LongSummaryStatistics getPointStats(List<User> users, Predicate<User> predicate) { 
    return users.stream().filter(predicate).mapToLong(User::getPoints).summaryStatistics(); 
} 

System.out.println("point stats for adult men: " + getPointStats(users, adultMenPredicate)); 
System.out.println("point stats for adult women: " + getPointStats(users, adultWomenPredicate)); 
System.out.println("point stats for minors: " + getPointStats(users, minorPredicate)); 

Hier haben wir den Benutzer Sammlung dreimal iterieren. Ist es möglich, dies in nur einer Iteration zu erhalten?

Answer 1

Ich habe so etwas herausgefunden:

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 
} 

Ich denke, es ist eine ausgewogene Lösung - sehr effizient und gut lesbar. Ich mag es nicht, wenn-else-Anweisungen, damit Sie es mit Karte wie ersetzen:

private static final Map<Predicate<User>, Type> predicates = ImmutableMap.of(
     user -> user.getGender() == MALE && user.getAge() >= 18, Type.ADULT_MALE, 
     user -> user.getGender() == FEMALE && user.getAge() >= 18, Type.ADULT_FEMALE, 
     user -> user.getAge() < 18, Type.MINOR 
); 

public static Type resolveType(final User user) { 
    return predicates.entrySet().stream() 
      .filter(entry -> entry.getKey().test(user)) 
      .findFirst() 
      .map(Map.Entry::getValue) 
      .orElseThrow(RuntimeException::new); 
} 

Er druckt:

{ADULT_MALE=33, MINOR=71, ADULT_FEMALE=1} 

Ich denke, Sie müssen nicht über die Leistung, wenn Sie‘Sorge re mit großen Sammlungen zu tun haben.

// bearbeiten Nur um es klar zu machen. Meine Tuple-Implementierung sieht so aus:

@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; 
    } 
}