El uso de diferentes captadores en un método

sjne:

Dado el siguiente método

public int calcSum(List<MyClass> items) {
    return items.stream()
                .mapToInt(i -> i.getHeight())
                .sum();
}

¿cuáles son mis opciones para el uso de diferentes captadores que me puede pasar en los argumentos del método para que yo no tenga que repetir la misma instrucción de retorno con getWeight()por ejemplo?

Estaba pensando tal vez utilizando un método diferente que devolvería los captadores (si eso es posible) pero estoy teniendo dificultad para pensar de una aplicación buena para eso. ¡Gracias por la ayuda!

Andy Turner:

Pasar en una ToIntFunction<T>como un parámetro:

public <T> int calcSum(List<T> items, ToIntFunction<? super T> fn) {
    return items.stream()
                .mapToInt(fn)
                .sum();
}

// Example invocations:
int heightSum = calcSum(items, MyClass::getHeight);
int weightSum = calcSum(items, MyClass::getWeight);

---

El <? super T>es AA comodín acotada (específicamente un comodín inferior-acotada ). Sólo hace que la API un poco más flexible. Por ejemplo, debido al carácter comodín, puede llamar a:

ToIntFunction<Object> constantValue = a -> 1;
int count = calcSum(items, constantValue);

Debido constantValueacepta ninguna Object, sino que también puede aceptar MyClasscasos.

Sin el límite, que no sería capaz de pasar en una ToIntFunction<Object>: para los diferentes tipos de elementos de la lista, que había necesidad de tener instancias separadas:

ToIntFunction<MyClass> constantValueForMyClass = a -> 1;
ToIntFunction<MyOtherClass> constantValueForMyOtherClass = a -> 1;
ToIntFunction<YetAnotherClass> constantValueForYetAnotherClass = a -> 1;
// ...

Que no es más tedioso y repetitivo.