Taschenrechner mit mehreren Rechnungen

Diskutiere Taschenrechner mit mehreren Rechnungen im AWT, Swing, JavaFX & SWT Forum; Jetzt wird es natürlich bei mehreren aufeinanderfolgenden Rechnungen schon schwieriger. Wenn Du die Lösung von @MoxxiManagarm nimmst, sollte das...

  1. mihe7
    mihe7 Bekanntes Mitglied
    Wenn Du die Lösung von @MoxxiManagarm nimmst, sollte das bereits funktionieren. Schau Dir mal an, was bei ihm "left" ist.
     
  2. niklas551
    niklas551 Neues Mitglied
    Aaaalso, meine Überlegung jetzt:
    String Eingabe: Bsp.: 10+35-6*3
    Ich habe 2 Listen. 1.zList für die Zahlen und 2.oList für die Operatoren
    Ich hole dann alle Zahlen und speicher sie in zList und alle Operatoren in oList...
    Dann will ich auf die 1.Stelle von oList prüfen ob +-*/ und dementsprechend die 1.Stelle und 2.Stelle von zList miteinander verrechnen. Mit diesem Ergebnis dann weiterrechnen. Heißt prüft 2.Stelle von oList und verrechnet dementsprechend das Ergebnis mit der 3.Stelle von zList usw... So hab ich mir das jetzt mal gedacht, was nicht alzu komplex ist (denke ich/hoffe ich:D), aber ich tu mir da Codemäßig ein wenig schwer
    Hier einmal mein Code bisher (natürlich funktioniert er nicht)
    parsingCode (open)

    Code (Java):
    public String parsing(String input) {
            List<Double> zahlen = new ArrayList<Double>();
            List<Character> operatoren = new ArrayList<Character>();
            //1.Liste für zahlen, 2.Liste für Operatoren zu speichern
           
            String kurzInput = input.replaceAll(" ", "");
           
            //Erzeugt Array und splittet String input an allen Operatoren
            String[] zahlenArr = kurzInput.split("[\\+\\-\\*/]");
            for(int i = 0; i < zahlenArr.length; i++) {    //liest einzelne Zahlen in Array ein
                zahlen.add(Double.parseDouble(zahlenArr[i]));
            }
           
            for(int i = 0; i < input.length(); i++) {
                char op = input.charAt(i);
                if(op == '+' || op == '-' || op == '*' || op == '/'){
                    operatoren.add(op);

                }
            }
            double ergebnis = 0;
            for(int i= 0; i < zahlenArr.length; i++) {
            for(int j = 0; i <= input.length(); j++)  
                if(operatoren.indexOf(j) == '+') {
                    ergebnis = zahlen.indexOf(i) + zahlen.indexOf(i + 1);
                    labTest.setText(Double.toString(ergebnis));
                }
                else if(operatoren.indexOf(j) == '-') {
                    ergebnis = zahlen.indexOf(i) - zahlen.indexOf(i + 1);
                }
                else if(operatoren.indexOf(j) == '*') {
                    ergebnis = zahlen.indexOf(i) * zahlen.indexOf(i + 1);
                }
                else if(operatoren.indexOf(j) == '/') {
                    ergebnis = zahlen.indexOf(i) / zahlen.indexOf(i + 1);
                }
           
            }
           
           
           
            return Double.toString(ergebnis);
     
  3. MoxxiManagarm
    MoxxiManagarm Aktives Mitglied
    @mihe7 Ich bin weiblich ^^

    Code (Java):
    zahlen.add(Double.parseDouble(zahlenArr[i]));
    Die NumberFormatException solltest du schon abfangen oder werfen.

    Code (Java):
    if(op == '+' || op == '-' || op == '*' || op == '/')
    Nichts verkehrt, aber in Hinblick auf spätere weitere Operatoren empfehle ich eher sowas:
    Code (Java):
    Arrays.asList('+', '-', '*', '/').contains(op)
    Deine oder-'Liste' könnte sonst ziemlich lang werden.

    Code (Java):
    operatoren.indexOf(j)
    Sollte das nicht ein List::get sein?

    Ich bin noch verwirrt warum du auf einmal 2 Schleifen hast, erkenne das Ziel dahinter nicht und bezweifle, dass das richtig ist. Vorher sah es richtiger aus. Du rechnest nun auch immer mit 2 zahlen aus dem Array und nicht mehr mit dem Vorergebnis.
     
    niklas551 gefällt das.
  4. MoxxiManagarm
    MoxxiManagarm Aktives Mitglied
    Kleines Beispiel wie es aussehen könnte. Allerdings ist das Beispiel nun auch quick&dirty. Bitte entsprechendes Fehlerhandling ergänzen:

    Code (Java):

    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.function.DoubleBinaryOperator;
    import java.util.stream.Collectors;

    public class SimpleExpressionParser {
        private static final Map<Character, DoubleBinaryOperator> OPERATIONS = new HashMap<>();
        static {
            OPERATIONS.put('+', (o1, o2) -> o1 + o2);
            OPERATIONS.put('-', (o1, o2) -> o1 - o2);
            OPERATIONS.put('*', (o1, o2) -> o1 * o2);
            OPERATIONS.put('/', (o1, o2) -> o1 / o2);
        }
     
        public static void main(String... args) {
            String expression = "3+4-6*5";
         
            List<Double> operants = Arrays.stream(expression.split("[\\+\\*\\-/]")) // hier auch keySet verwenden
                    .map(o -> Double.parseDouble(o))
                    .collect(Collectors.toList());
         
            List<Character> operators = expression.chars()
                    .mapToObj(c -> (char)c)
                    .filter(c -> OPERATIONS.keySet().contains(c))
                    .collect(Collectors.toList());
         
            double result = operants.get(0);
         
            for(int i = 0; i < operators.size(); i++) {
                double nextOperant = operants.get(i + 1);
                char operator = operators.get(i);
             
                result = OPERATIONS.get(operator).applyAsDouble(result, nextOperant);
            }
         
            System.out.println(expression + "=" + result);
        }
    }
     
    Zuletzt bearbeitet: 10. Okt. 2018
    mihe7 und niklas551 gefällt das.
  5. niklas551
    niklas551 Neues Mitglied
    Okay, erstmal vielen Dank für deine Hilfe!!
    Dein Code funktioniert auf alle Fälle schonmal, ich versuch diesen jetzt mal etwas ,,simpler'' umzuschreiben denn vieles habe ich noch nie davon gelesen:D
    Aber auf jedenfall eine gute Hilfe auf dem Weg zum Erfolg:)
     
  6. mihe7
    mihe7 Bekanntes Mitglied
    :eek:
     
  7. niklas551
    niklas551 Neues Mitglied

    Oke, also muss leider gestehen, das mir dein Code eeetwas zu kompliziert ist... Macht für viele sicher Sinn, bin jedoch eher noch ein blutiger Anfänger und versteh das wenig bis gar nichts
     
  8. MoxxiManagarm
    MoxxiManagarm Aktives Mitglied
    Habs umgeschrieben, aber das Beibehalten der Map empfehle ich weiterhin aufgrund der Erweiterbarkeit durch weitere Operatoren.

    Code (Java):

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.function.DoubleBinaryOperator;

    public class SimpleExpressionParser {  
        private static SimpleExpressionParser instance;
           
        private final Map<Character, DoubleBinaryOperator> registeredOperations;
        private final String regex;
       
        private SimpleExpressionParser() {
            registeredOperations = new HashMap<>();
           
            // when adding operations, change here
            registeredOperations.put('+', (o1, o2) -> o1 + o2);
            registeredOperations.put('-', (o1, o2) -> o1 - o2);
            registeredOperations.put('*', (o1, o2) -> o1 * o2);
            registeredOperations.put('/', (o1, o2) -> o1 / o2);
           
            // build regular expression dynamically
            StringBuilder sb = new StringBuilder();
            sb.append("[");
            registeredOperations.keySet().forEach(sb::append);
            sb.append("]");
            regex = sb.toString();
        }
       
        // singleton Pattern
        public static SimpleExpressionParser getInstance() {
            if(instance == null) {
                instance = new SimpleExpressionParser();
            }
           
            return instance;
        }
       
        // the parsing semantic
        public double evaluate(String expression) {
            // retrieve numbers of the expression
            List<Double> numbers = new ArrayList<>();
            for(String token : expression.split(regex)) {
                numbers.add(Double.parseDouble(token));
            }

            // retrieve operators of the expression
            List<Character> operators = new ArrayList<>();
            for(int i = 0; i < expression.length(); i++) {
                char c = expression.charAt(i);
                if(registeredOperations.keySet().contains(c)) {
                    operators.add(c);
                }
            }
           
            // calculate
            double result = numbers.get(0);
            for(int i = 0; i < operators.size(); i++) {
                double nextNumber = numbers.get(i + 1);
                char operator = operators.get(i);
               
                result = registeredOperations.get(operator).applyAsDouble(result, nextNumber);
            }
           
            return result;
        }
       
        public static void main(String... args) {
            String expression = "3+4-6*8";
            double result = SimpleExpressionParser.getInstance().evaluate(expression);
           
            System.out.println(expression + "=" + result);
        }
    }

     
     
    Zuletzt bearbeitet: 10. Okt. 2018
  9. niklas551
    niklas551 Neues Mitglied
    okay, hast dein Text anscheinend nochmal geändert, weil er sieht auf jedenfall mehr komplexer aus als gestern. Aber habe jetzt dein vereinfachten Code von gestern und habe diesen mal genommen:)
    Jetzt bin ich soweit durch und muss sagen, es läuft;)
    Eine einzige Sache, welche mir fehl müsste jedoch noch implementiert werden und zwar, wenn ich 10 + 10 eingebe, dann kein Gleichheitszeichen drücke, sondern nochmal einen Operator um eine weitere Rechnung dazuzurechnen, sollte er jetzt schon das Ergebnis von 10 + 10 ausgeben... Siehe Win10 Taschenrechner.. Im Hintergunde steht die Rechnung, im Vordergrund die Teilergebnisse, sowie das gesame Ergebnis wenn man das Gleichheitszeichen betätigt
    Gruß und nochmals ein dickes Dankeschön!:)
     
  10. Hinweis: Du möchtest Java lernen? Vielleicht hilft dir dieser Kurs hier weiter. Sichere dir hier den Zugriff auf umfangreiches Java-Know How und starte richtig durch!
Die Seite wird geladen...

Taschenrechner mit mehreren Rechnungen - Ähnliche Themen

Frage zu simplem Taschenrechner(switch)
Frage zu simplem Taschenrechner(switch) im Forum Java Basics - Anfänger-Themen
Mein Taschenrechner lässt sich plötzlich nicht mehr öffnen
Mein Taschenrechner lässt sich plötzlich nicht mehr öffnen im Forum Java Basics - Anfänger-Themen
Sehr viele Exceptions bei Taschenrechner mit JavaFx
Sehr viele Exceptions bei Taschenrechner mit JavaFx im Forum AWT, Swing, JavaFX & SWT
Taschenrechner mit GUI
Taschenrechner mit GUI im Forum AWT, Swing, JavaFX & SWT
Android TaschenRechner
Android TaschenRechner im Forum Mobile Geräte
Thema: Taschenrechner mit mehreren Rechnungen