ComputerBase Menü
Aktuelles

Java Partielle Gewinnberechnung falsch?

Lol, also ist jetzt richtig == falsch? Verstehe. Danke für deinen nutzlosen Kommentar.
 
Wir sollten eventuell anfangen codeunahängig zu diskutieren.
Das hier ist FIFO und zeigt auch wieso die zeitliche Reihenfolge wichtig ist:

Code: 
+------------+-------+--------+----------------------+
|            | Preis | Anzahl | Gewinn bei Verkauf   |
+------------+-------+--------+----------------------+
| 1. Kauf    | 100   | 2      | 2*50=100             |
+------------+-------+--------+----------------------+
| 2. Kauf    | 50    | 2      | 1*100=100            |
+------------+-------+--------+----------------------+
| 3. Verkauf | 150   | -3     | 200                  |
+------------+-------+--------+----------------------+

+------------+-------+--------+----------------------+
|            | Preis | Anzahl | Gewinn bei Verkauf |
+------------+-------+--------+----------------------+
| 1. Kauf    | 50    | 2      | 2*100=200            |
+------------+-------+--------+----------------------+
| 2. Kauf    | 100   | 2      | 1*50=50              |
+------------+-------+--------+----------------------+
| 3. Verkauf | 150   | -3     | 250                  |
+------------+-------+--------+----------------------+

Passt das in deinen aktuellen Kontext? Falls nein, dann erkläre uns deinen aktuellen Kontext.
 
Zuletzt bearbeitet:
Testklasse:

Java: 
import java.util.ArrayList;
import java.util.Comparator;

public class ProfitCalculatorTest {
    private record Transaction(boolean isBuy, double price, double quantity) {
    }

    private final ArrayList<Transaction> transactions = new ArrayList<>();

    public void buy(double quantity, double price) {
        transactions.add(new Transaction(true, price, quantity));
        System.out.println("Gekauft: " + quantity + " Aktien zu " + price + " EUR.");
        System.out.println();
    }

    public void sell(double quantity, double price) {
        double[] profit = calculatePartialProfitAtPrice(quantity, price);
        transactions.add(new Transaction(false, price, quantity));
        System.out.println("Verkauft: " + quantity + " Aktien zu " + price + " EUR.");
        if (profit != null) {
            System.out.println("Partial profit: " + profit[0] + " EUR.");
            System.out.println("Percentage: " + profit[1] + " %.");
        } else {
            System.out.println("Warnung: Nicht genügend Aktien zum Verkauf vorhanden.");
        }
        System.out.println();
    }

    public double[] calculatePartialProfitAtPrice(double quantity, double price) {
        final double quoteToFind = quantity;
        double sellQuote = 0;
        double buyQuote = 0;
        for (Transaction transaction : transactions) {
            if (transaction.isBuy()) {
                buyQuote += transaction.quantity();
            } else {
                sellQuote += transaction.quantity();
            }
        }
        if (quoteToFind + sellQuote > buyQuote) {
            return null;
        }
        double openQuote = quoteToFind + sellQuote;
        ArrayList<Transaction> tempList = new ArrayList<>(transactions);
        tempList.sort(Comparator.comparing(Transaction::price));
        for (Transaction transaction : tempList) {
            if (transaction.isBuy()) {
                openQuote -= transaction.quantity();
                if (openQuote <= 0) {
                    double profit = quoteToFind * price - quoteToFind * transaction.price();
                    double percentage = (price / transaction.price() - 1.0) * 100.0;
                    return new double[]{profit, percentage};
                }
            }
        }
        return null;
    }

    public static void main(String[] args) {
        ProfitCalculatorTest calculator = new ProfitCalculatorTest();

        calculator.buy(50, 50.0);
        calculator.buy(100, 60.0);
        calculator.sell(10, 51.0);
        calculator.sell(35, 51.0);
        calculator.sell(10, 51.0); // Hier fehlt ein "Split" in der Berechnung
        calculator.sell(95, 59.0);
        calculator.sell(1, 61.0);
    }
}

Ausgabe:

Gekauft: 50.0 Aktien zu 50.0 EUR.

Gekauft: 100.0 Aktien zu 60.0 EUR.

