BinaryOperator - Java 8

Il s'agit d'une interface fonctionnelle et peut donc être utilisée comme cible d'affectation pour une expression lambda ou une référence de méthode. La définition d'un BinaryOperator est "T apply(T t1, T t2)". Le BinaryOperator a en argument et en retour le même type.

public interface BinaryOperator<T> extends BiFunction<T,T,T>

Cette interface contient deux méthodes que nous détaillerons plus tard :

public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator);
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator);

En étendant l'interface BiFunction, l'interface BinaryOperator hérite des méthodes suivantes :

R apply(T t, U u);
default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after);

1. Exemple du BinaryOperator

Dans cette exemple nous alors utiliser le type Long. Par conséquent, on aura BinaryOperator<Long> qui étendra la classe BiFunction avec la déclaration BiFunction<Long, Long, Long>. On préfèrera utiliser la classe BiFunction uniquement si les types en entrée/sortie sont différents.

// BiFunction
final BiFunction<Long, Long, Long> biFunction = (a, b) -> a + b;
System.out.println(biFunction.apply(8L, 10L)); // 18

// BinaryOperator
final BinaryOperator<Long> binaryOperator = (a, b) -> a + b;
System.out.println(binaryOperator.apply(8L, 10L)); // 18

2. BinaryOperator en tant qu'argument

public static void main(final String[] args) {
    final List<Long> myList = Arrays.asList(8L, 5L, 3L);
    final BinaryOperator<Long> binaryOperator = (a, b) -> a + b;

    System.out.println(BinaryOperationTest.add(myList, (a, b) -> a + b, 0L)); // 16
    System.out.println(BinaryOperationTest.add(myList, binaryOperator, 0L)); // 16

}

public static <T> T add(final List<T> theList, final BinaryOperator<T> binaryOperator, final T init) {
    T result = init;
    for (final T list : theList) {
        result = binaryOperator.apply(result, list);
    }
    return result;
}

Remarque : On peut noter qu'il y a une transformation automatique entre une expression lambda et son équivalent, ici BinaryOperator.

3. Utilisation de LongBinaryOperator

Quelques type primitifs ont leurs propre BinaryOperator, c'est le cas pour les entiers, les double et les long.

public static Long add(final List<Long> theList, final LongBinaryOperator binaryOperator, final Long init) {
    Long result = init;
    for (final Long list : theList) {
        result = binaryOperator.applyAsLong(result, list);
    }
    return result;
}

public static void main(final String[] args) {
    final List<Long> myList = Arrays.asList(8L, 5L, 3L);
    final LongBinaryOperator binaryOperator = (a, b) -> a + b;

    System.out.println(BinaryOperationTest.add(myList, (a, b) -> a + b, 0L)); // 16
    System.out.println(BinaryOperationTest.add(myList, binaryOperator, 0L)); // 16

}

4. Les méthodes minBy et maxBy

Comme vu précédemment, ces deux méthodes sont disponibles dans l'interface BinaryOperator. Elles prennent en entrée un comparator afin de récupérer le min ou le max.

 Création de la classe DVD :

public class DVD {
    private final String title;
    private final Integer sold;

    public DVD(final String title, final Integer sold) {
        super();
        this.title = title;
        this.sold = sold;
    }

 // ...
}

Récupération du min et du max de l'objet DVD créé ci-dessous à l'aide du champ "sold".

public static DVD find(final List<DVD> theList, final BinaryOperator<DVD> theBinaryOperator) {
    DVD result = null;
    for (final DVD theDVD : theList) {
        if (result == null) {
            result = theDVD;
        } else {
            result = theBinaryOperator.apply(result, theDVD);
        }
    }
    return result;
}

public static void main(final String[] args) {
    final List<DVD> list = Arrays.asList(new DVD("A", 6), new DVD("B", 60), new DVD("C", 3), new DVD("D", 40), new DVD("E", 20));
    final Comparator<DVD> comparing = Comparator.comparing(DVD::getSold);

    // max
    final BinaryOperator<DVD> maxBo = BinaryOperator.maxBy(comparing);
    System.out.println(BinaryOperationTest.find(list, maxBo).getSold()); // 60

    // min
    final BinaryOperator<DVD> minBo = BinaryOperator.minBy(comparing);
    System.out.println(BinaryOperationTest.find(list, minBo).getSold()); // 3
}