Lära Binaryoperator: Kombinera Två Värden

Svep för att visa menyn

Detta interface är särskilt användbart när man kombinerar två värden av samma typ, såsom vid matematiska beräkningar eller sammanfogning av data.

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
    T apply(T t1, T t2);
}

BinaryOperator<T>-interfacet utökar BiFunction<T, T, T>, men till skillnad från BiFunction måste både inmatningsargumenten och returvärdet alltid vara av samma typ T.

Dess enda abstrakta metod, apply(T t1, T t2), utför en operation på två argument och returnerar resultatet.

Praktiskt exempel

Anta att du har ett lönesystem där du behöver avgöra vilken av två bonusar — årlig eller kvartalsvis — som är högst så att det större beloppet kan tilldelas en anställd.

Main.java


              123456789101112131415
            
package com.example;

import java.util.function.BinaryOperator;

public class Main {
    public static void main(String[] args) {
        BinaryOperator<Double> maxBonus = (bonus1, bonus2) -> Math.max(bonus1, bonus2);

        double annualBonus = 5000.0;
        double quarterlyBonus = 1500.0;

        double finalBonus = maxBonus.apply(annualBonus, quarterlyBonus);
        System.out.println("Awarded Bonus: " + finalBonus);
    }
}

I detta exempel skapas en BinaryOperator<Double> som använder Math.max() för att jämföra två värden och returnera det större.

Därefter definieras två bonusar: annualBonus (årlig bonus) och quarterlyBonus (kvartalsbonus).

Metoden apply() anropas för att avgöra den högsta bonusen, och resultatet skrivs ut till konsolen. Denna metod är användbar när det finns behov av att dynamiskt välja det bästa alternativet utan komplex villkorslogik.

Statisk metoder

Förutom sin primära apply() metod innehåller BinaryOperator<T> flera användbara statiska metoder:

maxBy(Comparator<T> comparator) – returnerar en BinaryOperator<T> som väljer det större av två värden baserat på den angivna Comparator<T>;
minBy(Comparator<T> comparator) – returnerar en BinaryOperator<T> som väljer det mindre av två värden baserat på den angivna Comparator<T>.

Exempel på användning

Anta att du har ett personalhanteringssystem där du behöver avgöra vilken av två kandidater som har ett högre betyg för att välja den bästa för en befordran.

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.Comparator;
import java.util.function.BinaryOperator;

public class Main {
    public static void main(String[] args) {
        BinaryOperator<Employee> topPerformer =
                BinaryOperator.maxBy(Comparator.comparingInt(Employee::getRating));

        Employee employee1 = new Employee("John", 85);
        Employee employee2 = new Employee("Sarah", 90);

        Employee bestEmployee = topPerformer.apply(employee1, employee2);
        System.out.println("Top employee: " + bestEmployee.getName());
    }
}

class Employee {
    private String name;
    private int rating;

    public Employee(String name, int rating) {
        this.name = name;
        this.rating = rating;
    }

    public String getName() {
        return name;
    }

    public int getRating() {
        return rating;
    }
}

BinaryOperator.maxBy() metod tar en Comparator<Employee>, som använder Employee::getRating för att jämföra anställda baserat på deras betyg.

Två Employee objekt skapas med olika betyg. apply() metod väljer den anställde med det högsta betyget och skriver ut deras namn.