Verkauft: 10.0 Aktien zu 51.0 EUR.
Partial profit: 10.0 EUR.
Percentage: 2.0000000000000018 %.

Verkauft: 35.0 Aktien zu 51.0 EUR.
Partial profit: 35.0 EUR.
Percentage: 2.0000000000000018 %.

Verkauft: 10.0 Aktien zu 51.0 EUR.
Partial profit: -90.0 EUR.
Percentage: -15.000000000000002 %.

Verkauft: 95.0 Aktien zu 59.0 EUR.
Partial profit: -95.0 EUR.
Percentage: -1.6666666666666718 %.

Verkauft: 1.0 Aktien zu 61.0 EUR.
Warnung: Nicht gen�gend Aktien zum Verkauf vorhanden.

Problem:

Eigentlich können ja 5 Anteile mit Gewinn verkauft werden (Zeile 66), das wird aber noch nicht berücksichtigt ...
Ergänzung ()

Wo bin ich hier schrieb:
Passt das in deinen aktuellen Kontext?
Zum Vergrößern anklicken....
Ja, siehe auch mein Beispiel in der main()-Methode ...
Ergänzung ()

Die -15.0 % stimmen doch noch nicht?
 
Zuletzt bearbeitet:
Naja, wieso sortierst du nach all den Kommentaren hier immer noch nach dem Preis?
CyborgBeta schrieb:
tempList.sort(Comparator.comparing(Transaction::price));
Zum Vergrößern anklicken....


CyborgBeta schrieb:
Eigentlich können ja 5 Anteile mit Gewinn verkauft werden (Zeile 66), das wird aber noch nicht berücksichtigt ...
Zum Vergrößern anklicken....
Du musst halt vor allem den Verkauf über mehrere Kauf-Transaktionen hinweg berücksichtigen.
Und wenn du mehrere Verkäufe hintereinander simulierst musst du den teilweisen Abverkauf berücksichtigen und auch den "Rest" in einer Kauftransaktion entsprechend aktualisieren bzw die Transaktion dann komplett entfernen.
All das war in meinem Codeschnipsel (auf dem ersten Blick) schon mit dabei:
https://www.computerbase.de/forum/threads/partielle-gewinnberechnung-falsch.2223552/#post-30115136
 
  • Gefällt mir
Reaktionen: CyborgBeta
Wo bin ich hier schrieb:
Naja, wieso sortierst du nach all den Kommentaren hier immer noch nach dem Preis?
Zum Vergrößern anklicken....
Weil sich anhand der Transaktionen mit den niedrigsten Preisen der Profit orientiert (vorausgesetzt, sie wurden noch nicht "realisiert", also vorher verkauft).
Ergänzung ()

Jetzt passt es:

Java: 
import java.util.ArrayList;
import java.util.Comparator;

public class ProfitCalculatorTest {
    private record Transaction(boolean isBuy, double price, double quantity) {
    }

    private final ArrayList<Transaction> transactions = new ArrayList<>();

    public void buy(double quantity, double price) {
        transactions.add(new Transaction(true, price, quantity));
        System.out.println("Gekauft: " + quantity + " Aktien zu " + price + " EUR.");
        System.out.println();
    }

    public void sell(double quantity, double price) {
        double[] profit = calculatePartialProfitAtPrice(quantity, price);
        transactions.add(new Transaction(false, price, quantity));
        System.out.println("Verkauft: " + quantity + " Aktien zu " + price + " EUR.");
        if (profit != null) {
            System.out.println("Partial profit: " + profit[0] + " EUR.");
            System.out.println("Percentage: " + profit[1] + " %.");
        } else {
            System.out.println("Warnung: Nicht genügend Aktien zum Verkauf vorhanden.");
        }
        System.out.println();
    }

