Zusatz in Java 8 mit BinaryOperator

Question

package com.operators; 

    import java.util.ArrayList; 
    import java.util.HashMap; 
    import java.util.List; 
    import java.util.Map; 
    import java.util.Scanner; 
    import java.util.function.BinaryOperator; 

    public class TotalCost { 

     public static void main(String[] args) { 
      Scanner scan = new Scanner(System.in); 
      double mealCost = scan.nextDouble(); // original meal price 
      int tipPercent = scan.nextInt(); // tip percentage 
      int taxPercent = scan.nextInt(); // tax percentage 
      scan.close(); 

      Map<Double,Double> map = new HashMap<>(); 
      map.put(mealCost, (double)tipPercent); 
      map.put(mealCost, (double)taxPercent); 

      BinaryOperator<Double> opPercent = (t1,t2) -> (t1*t2)/100; 
      BinaryOperator<Double> opSum = (t1,t2) -> (t1+t2); 
      calculation(opPercent,map); 
     } 

     public static void calculation(BinaryOperator<Double> opPercent , Map<Double,Double> map) { 
      List<Double> biList = new ArrayList<>(); 
      map.forEach((s1,s2)-> biList.add(opPercent.apply(s1, s2))); 
     } 
    } 

1. Ich habe die unten Problem, das ich in Java zu lösen versuche 8 BinaryOperator.There verwenden drei Eingänge auf diese Anwendung [mealCost (double), tipPercent (int), taxPercent (int)].

2. Ich versuche, die nachfolgenden Werte zu berechnen:

   tip = (mealCost*tipPercent)/100; 
   tax = (mealCost*taxPercent)/100; 
   TotalCost = mealCost+tip +tax; 
   

3. Ich kann einen ganzzahligen Eingabe an die Methode anwenden BinaryOperator passieren. Auch der berechnete Wert in BiList ist nicht korrekt. Unten ist mein Code

Answer 1

Sie den gleichen Schlüssel zweimal in einer Karte setzen, so dass der zweite Wert überschreibt den ersten Wert. Ich denke nicht, dass ein Map für diese Berechnungen geeignet ist. Sie können stattdessen einen List<SomePairType> verwenden.

Oder halten mealCost in einer Variablen und die anderen Werte in ein List<Double>:

public static void calculation(BinaryOperator<Double> opPercent, Double cost, List<Double> rates) { 
     List<Double> biList = new ArrayList<>(); 
     rates.forEach(d-> biList.add(opPercent.apply(cost, d))); 
    } 

Answer 2

Sie sind die Werte für den gleichen Schlüssel in der Karte setzen. Also wurde der Anfangswert durch den neuen Wert überschrieben.

Versuchen Sie den Code unten

package com.operators; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.Scanner; 
import java.util.function.BinaryOperator; 

public class TotalCost { 

    public static void main(String[] args) { 
     Scanner scan = new Scanner(System.in); 
     double mealCost = scan.nextDouble(); // original meal price 
     int tipPercent = scan.nextInt(); // tip percentage 
     int taxPercent = scan.nextInt(); // tax percentage 
     scan.close(); 

     Map<Double,Double> map = new HashMap<>(); 

     map.put(mealCost, (double)taxPercent + (double)tipPercent); 

     BinaryOperator<Double> opPercent = (t1,t2) -> (t1*t2)/100; 
     BinaryOperator<Double> opSum = (t1,t2) -> (t1+t2); 
     calculation(opPercent,map); 
    } 

    public static void calculation(BinaryOperator<Double> opPercent , Map<Double,Double> map) { 
     List<Double> biList = new ArrayList<>(); 
     map.forEach((s1,s2)-> biList.add(opPercent.apply(s1, s2))); 
    } 
} 

Answer 3

Die anderen Antworten haben Sie schon gesagt, die Ursache des Fehlers bei der Berechnung. In Bezug auf den zweiten Teil Ihrer Frage:

Ich bin nicht in der Lage eine ganze Zahl Eingabe in die Methode apply von BinaryOperator

Dies wird passieren, weil Sie erklärt haben, dass Ihr BinaryOperatorDouble als Eingabeparameter Typ und Rückgabetyp. BinaryOperator nimmt nur einen Typ als Parameter und das ist der Typ sowohl der Eingabeparameter als auch des Rückgabetyps. Wenn Sie also Double als Methodenparameter und Double als Rückgabetyp verwenden, können Sie auch BinaryOperator verwenden. Wenn Sie mehrere Typen als Parameter und Rückgabetyp haben, können Sie die Verwendung von BiFunction in Erwägung ziehen.

BiFunction<Double, Integer, Double> opPercent = (t1,t2) -> (t1*t2)/100; 

Hier sagen wir, dass die Eingangsparameter sind doppelt und Inetger zum mealCost und taxPercent entspricht, und der Rückgabetyp ist ein Doppel.

Sie können sogar Ihre eigene funktionale Schnittstelle mit mehr Anzahl von Parametern wie in Beispiel unten definieren:

public class TotalCost { 

    public static void main(String[] args) { 
     Scanner scan = new Scanner(System.in); 
     double mealCost = scan.nextDouble(); // original meal price 
     int tipPercent = scan.nextInt(); // tip percentage 
     int taxPercent = scan.nextInt(); // tax percentage 
     scan.close(); 

     TriFunction<Double, Integer, Integer, Double> calcCost = (cost, tipPct, taxPcnt) -> 
             (cost + (cost * tipPct/100) + (cost * taxPcnt/100)); 
     Double totalBill = calculation(calcCost, mealCost, tipPercent, taxPercent); 
     System.out.println(totalBill); 
    } 

    public static Double calculation(TriFunction<Double, Integer, Integer, Double> calcCost , 
             Double mealCost, Integer tipPct, Integer taxPct) { 
     return calcCost.apply(mealCost, tipPct, taxPct); 
     } 
    } 

    @FunctionalInterface 
    interface TriFunction<T,U,V,R> { 
     R apply(T t, U u, V v); 
    }