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 extends BiFunction

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

public static  BinaryOperator minBy(Comparator comparator);
public static  BinaryOperator maxBy(Comparator comparator);

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

R apply(T t, U u);
default  BiFunction andThen(Function after);

 

1. Exemple du BinaryOperator

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

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

// BinaryOperator
final BinaryOperator 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 myList = Arrays.asList(8L, 5L, 3L);
    final BinaryOperator 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 add(final List theList, final BinaryOperator 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 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 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 theList, final BinaryOperator 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 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 comparing = Comparator.comparing(DVD::getSold);

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

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