    public double[] calculatePartialProfitAtPrice(double quantity, double price) {
        final double quoteToFind = quantity;
        double sellQuote = 0;
        double buyQuote = 0;
        for (Transaction transaction : transactions) {
            if (transaction.isBuy()) {
                buyQuote += transaction.quantity();
            } else {
                sellQuote += transaction.quantity();
            }
        }
        if (quoteToFind + sellQuote > buyQuote) {
            return null;
        }
        double openQuote1 = sellQuote;
        double openQuote2 = quoteToFind;
        double profit = 0;
        ArrayList<Transaction> tempList = new ArrayList<>(transactions);
        tempList.sort(Comparator.comparing(Transaction::price));
        for (Transaction transaction : tempList) {
            if (transaction.isBuy()) {
                openQuote1 -= transaction.quantity();
                if (openQuote1 <= 0) {
                    if (transaction.quantity() <= openQuote2) {
                        profit += transaction.quantity() * (price - transaction.price());
                        openQuote2 -= transaction.quantity();
                    } else {
                        profit += openQuote2 * (price - transaction.price());
                        return new double[]{profit, (quoteToFind * price + profit) / (quoteToFind * price) * 100 - 100};
                    }
                }
            }
        }
        return null;
    }

    public static void main(String[] args) {
        ProfitCalculatorTest calculator = new ProfitCalculatorTest();

        calculator.buy(100, 60.0);
        calculator.buy(50, 50.0);
        calculator.sell(55, 51.0); // 0.178 %
        calculator.sell(10, 61.0); // 1.64 %
        calculator.sell(84, 59.0); // -1.69 %
        calculator.sell(0.1, 61.0); // 1.64 %
        calculator.sell(1, 61.0); // not enough stocks
    }
}

Ich bin mit aber bei der Prozentberechnung noch unsicher: (quoteToFind * price + profit) / (quoteToFind * price) * 100 - 100

Könnte mir bitte jemand sagen, ob das richtig ist?
Ergänzung ()

Hm, offenbar nicht, wie das folgende, einfachere Beispiel zeigt:

Java: 
    public static void main(String[] args) {
        ProfitCalculatorTest calculator = new ProfitCalculatorTest();

        calculator.buy(100, 60.0);
        calculator.buy(50, 50.0);
        calculator.sell(45, 50);
        calculator.sell(20, 60); // 20 * 60 = 1200 vs. 5 * 50 + 15 * 60 = 1150 <=> sollte 4.3 % sein, ist aber 16.7 % => Fehler
        calculator.sell(84, 60);
        calculator.sell(0.1, 60);
        calculator.sell(0.9, 60);
    }
 
Zuletzt bearbeitet:
Zuvor noch ein anderes Problem in Richtung teilweiser Abverkauf:
Java: 
calculator.buy(100, 60.0);
calculator.buy(50, 50.0);
calculator.sell(20, 51.0);
calculator.sell(20, 51.0);
calculator.sell(20, 51.0);

gibt aus:
Gekauft: 100.0 Aktien zu 60.0 EUR.
Gekauft: 50.0 Aktien zu 50.0 EUR.

Verkauft: 20.0 Aktien zu 51.0 EUR.
Partial profit: 20.0 EUR.
Percentage: 1.9607843137254832 %.

Verkauft: 20.0 Aktien zu 51.0 EUR.
Partial profit: 20.0 EUR.
Percentage: 1.9607843137254832 %.

Verkauft: 20.0 Aktien zu 51.0 EUR.
Partial profit: 20.0 EUR.
Percentage: 1.9607843137254832 %.
 
  • Gefällt mir
Reaktionen: CyborgBeta
Wo bin ich hier schrieb:
Zuvor noch ein anderes Problem in Richtung teilweiser Abverkauf
Zum Vergrößern anklicken....
Ja, die Prozentberechnung stimmt nicht, vermute ich.
 
Der angegebene "Partial profit: 20.0 EUR." ist doch bereits daneben?
Du hast 10*1 + 10*-9 = -80.
 
  • Gefällt mir
Reaktionen: CyborgBeta
Und hier if (transaction.quantity() <= openQuote2) {
solte nur if (transaction.quantity() < openQuote2) {
stehen. Aber daran liegt's aktuell nicht
Ergänzung ()

Wo bin ich hier schrieb:
Der angegebene "Partial profit: 20.0 EUR." ist doch bereits daneben?
Du hast 10*1 + 10*-9 = -80.
Zum Vergrößern anklicken....
Stimmt: 20*51 - (10*50 + 10*60) = -80
Ergänzung ()

Ich glaube, ich sollte das mehr "low-level" angehen, und nicht direkt den Profit berechnen, sondern erstmal die Partialsummen sammeln.

Aber mir brummt schon der Kopf, ich versuche das morgen nochmal.
 
Zuletzt bearbeitet:
Fachlich habe ich keine Lust, mich damit auseinanderzusetzen. Aber wenn du in Java mit Geldbeträgen hantierst, nimm niemals double, sondern BigDecimal.
 
  • Gefällt mir
Reaktionen: cbmik, kuddlmuddl, BeBur und eine weitere Person
mental.dIseASe schrieb:
nimm niemals double, sondern BigDecimal
Zum Vergrößern anklicken....
Diesmal geht es nicht um Genauigkeit ... da reichen schon zwei Prozentnachkommastellen. Der kumulative Fehler dürfte auch bei ca. 10 Transaktionen nicht allzu hoch sein.

mental.dIseASe schrieb:
Fachlich habe ich keine Lust, mich damit auseinanderzusetzen
Zum Vergrößern anklicken....
Selbstverständlich dein gutes recht. Aber nicht beleidigend werden.
 
Taa! Jetzt funktioniert alles so, wie ich mir das vorgestellt hatte ...

An zwei Dinge wurde nicht gedacht:

  • Es muss eine temporäre Listenkopie erstellt werden, und alle "verbrauchten" Transaktionen müssen gelöscht werden.
  • Sobald die Menge der Aktien einmal leer ist, müssen alle Transaktionen gelöscht werden, damit mit einer neuen Liste begonnen werden kann - es ist nicht möglich, das auf anderem Weg "auseinander zu rechnen".

Java: 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;

public class ProfitCalculatorTest {
    private record Transaction(boolean isBuy, double price, double quantity) {
    }

    private final ArrayList<Transaction> transactions = new ArrayList<>();

    public void buy(double quantity, double price) {
        transactions.add(new Transaction(true, price, quantity));
        System.out.println("Gekauft: " + quantity + " Aktien zu " + price + " EUR.");
        System.out.println();
    }

    public void sell(double quantity, double price) {
        double[] profit = calculatePartialProfitAtPrice(quantity, price);
        if (profit != null) {
            transactions.add(new Transaction(false, price, quantity));
            if (isQuoteEmpty()) {
                // New epoch: all quotes are sold
                transactions.clear();
            }
            System.out.println("Verkauft: " + quantity + " Aktien zu " + price + " EUR.");
            System.out.println("Partial profit: " + profit[0] + " EUR.");
            System.out.println("Percentage: " + profit[1] + " %.");
        } else {
            System.out.println("Warnung: Nicht genügend Aktien zum Verkauf vorhanden.");
        }
        System.out.println();
    }

    public boolean isQuoteEmpty() {
        double sellQuote = 0;
        double buyQuote = 0;
        for (Transaction transaction : transactions) {
            if (transaction.isBuy()) {
                buyQuote += transaction.quantity();
            } else {
                sellQuote += transaction.quantity();
            }
        }
        double e = 0.001;
        return sellQuote + e >= buyQuote;
    }

    public double[] calculatePartialProfitAtPrice(double quantity, double price) {
        final double quoteToFind = quantity; // The total amount of quotes to find
        // Calculate the total amount of bought and sold quotes
        double sellQuote = 0;
        double buyQuote = 0;
        for (Transaction transaction : transactions) {
            if (transaction.isBuy()) {
                buyQuote += transaction.quantity();
            } else {
                sellQuote += transaction.quantity();
            }
        }
        // If the total amount of sold quotes is greater than the total amount of bought quotes, return null, because the transaction is invalid
        if (quoteToFind + sellQuote > buyQuote) {
            return null;
        }
        // Create a temporary list of transactions and sort it by price
        ArrayList<Transaction> tempList = new ArrayList<>(transactions);
        tempList.sort(Comparator.comparing(Transaction::price));
        // Remove the bought quotes from the list until the total amount of sold quotes is reached
        double open = sellQuote;
        for (Iterator<Transaction> iterator = tempList.iterator(); iterator.hasNext(); ) {
            Transaction transaction = iterator.next();
            iterator.remove();
            if (transaction.isBuy()) {
                if (open > transaction.quantity()) {
                    open -= transaction.quantity();
                } else {
                    tempList.addFirst(new Transaction(true, transaction.price(), transaction.quantity() - open));
                    break;
                }
            }
        }
        // Calculate the profit
        open = quoteToFind;
        double profit = 0;
        for (Transaction transaction : tempList) {
            if (transaction.isBuy()) {
                if (open > transaction.quantity()) {
                    open -= transaction.quantity();
                    profit += transaction.quantity() * (price - transaction.price());
                } else {
                    profit += open * (price - transaction.price());
                    return new double[]{profit, (quoteToFind * price + profit) / (quoteToFind * price) * 100 - 100};
                }
            }
        }
        // Should never be reached
        return null;
    }

    public static void main(String[] args) {
        ProfitCalculatorTest calculator = new ProfitCalculatorTest();

        calculator.buy(100, 60.0);
        calculator.buy(50, 50.0);
        calculator.sell(20, 50);
        calculator.sell(20, 50);
        calculator.sell(110, 60);

        calculator.sell(1, 60);

        calculator.buy(100, 60.0);
        calculator.buy(50, 50.0);
        calculator.sell(20, 50);
        calculator.sell(20, 50);
        calculator.sell(20, 50);
        calculator.sell(80, 60);

        calculator.sell(100, 60);

        calculator.buy(100, 65.0);
        calculator.sell(110, 65);

        calculator.sell(0.01, 65);
    }
}
Ergänzung ()

🤔 Es ginge vielleicht auch, ohne die Transaktionsliste bei 0 zu leeren ... wenn man noch eine "Voruntersuchung" der Liste machen würde, aber das ist mir irgendwie zu aufwändig. Man müsste eben vorher alle "Nullstellen" ermitteln, und dann ab der zeitlich letzten Nullstelle beginnen.

ChatGPT hat im Prinzip auch recht (ich bekam von ChatGPT übrigens die gleiche Antwort), aber das Problem an dem ChatGPT-Code ist, dass die Berechnung nicht anhand des FIFO-Prinzips erfolgen sollte, bzw. dadurch falsch ist.
 
Zuletzt bearbeitet:
  • Gefällt mir
Reaktionen: Wo bin ich hier
Ta! Noch mal etwas einfacher und ohne alte Transaktionen zu leeren:

Java: 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.function.Predicate;

public class ProfitCalculatorTest {
    private record Transaction(boolean isBuy, double price, double quantity) {
    }

    private final ArrayList<Transaction> transactions = new ArrayList<>();

    public void buy(double quantity, double price) {
        transactions.add(new Transaction(true, price, quantity));
        System.out.println("Gekauft: " + quantity + " Aktien zu " + price + " EUR.");
        System.out.println();
    }

    public void sell(double quantity, double price) {
        double[] profit = calculatePartialProfitAtPrice(quantity, price);
        if (profit != null) {
            transactions.add(new Transaction(false, price, quantity));
            System.out.println("Verkauft: " + quantity + " Aktien zu " + price + " EUR.");
            System.out.println("Partial profit: " + profit[0] + " EUR.");
            System.out.println("Percentage: " + profit[1] + " %.");
        } else {
            System.out.println("Warnung: Nicht genug Aktien zum Verkauf vorhanden.");
        }
        System.out.println();
    }

    private ArrayList<Transaction> removeOldTransactions() {
        ArrayList<Transaction> tempList = new ArrayList<>(transactions);
        double sum = 0;
        a:
        while (true) {
            for (int i = 0; i < tempList.size(); i++) {
                Transaction transaction = tempList.get(i);
                if (transaction.isBuy()) {
                    sum += transaction.quantity();
                } else {
                    sum -= transaction.quantity();
                }
                if (sum <= 0.0000001) {
                    tempList = new ArrayList<>(tempList.subList(i + 1, tempList.size()));
                    sum = 0;
                    continue a;
                }
            }
            break;
        }
        return tempList;
    }

    public double[] calculatePartialProfitAtPrice(double quantity, double price) {
        final double quoteToFind = quantity; // The total amount of quotes to find
        // Get a copy of the transactions list without the old transactions
        ArrayList<Transaction> tempList = removeOldTransactions();
        // Calculate the total amount of bought and sold quotes
        double sellQuote = tempList.stream().filter(Predicate.not(Transaction::isBuy)).mapToDouble(Transaction::quantity).sum();
        double buyQuote = tempList.stream().filter(Transaction::isBuy).mapToDouble(Transaction::quantity).sum();
        // If the total amount of sold quotes is greater than the total amount of bought quotes, return null, because the transaction is invalid
        if (quoteToFind + sellQuote > buyQuote) {
            return null;
        }
        // Sort the list by price to get the lowest prices first
        tempList.sort(Comparator.comparing(Transaction::price));
        // Remove the bought quotes from the list until the total amount of sold quotes is reached
        double open = sellQuote;
        for (Iterator<Transaction> iterator = tempList.iterator(); iterator.hasNext(); ) {
            Transaction transaction = iterator.next();
            iterator.remove();
            if (transaction.isBuy()) {
                if (open > transaction.quantity()) {
                    open -= transaction.quantity();
                } else {
                    tempList.addFirst(new Transaction(true, transaction.price(), transaction.quantity() - open));
                    break;
                }
            }
        }
        // Calculate the profit
        open = quoteToFind;
        double profit = 0;
        for (Transaction transaction : tempList) {
            if (transaction.isBuy()) {
                if (open > transaction.quantity()) {
                    open -= transaction.quantity();
                    profit += transaction.quantity() * (price - transaction.price());
                } else {
                    profit += open * (price - transaction.price());
                    return new double[]{profit, (quoteToFind * price + profit) / (quoteToFind * price) * 100 - 100};
                }
            }
        }
        // Should never be reached
        return null;
    }

    public static void main(String[] args) {
        ProfitCalculatorTest calculator = new ProfitCalculatorTest();

        calculator.buy(100, 60.0);
        calculator.buy(50, 50.0);
        calculator.sell(20, 50);
        calculator.sell(20, 50);
        calculator.sell(110, 60);

        calculator.sell(1, 60);

        calculator.buy(100, 60.0);
        calculator.buy(50, 50.0);
        calculator.sell(20, 50);
        calculator.sell(20, 50);
        calculator.sell(20, 50);
        calculator.sell(80, 60);

        calculator.sell(100, 60);

        calculator.buy(100, 65.0);
        calculator.sell(110, 65);

        calculator.sell(0.01, 65);
    }
}
 
Ein paar Anmerkungen, die nur meine persönliche Meinung zum Code darstellen.
  • Zeile 31: der Name ist nicht gut gewählt. Du entfernst zwar alte Transaktionen, aber "alt" ist ein weit gefasster Begriff. Ich würde dort irgendwo ein Datum erwarten. Meiner Meinung nach würde ich sowas wie "getRelevantTransactions" bevorzugen.
  • Zeile 34: ich würde wahrscheinlich statt dem Label eine bool Variable bevorzugen
  • Zeile 44: Erstell die neue ArrayList erst nachdem du den relevanten Teil gefunden hast, also in Zeile 51. Mit subList() bekommst du doch eine schöne Sicht auf den relevanten Teil. Brauchst nicht jedes mal ein neue Liste machen. Wahrscheinlich kannst du dir auch nur den Startindex für den relevanten Teil merken und die Summe auf 0 setzen und dann einfach weiter durchgehen. Spart dir die while Schleife außen rum.
 
  • Gefällt mir
Reaktionen: CyborgBeta
Danke für die Vorschläge.

In der Tat, removeOldTransactions/getRelevantTransactions ginge einfacher. Vielleicht wäre da auch ein Stream-Konstrukt denkbar, aber ich bin eigentlich kein Fan davon, alles "durchzustreamen"...
 
@marcOcram besser?:

Java: 
    private ArrayList<Transaction> getRelevantTransactions() {
        ArrayList<Transaction> tempList = new ArrayList<>(transactions);
        double sum = 0;
        int lastZeroIndex = -1;
        for (int i = 0; i < tempList.size(); i++) {
            Transaction transaction = tempList.get(i);
            if (transaction.isBuy()) {
                sum += transaction.quantity();
            } else {
                sum -= transaction.quantity();
            }
            if (sum <= 0.0000001) {
                sum = 0;
                lastZeroIndex = i;
            }
        }
        return lastZeroIndex == -1 ? tempList : new ArrayList<>(tempList.subList(lastZeroIndex + 1, tempList.size()));
    }

Copilot schlägt folgende Stream-/Lambda-Variante vor:

Java: 
private ArrayList<Transaction> getRelevantTransactions() {
    ArrayList<Transaction> tempList = new ArrayList<>(transactions);
    double[] sum = {0};
    int[] lastZeroIndex = {-1};

    IntStream.range(0, tempList.size()).forEach(i -> {
        Transaction transaction = tempList.get(i);
        if (transaction.isBuy()) {
            sum[0] += transaction.quantity();
        } else {
            sum[0] -= transaction.quantity();
        }
        if (sum[0] <= 0.0000001) {
            sum[0] = 0;
            lastZeroIndex[0] = i;
        }
    });

    return lastZeroIndex[0] == -1 ? tempList : new ArrayList<>(tempList.subList(lastZeroIndex[0] + 1, tempList.size()));
}
 
@CyborgBeta sieht besser aus. Zeile 2 sieht unnötig aus. Brauchst keine temporäre Liste. In Zeile 4 solltest du überlegen ob der default von -1 sinnvoll ist. Meiner Meinung nach benötigst du den nicht. Zeile 19 wird dann auch einfacher.

Die Variante von Copilot kommentiere ich mal nicht :)
 
  • Gefällt mir
Reaktionen: CyborgBeta
Ja, stimmt, die Liste muss dort noch nicht umverpackt werden ... und -1 darf 0 sein.

Jetzt ist's schon in Production geflossen. Ich merke mir das mal vor fürs nächste Refactoring.

Bezüglich Copilot ... eigentlich hat er nur das gemacht (clean), wonach ich gefragt hatte. :D
 
Die Variante funktioniert auch. Es ist halt ein gutes Beispiel für "wann man Streams nicht nutzen sollte". Copilot nutzt sogar Arrays weil das wahrscheinlich schneller ist und vom Compiler einfacher referenziert werden kann. Aber die Lesbarkeit...
 
Du musst dich einloggen oder registrieren, um hier zu antworten.

Ähnliche Themen

L
SSD mit VMFS. Partition gerettet. VMDK nicht zu finden. Blockgröße falsch?
Antworten
11
Aufrufe
2.175
Holt
H
A
HDD geometrie falsch und "following partition can´t be recovered"
Antworten
2
Aufrufe
1.654
ACID25
A
F
Festplatte falsch gejumpert - nun Partion und alle Daten weg
Antworten
9
Aufrufe
1.446
Fiona
F
B
Festplatte falsch gejumpert dann Partitionen weg
Antworten
9
Aufrufe
1.476
Frieh
F
Zurück
Oben

Willkommen auf ComputerBase!

Mit Werbung weiterlesen

Besuche ComputerBase wie gewohnt mit Werbung und Tracking. Die Zustimmung ist jederzeit widerrufbar.

Details im Privacy Center und in der Liste unserer Partner. Ein Widerruf ist möglich in der Datenschutzerklärung.

… oder ComputerBase Pro bestellen

Nutze ComputerBase ohne Werbebanner, Video-Ads und Werbetracking schon für 4 €/Monat oder 36 €/Jahr.

Mehr zu ComputerBase Pro

Bereits Pro-Nutzer? Hier anmelden.

Tracking: Wir und unsere 160 Partner verarbeiten personenbezogene Daten, indem wir mit auf Ihrem Gerät gespeicherten Informationen (z. B. eindeutige Kennungen in Cookies) ein Nutzungsprofil erstellen, um z. B. Anzeigen zu personalisieren. Verarbeitungszwecke: Genaue Standortdaten und Abfrage von Geräteeigenschaften zur Identifikation, Informationen auf einem Gerät speichern und/oder abrufen, Personalisierte Anzeigen und Inhalte, Anzeigen- und Inhaltsmessungen, Erkenntnisse über Zielgruppen und Produktentwicklungen.

Impressum Kontakt Datenschutz