Mit Zahlen im String rechnen

Lasnik

Mitglied
Angenommen ich habe einen String, zum Beispiel "Solve: 5 + 7". Die beiden Zahlenwerte (5 und 7) können jedes Mal variieren, auch die Rechenoperation kann variieren (es könnte also genauso gut "Solve: 334 * 1000" heißen).
Wie würde ich jetzt diese beiden Werte aus dem String nehmen und mit ihnen rechnen.
Wenn es nicht allzu kompliziert ist, wäre mir am Liebsten noch weitere Zahlen und Rechenoperationen hinzuzufügen.

Ich denke mal ein sehr simples Problem, dennoch habe ich beim googeln leider nichts brauchbares gefunden.
 

fhoffmann

Top Contributor
Ich denke mal ein sehr simples Problem
Das ist leider falsch. Das Problem ist ziemlich kompliziert. Du musst (zumindestens wenn du auch kompliziertere Formeln wie 27 * (5 + 4) betrachten willst, einen "Parser" schreiben. Dazu solltest du ein Buch über Compilerbau hinzuziehen.

Falls du wirklich nur einfache Operationen mit zwei Zahlen, zwischen denen ein Rechenzeichen steht, betrachten willst, kannst du den String mit einem regulären Ausdruck in seine drei (ohne das Solve:) Teile zerlegen und damit die Rechnung ausführen.
 

JennyL

Bekanntes Mitglied
Wie zerlege ich mir die Rechnung in einzelne Teile?
Das Rad muss doch nicht neu erfunden werden...
Code:
		<dependency>
			<groupId>org.mariuszgromada.math</groupId>
			<artifactId>MathParser.org-mXparser</artifactId>
			<version>4.4.2</version>
		</dependency>
Java:
import java.util.Scanner;

import org.mariuszgromada.math.mxparser.Expression;
import org.mariuszgromada.math.mxparser.parsertokens.Token;

public class ME1 {
	public static void main(String[] args) {
		System.out.println("Solve:");
		@SuppressWarnings("resource")
		String e = new Scanner(System.in).nextLine();
		Expression e2 = new Expression(e);
		int i = 0;
		double a = -1;
		double b = -1;
		char op = ' ';
		for (Token token : e2.getCopyOfInitialTokens()) {
			System.out.println(token.tokenStr);
			if (token.tokenTypeId == 0) {
				if (i == 0) {
					a = token.tokenValue;
				}
				if (i == 2) {
					b = token.tokenValue;
				}
			}
			if (token.tokenTypeId == 1) {
				op = token.tokenStr.charAt(0);
			}
			if (i == 2) {
				if (op == '+') {
					a += b;
				}
				// etc.
				i = 1;
			} else {
				i++;
			}
		}
		System.out.println(a);
		System.out.println("Proof: " + e2.calculate());
	}
}
Code:
Solve:
1+2+3
1
+
2
+
3
6.0
Proof: 6.0
 

TM69

Bekanntes Mitglied
Dann verwende doch die split-Funktion von String.

Code:
String text = "3 * 5";
text.split("*");

alternativ auch mit regex.
 
G

Gelöschtes Mitglied 9001

Gast
Formelparser zu schreiben ist meine Lieblingsbeschäftigung :)
Wenn du es selbst machen willst, hier ein paar Gedankenanstöße:

-zerlege den String in sinnvolle Einheiten (sog. Tokens), das sind: Zahlen, Operatoren, Klammern, evtl. Funktionsnamen. Packe sie auf einen Stapel.
-eine Formel ist immer eine Summe
-eine Summe besteht aus einem oder mehreren Summanden, zwischen denen ein + oder - ist
-ein Summand ist ein Produkt
-ein Produkt besteht aus einem oder mehreren Faktoren zwischen denen ein * oder / ist
-ein Faktor ist eine Potenz
-eine Potenz besteht aus einer Basis und ggf. einem oder mehreren Exponenten, zwischen denen ein ^ ist
-Basis und Exponenten sind Operanden
-ein Operand ist
eine Zahl oder
eine Summe, die in Klammern eingeschlossen ist oder
ein Funktionsname mit einer in Klammern eingeschlossenen Summe

Schreibe für Summe, Produkt, Potenz, Operand jeweils eine Methode.

Die Summe könnte so aussehen:
Code:
Methode Summe():
    ergebnis = Produkt()
    t = nächstesToken()
    solange t + oder - ist:
          summand = Produkt()
          wenn t +: ergebnis += summand
          wenn t -: ergebnis -= summand
          t = nächstesToken()
    lege t zurück auf den Stapel
    return ergebnis
So bzw. so ähnlich dann für Produkt und Potenz. Man kann das Konzept nach Belieben erweitern um boolesche Operatoren, verschiedene Datentypen etc. Grundgedanke dieses sog. Top-down-Parsers ist, dass mit den niederwertigsten Operationen begonnen wird (eine Summe ist niederwertiger als ein Produkt, denn „Punktrechnung geht vor Strichrechnung“)
Viel Spaß!
 
Zuletzt bearbeitet von einem Moderator:
G

Gelöschtes Mitglied 9001

Gast
...das Zerlegen eines Strings in Tokens kann im einfachsten Fall mit text.split("\s+") geschehen, d.h. aufteilen an Leerzeichen. Dann muss aber bei den Formeln vor und nach jeder Zahl, jedem Operator, jeder Klammer, jedem Funktionsnamen ein Leerzeichen stehen.
 

temi

Top Contributor
...das Zerlegen eines Strings in Tokens kann im einfachsten Fall mit text.split("\s+") geschehen, d.h. aufteilen an Leerzeichen. Dann muss aber bei den Formeln vor und nach jeder Zahl, jedem Operator, jeder Klammer, jedem Funktionsnamen ein Leerzeichen stehen.
Da es sich höchst wahrscheinlich um eine Übung handelt wird das wohl der gesuchte Weg sein. Anschließend kann man die beiden Strings mit den Ziffern in int umwandeln und den String mit dem Operator mittels if() oder switch() überprüfen und die Rechnung ausführen.
 
G

Gelöschtes Mitglied 9001

Gast
Anschließend kann man die beiden Strings mit den Ziffern in int umwandeln und den String mit dem Operator mittels if() oder switch() überprüfen und die Rechnung ausführen.
Man sollte die Dinge so einfach machen wie möglich, aber nicht einfacher (Albert Einstein) ;)
Der TE fragte nach einer Lösung, wie er das auch mit mehreren Zahlen und verschiedenen Rechenoperationen lösen kann. Wenn man einfach linear von vorn nach hinten durchgeht, ignoriert man die Wertigkeiten der Operatoren und bekommt falsche Ergebnisse. 2 + 3 * 4 sind eben 14 und nicht 20.
 

temi

Top Contributor
Der TE fragte nach einer Lösung, wie er auch mit mehreren Zahlen und verschiedenen Rechenoperationen lösen kann.
Das lese ich anders.
Die beiden Zahlenwerte (5 und 7) können jedes Mal variieren, auch die Rechenoperation kann variieren (es könnte also genauso gut "Solve: 334 * 1000" heißen).
Das Muster ist meiner Leseweise nach immer: "Solve:" Leerzeichen Zahl1 Leerzeichen Operator Leerzeichen Zahl2

Und das lässt sich relativ einfach lösen. Wenn es nicht so sein sollte, dann wird es deutlich komplizierter.
 
G

Gelöschtes Mitglied 9001

Gast
Das lese ich anders.

Das Muster ist meiner Leseweise nach immer: "Solve:" Leerzeichen Zahl1 Leerzeichen Operator Leerzeichen Zahl2

Und das lässt sich relativ einfach lösen. Wenn es nicht so sein sollte, dann wird es deutlich komplizierter.

TE: "wäre mir am Liebsten noch weitere Zahlen und Rechenoperationen". Es wird komplizierter, aber wie man es lösen kann, hab ich ja grob beschrieben.
 
K

kneitzel

Gast
Wenn man mit diesem Thema anfangen will, dann kann man es sich vielleicht auch leichter machen und mit einer Postfix Notation anfangen. Dann kann man die Klammern weglassen.

Dann hat man also Ausdrücke wie: 27 13 +, was (27 + 13) entspricht.
Oder 27 13 + 5 * -> ((27 + 13) * 5)

Parsen ist relativ trivial: Man nimmt ein Zeichen:
- Ist es ein Whitespace, dann ignoriert man es.
- Ist es eine Ziffer, dann wird diese Ziffer mit allen direkt nachfolgenden zu einer Zahl
- Ist es ein Operator, dann hat man den Operator direkt.

Wenn man dies dann auswerten will, dann geht das auch extrem einfach, da eben keine Regeln wie Punkt vor Strich Rechnung beachtet werden müssen:
Auswertung von Links nach Rechts
- Zahlen werden auf den Stack gelegt
- Operatoren nehmen sich die Operanden vom Stack, führen die Operation aus und legen das Ergebnis auf den Stack.
- Am Ende ist das Ergebnis auf dem Stack.
Ungültig war der Ausdruck, wenn ein Operator seine Operanden nicht bekommen konnte oder am Ende nicht genau eine Zahl auf dem Stack liegt.

Also bei 27 13 + 5 * sähe die Auswertung vor:
1. 27: Stack: 27; Rest: 13 + 5 *
2. 13: Stack: 13, 27; Rest: + 5 *
3. +: Stack: 40; Rest: 5 *
4. 5: Stack: 5, 40; Rest: *
5. *: Stack: 200; Rest:
==> Wir sind fertig und das Ergebnis ist 200.

Das war damals (vor 1990) bei uns im Unterricht die Einführung in die Auswertung.

Ich habe das damals dann noch vertieft mit dem Buch "Compilerbau" von Alfred v, Aho, Ravi Sethi und Jeffry D. Ullman (Übersetz von Prof. Dr. Gerhard Barth) aus dem Addison-Wesley Verlag. (Ist ein Zweiteiler). Das läuft (lief?) halt auch unter dem Spitznamen "Drachenbuch". Ist aber halt schon etwas älter - Das Original in englischer Sprache ist wohl von 86/87. Ich möchte also nicht ausschließen, dass es da inzwischen auch einiges an Neuerungen geben könnte. Aber das dürfte sich vor allem auf den zweiten Teil auswirken, wo es um Code Optimierungen und so geht. Und andere Bücher (neuere) Bücher kenne ich nicht, da ich diese Thematik nicht weiter vertieft habe in den letzten 20 Jahren....
==> Vorteil könnte sein, dass man das Buch ggf. gut ausleihen kann (zur Not Fernausleihe). Man muss also nicht einmal groß Geld ausgeben.

Ansonsten auch einfach einmal Google nutzen und nach "compilerbau drachenbuch pdf" oder so suchen. Da habe ich einige PDFs von Unis bekommen. Da werden bestimmt auch interessante Scripte dabei sein, die man durchsehen kann....
 

JennyL

Bekanntes Mitglied
Aber man kann doch als Übung mal versuchen, einen Text wie 3 * 5 auszuwerten
Schon richtig... Habe mal etwas mit den Grundrechenarten rumprobiert... Der mXparser dient hier nur für das Tokenizing und Leveln der Eingabe. Der Term muss (vollständig) geklammert sein:
Java:
import java.util.PriorityQueue;
import java.util.Scanner;

import org.mariuszgromada.math.mxparser.Expression;
import org.mariuszgromada.math.mxparser.parsertokens.Token;

public class ME1 {
	public static void main(String[] args) {
		// 1+((2*3)-4) == 3 
		// 1+(2*(3-4)) == -1
		// ((1+2)*3)-4 == 5
		System.out.println("Solve:");
		@SuppressWarnings("resource")
		String e = new Scanner(System.in).nextLine();
		Expression e2 = new Expression(e);
		PriorityQueue<Token2> queue = new PriorityQueue<Token2>();
		for (Token token : e2.getCopyOfInitialTokens()) {
			System.out.println(token.tokenStr + " (" + token.tokenLevel + ")");
			if (token.tokenTypeId == 0) {
				queue.add(new Token2(token));
			}
			if (token.tokenTypeId == 1) {
				queue.add(new Token2(token));
			}
		}
		Token2 t2 = queue.remove();
		double a = queue.remove().t.tokenValue;
		queue.add(t2);
		while (!queue.isEmpty()) {
			switch (queue.remove().t.tokenStr.charAt(0)) {
			case '+':
				a += queue.remove().t.tokenValue;
				break;
			case '-':
				a -= queue.remove().t.tokenValue;
				break;
			case '*':
				a *= queue.remove().t.tokenValue;
				break;
			case '/':
				a /= queue.remove().t.tokenValue;
				break;
			default:
				break;
			}
		}
		System.out.println(a);
		System.out.println("Proof: " + e2.calculate());
	}
}

class Token2 implements Comparable<Token2> {
	private static int level0 = 0;
	public Token t;
	private int level1;
	private int level2;

	public Token2(Token t) {
		this.t = t;
		this.level1 = t.tokenLevel;
		this.level2 = level0++;
	}

	public int compareTo(Token2 o) {
		if (level1 == o.level1)
			if (t.tokenTypeId == o.t.tokenTypeId)
				return level2 - o.level2;
			else
				return o.t.tokenTypeId - t.tokenTypeId;
		return o.level1 - level1;
	}
}
 

Lasnik

Mitglied
Ich hätte nie gedacht, dass es tatsächlich so kompliziert es mit Grundrechenarten zu hantieren :D
Vielen Dank für alle Antworten (übrigens habt ihr mir dabei nicht bei einer Übung oder Hausaufgabe geholfen, sondern bei meinem eigenen Projekt ;) )
 
G

Gelöschtes Mitglied 9001

Gast
Weil ich's so gerne mache, hier ein kleiner Formelparser, der Grundrechenarten, Klammern, ein paar Funktionen und Konstanten versteht. Das Zerlegen in Tokens ist etwas hingekliert, das kann man sicherlich schöner machen. Nicht so elegant ist freilich auch, dass jeder Operator 2x mit dem Token verglichen wird. Aber zum Verständnis langt das Beispiel allemal.

Code:
import java.util.Collections;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SimpleFormelParser {

    private Stack<String> tokens;
    
    // Zahlen, Woerter, einzelne Zeichen
    private final static Pattern pattern = Pattern.compile("(^[0-9\\.]+)|(^\\w+)|(^.)");
    
    private final static String ENDSYMBOL = "end of input";
    
    public SimpleFormelParser(String string) {
        tokens = new Stack<>();
        
        // den String zerlegen und in den Stack legen
        
        int cursor = 0;
        while (cursor < string.length()) {
            Matcher m = pattern.matcher(string.substring(cursor));
            if (m.find()) {
                String token = m.group().trim();
                if (!token.isEmpty()) {
                    tokens.push(token);
                }
                cursor += m.group().length();
            } else {
                throw new RuntimeException("Syntax error");
            }
        }
        
        Collections.reverse(tokens);
    }

    /**
     * Wertet die Formel aus.
     * @return
     */
    public double eval() {
        double result = Summe();
        if (!tokens.isEmpty()) {
            throw new RuntimeException(String.format("superfluous tokens: '%s'", tokens));
        }
        return result;
    }
    
    /**
     * Holt das naechste Token vom Stapel. Ist der Stapel leer, wird das Endsymbol geliefert.
     * @return
     */
    private String nextToken() {
        return tokens.isEmpty()?ENDSYMBOL:tokens.pop();
    }
    
    /**
     * Legt ein Token zurueck auf den Stapel, aber nicht, wenn es sich dabei um's Endsymbol handelt.
     * @param token
     */
    private void pushBack(String token) {
        if (token != ENDSYMBOL) {
            tokens.push(token);
        }
    }
    
    private double Summe() {
        double result = Produkt();

        String token = nextToken();
        while ("+".equals(token) || "-".equals(token)) {
            switch (token) {
            case "+": result += Produkt(); break;
            case "-": result -= Produkt(); break;
            }
            token = nextToken();
        }
        pushBack(token);
        
        return result;
    }
    
    private double Produkt() {
        double result = Potenz();
        
        String token = nextToken();
        while ("*".equals(token) || "/".equals(token)) {
            switch (token) {
            case "*": result *= Potenz(); break;
            case "/": result /= Potenz(); break;
            }
            token = nextToken();
        }
        pushBack(token);
        
        return result;
    }
    
    private double Potenz() {
        double result = Operand();
        
        String token = nextToken();
        while ("^".equals(token)) {
            result = Math.pow(result, Operand());
            token = nextToken();
        }
        pushBack(token);
        
        return result;
    }
    
    private double Operand() {
        String token = nextToken(); 

        switch (token) {
        // Klammerausdruecke
        case "(":
            double result = Summe();
            token = nextToken();
            if (!")".equals(token)) {
                throw new RuntimeException(String.format(") expected. Found '%s' instead.", token));
            }
            return result;
            
        // Funktionen. In der Mathematik wird das nachfolgende Produkt als Argument verstanden, es muss nicht geklammert sein
        case "sin" :  return Math.sin(Produkt());
        case "cos" :  return Math.cos(Produkt());
        case "sqrt":  return Math.sqrt(Produkt());
        
        // Konstanten
        case "pi"  :  return Math.PI;
        
        // Negation
        case "-"   :  return -Operand();
        
        // alles andere versuchen wir als Zahl zu interpretieren
        default:
            try {
                return Double.parseDouble(token);
            } catch (NumberFormatException e) {
                throw new RuntimeException(String.format("Invalid operand: '%s'", token));
            }
        }
    }
    
    public static void main(String [] args) {
        System.out.println(new SimpleFormelParser(" ( 1.7 * 10^2) * sin -1.6*pi").eval());
    }
}
 
G

Gelöschtes Mitglied 9001

Gast
Hier noch eine leicht kürzere Variante, die möglicherweise etwas schwieriger zu verstehen ist, aber erlaubt, unkompliziert Operatoren, Funktionen, Konstanten zu ergänzen, in dem man einen entsprechenden Eintrag in der Map macht.
Code:
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SimpleFormelParser {
    
    // Zahlen, Wörter, einzelne non-Whitespace-Zeichen. Alles ggf. mit führenden Leerzeichen
    private final static Pattern pattern = Pattern.compile("^\\s*([0-9\\.]+|\\w+|\\S)");
    private final static String ENDSYMBOL = "end of input";

    private Map<String,BiFunction<Double,Double,Double>> operators = new HashMap<>();
    private Map<String,Function<Double,Double>>          functions = new HashMap<>();
    private Map<String,Double>                           constants = new HashMap<>();
    
    private Stack<String> tokens = new Stack<>();
    
    public SimpleFormelParser(String string) {
        // den String zerlegen und in den Stack legen
        int cursor = 0;
        while (cursor < string.length()) {
            Matcher m = pattern.matcher(string.substring(cursor));
            if (m.find() && m.groupCount() > 0) {
                tokens.push(m.group(1));
                cursor += m.group().length();
            }  else {
                cursor++;
            }
        }

        tokens.push(ENDSYMBOL);
        Collections.reverse(tokens);

        // Hier Operatoren definieren. Die Zahl ist die Wertigkeit (je kleiner, desto höherwertiger, keine 0 verwenden). 'Punktrechnung geht vor Strichrechnung'
        operators.put("1^", (a,b) -> Math.pow(a,b));
        operators.put("2*", (a,b) -> a*b);
        operators.put("2/", (a,b) -> a/b);
        operators.put("3+", (a,b) -> a+b);
        operators.put("3-", (a,b) -> a-b);
        
        // Hier Funktionen definieren
        functions = new HashMap<>();
        functions.put("sin",  x -> Math.sin(x));
        functions.put("cos",  x -> Math.cos(x));
        functions.put("sqrt", x -> Math.sqrt(x));
        
        // Hier Konstanten definieren;
        constants.put("pi", Math.PI);
        constants.put("e",  Math.E);
    }

    /**
     * Wertet die Formel aus.
     */
    public double eval() {
        double result = Ausdruck(3);    // eine Formel ist ein Ausdruck 
        
        if (!tokens.isEmpty() && tokens.peek() != ENDSYMBOL) {
            throw new RuntimeException(String.format("superfluous tokens: '%s'", tokens));
        }
        return result;
    }
    
    /**
     * Parst einen mathematischen Ausdruck. Ein Ausdruck ist: <Ausdruck> <Operator> <Ausdruck> ... 
     * d.h., ein Ausdruck ist wiederum ein Ausdruck der Form <Ausdruck> <Operator> <Ausdruck> ... sofern die Hierarchy > 0 ist.<br>
     * Ist sie 0, wird mit der Methode Operand() ein Operand geparst.<br>
     * Entsprechend der Hierarchy wird in der Operator-Map nach passenden Operatoren gesucht.
     */
    private double Ausdruck(int hierarchy) {
        if (hierarchy <= 0) { 
            return Operand();
        }
        
        double result = Ausdruck(hierarchy-1);
        do {
            String token = tokens.pop();
            
            BiFunction<Double, Double, Double> operator = operators.get(String.format("%d%s", hierarchy, token));
            if (operator == null) {
                tokens.push(token);
                break;
            } else {
                result = operator.apply(result, Ausdruck(hierarchy-1));
            }

        } while (true);
        
        return result;
    }
    
    /**
     * Parst Negation, Klammerausdrücke, Funktionen, Konstanten, Zahlen
     */
    private double Operand() {
        String token = tokens.pop(); 

        switch (token) {
        case ENDSYMBOL: throw new RuntimeException("Unexpected end of input");
        
        // Negation
        case "-": return -Operand();
                
        // Klammerausdrücke
        case "(":
            double result = Ausdruck(3);
            token = tokens.pop();
            if (!")".equals(token)) {
                throw new RuntimeException(String.format(") expected. Found '%s' instead.", token));
            }
            return result;

        default:
            // Funktionen. In der Mathematik wird das nachfolgende Produkt als Argument verstanden, es muss nicht geklammert sein
            if (functions.containsKey(token)) {
                return functions.get(token).apply(Ausdruck(2));
            }
                
            // Konstanten
            if (constants.containsKey(token)) {
                return constants.get(token);
            }
            
            // alles andere versuchen wir als Zahl zu interpretieren
            try {
                return Double.parseDouble(token);
            } catch (NumberFormatException e) {
                throw new RuntimeException(String.format("Invalid operand: '%s'", token));
            }
        }
    }
    
    public static void main(String [] args) {
        System.out.println(new SimpleFormelParser(" ( 1.7 * 10^2) * sin -1.6*pi + 1+2*4*0.5").eval());
    }
}
 

JennyL

Bekanntes Mitglied
Ich hätte nie gedacht, dass es tatsächlich so kompliziert es mit Grundrechenarten zu hantieren :D
Vielen Dank für alle Antworten (übrigens habt ihr mir dabei nicht bei einer Übung oder Hausaufgabe geholfen, sondern bei meinem eigenen Projekt ;) )
also es ist schon richtig, das Thema ist nicht ganz trivial, sobald die Terme komplizierter werden... Zum Einlesen sei noch ans Herz gelegt: (geklammerte/ungeklammerte) infix, präfix und postfix Notation, Algo von Dijkstra (Shunting-yard algo), Regexes, Compilerbau, Lexikalische, Syntaktische und Semantische Analyse (Tokenizer, ...), kontextfreie Grammatik/Syntax, Syntaxbaum, Evaluierung.
 
G

Gelöschtes Mitglied 9001

Gast
also es ist schon richtig, das Thema ist nicht ganz trivial, sobald die Terme komplizierter werden... Zum Einlesen sei noch ans Herz gelegt: (geklammerte/ungeklammerte) infix, präfix und postfix Notation, Algo von Dijkstra (Shunting-yard algo), Regexes, Compilerbau, Lexikalische, Syntaktische und Semantische Analyse (Tokenizer, ...), kontextfreie Grammatik/Syntax, Syntaxbaum, Evaluierung.
Oder einfach mal mein Beispiel ausprobieren und mit einem Debugger nachvollziehen ;)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
macle Rekursive String Methode, Gerade Zahlen rausfiltern Java Basics - Anfänger-Themen 10
L Zahlen in String bestimmt schneiden! Java Basics - Anfänger-Themen 10
D Java doppelte Zahlen auch über 10 in einem String entfernen Java Basics - Anfänger-Themen 2
S Zahlen an String anfügen Java Basics - Anfänger-Themen 2
S String ab dem Wechsel Buchstaben zu Zahlen splitten Java Basics - Anfänger-Themen 14
T Array mit String, Zahlen in If Saetze packen Java Basics - Anfänger-Themen 3
G String Elemente auf Zahlen Überprüfen Java Basics - Anfänger-Themen 21
M String nach Zahlen durchsuchen Java Basics - Anfänger-Themen 21
M Anzahl Zahlen in String Java Basics - Anfänger-Themen 21
X String Sonderzeichen/Zahlen erkennen Java Basics - Anfänger-Themen 3
C Problem mit der Extraktion von Zahlen aus einem String Java Basics - Anfänger-Themen 8
M String mit mehreren Zahlen in Integer-Array Java Basics - Anfänger-Themen 2
G Zahlen aus String filtern? Java Basics - Anfänger-Themen 3
G String aus Zahlen multiplizieren -> unendlich große ! Java Basics - Anfänger-Themen 13
S String Vergleich mit Passwort geht nur bei Zahlen ? Java Basics - Anfänger-Themen 7
A Beliebiger String --> Buchstaben und Zahlen Java Basics - Anfänger-Themen 4
P String auf Zahlen beschränken Java Basics - Anfänger-Themen 16
P Zahlen aus String auslesen und dann sortieren. Java Basics - Anfänger-Themen 2
V String überprüfen, nur Punkte und Zahlen erlaubt Java Basics - Anfänger-Themen 7
S String in ACSII Zahlen umwandeln Java Basics - Anfänger-Themen 10
G String buchstaben in Zahlen umwandeln Java Basics - Anfänger-Themen 5
F Zahlen ine-notation aus string Java Basics - Anfänger-Themen 4
A String in Zahlen/Summe umformen Java Basics - Anfänger-Themen 2
D String überprüfen auf Zahlen. Java Basics - Anfänger-Themen 16
O String nur importieren wenn nur zahlen da sind? Java Basics - Anfänger-Themen 7
P Integer aus String erzeugen, der nicht nur Zahlen hat. Java Basics - Anfänger-Themen 2
V Zahlen sortieren und String zuweisen Java Basics - Anfänger-Themen 7
S String --> Zahlen herausschneiden an bestimmten Positione Java Basics - Anfänger-Themen 3
P String aus Zahlen auslesen und in einem Array speichern Java Basics - Anfänger-Themen 3
G zwei Zahlen bei String.valueOf(char c) in JTextField Java Basics - Anfänger-Themen 7
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
Ü Java Array - Buchstaben als Zahlen ausgeben Java Basics - Anfänger-Themen 22
P Aus Text Datei nur Zahlen übernehmen Java Basics - Anfänger-Themen 13
K Warum werden immer noch doppelte Zahlen ausgegeben ? Java Basics - Anfänger-Themen 13
M negative Zahlen bei Intervallen Java Basics - Anfänger-Themen 10
XWing Doppelte Zahlen im Array Java Basics - Anfänger-Themen 8
M 3 Zahlen miteinander vergleichen Java Basics - Anfänger-Themen 18
J Taschenrechner mit mehr als 2 Zahlen. Java Basics - Anfänger-Themen 18
O Zahlen aus einem char-array per char + Zeichen addieren Java Basics - Anfänger-Themen 2
B Alle Zahlen finden, die 3 bestimmte Ziffern enthalten? Java Basics - Anfänger-Themen 9
K Java gleicher Wert von Zahlen? Java Basics - Anfänger-Themen 5
I aus 2 random zahlen soll nur die ungerade summe der beiden genommen werden. Java Basics - Anfänger-Themen 13
J Operatoren Zahlen addieren Java Basics - Anfänger-Themen 13
B Threads Counter mit ungeraden Zahlen Java Basics - Anfänger-Themen 32
JavaBeginner22 Java 2 Zufalls zahlen generieren. Java Basics - Anfänger-Themen 11
X Wie kann man ein Regex erstellen, die 8-Bit-Binär-Zahlen darstellen. Java Basics - Anfänger-Themen 1
M Stream mit den ersten n natürlichen Zahlen Java Basics - Anfänger-Themen 4
D Größtes Palindrom Produkt aus zwei dreistelligen Zahlen Java Basics - Anfänger-Themen 60
T Methode, die prüft ob in einem Int-Array maximal 2 Zahlen enthalten sind, die größer als ihr Vorgänger sind Java Basics - Anfänger-Themen 5
sserio Befreundete Zahlen Java Basics - Anfänger-Themen 7
AhmadSlack Verzweigungen zahlen multiplizieren Java Basics - Anfänger-Themen 4
padde479 Array Multiplikation der ersten n Zahlen Java Basics - Anfänger-Themen 7
U Lotto-Zahlen App Java Basics - Anfänger-Themen 34
berserkerdq2 Wie würde man einen regulären Ausdruck in Java schreiben, der prüft, dass zwei bestimtme Zahlen nicht nebeneinadner sind? Java Basics - Anfänger-Themen 3
H Arrays: Größten Zahlen Unterschied herausfinden Java Basics - Anfänger-Themen 20
bluetrix Programmieren eines Bots für Zahlen-Brettspiel Java Basics - Anfänger-Themen 9
J Zahlen bis zu einem bestimmten Grenzwert ausgeben Java Basics - Anfänger-Themen 11
00111010101 Objektorientiertes Programmieren mit Vererbung (Zahlen in Array verschwinden) Java Basics - Anfänger-Themen 3
P Zweidimensionales Array als Tabelle mit befüllten Zahlen Java Basics - Anfänger-Themen 10
W Wie ziehe ich von einer bestimmten Zahl, Zahlen ab, bis mein Ergebnis null beträgt? Java Basics - Anfänger-Themen 10
emx-zee Erste Schritte NullPointerException, Array mit zufälligen Zahlen füllen Java Basics - Anfänger-Themen 2
W Bestimmte Zahlen bei Math.random ausschließen? Java Basics - Anfänger-Themen 31
K Erste Schritte "Taschenrechner" zeigt keine Komma Zahlen an. Java Basics - Anfänger-Themen 8
P Drei Zahlen eines Würfelspiels auswerten Java Basics - Anfänger-Themen 7
H Häufigkeit von Zahlen ermitteln Java Basics - Anfänger-Themen 23
sashady Zahlen rekursiv zerlegen und Ziffern addieren Java Basics - Anfänger-Themen 38
H Zahlen kürzen Java Basics - Anfänger-Themen 2
ansystin Teilerfremde Zahlen ausgeben + Zahlenausgabe speichern Java Basics - Anfänger-Themen 3
B Häufigkeit einzelner Zahlen in einem Array Java Basics - Anfänger-Themen 6
nevel Programm für die Summer der Zahlen 1- 1ß Java Basics - Anfänger-Themen 12
jhCDtGVjcZGcfzug Fibonacci Zahlen rekursiv und iterativ Java Basics - Anfänger-Themen 21
H Eingegebene Zahlen mit Array ausgeben Java Basics - Anfänger-Themen 18
I 12 Spalten von jeweils 30 Zahlen in Konsole ausgeben Java Basics - Anfänger-Themen 6
R Array mit Unter- und Obergrenze ganze Zahlen dazwischen erscheinen nicht Java Basics - Anfänger-Themen 1
OZAN86 For Schleife von 1-50 die Zahlen werden durch ein Komma getrennt Java Basics - Anfänger-Themen 10
Bademeister007 Operatoren Alle Zahlen einer ArrayList die durch 5 teilbar ist Java Basics - Anfänger-Themen 2
mhmt_03 dafür sorgen, dass im JTextfield nur zahlen eingebbar sind Java Basics - Anfänger-Themen 9
Ianatrix Zahlen von a bis b berechnen Java Basics - Anfänger-Themen 7
P Wie kann ich die Zahlen dieses Arrays dividieren? Java Basics - Anfänger-Themen 2
P Nutzer entscheiden lassen, wie viele Zahlen dieser in ein Array eingeben möchte. Java Basics - Anfänger-Themen 6
T Bestimmte Zahlen ausgeben mit einer whilfe Schleife Java Basics - Anfänger-Themen 21
H Alle Geraden zahlen bis 10 ausgeben Java Basics - Anfänger-Themen 11
java3690 Liste mit zufälligen zahlen füllen Java Basics - Anfänger-Themen 27
M Regex nur Zahlen und Punkt zulassen, Keine Eingabe(Leeres TextFeld) nicht zulassen Java Basics - Anfänger-Themen 6
G Java eingelesene Zahlen Java Basics - Anfänger-Themen 2
D Zahlen werden falsch gekürzt :? Java Basics - Anfänger-Themen 27
H Ungerade Zahlen ausgeben von 1 bis 1000 Java Basics - Anfänger-Themen 8
C Positive und negative Zahlen mit Regex extrahieren Java Basics - Anfänger-Themen 8
N Wörter und Zahlen nach speziellen Wörtern ausgeben Java Basics - Anfänger-Themen 11
F Komplexe Zahlen auf verschiedene Weise addieren Java Basics - Anfänger-Themen 18
L Java Int-Array, Zahlen sortieren Java Basics - Anfänger-Themen 8
B Fibonacci Zahlen dynamische Programmierung Java Basics - Anfänger-Themen 7
V Erste Schritte Taschenrechner mit beliebig vielen Zahlen Java Basics - Anfänger-Themen 5
X Wie kann ich Zahlen in einzelne Zifferne zerlegen? Java Basics - Anfänger-Themen 3
J 10 positive Zahlen eingeben Java Basics - Anfänger-Themen 10
K Rechtsbündige Ausgabe von Zahlen Java Basics - Anfänger-Themen 6
A Wie zwei zahlen in einer Variable speichern? Java Basics - Anfänger-Themen 7
M Zahlen erraten Java Basics - Anfänger-Themen 7
E Zahlen von einem Array mit zahlen von zweitem Array vergleichen Java Basics - Anfänger-Themen 27
S Mit nextGaussian() positive Zahlen erzeugen? Java Basics - Anfänger-Themen 39

Ähnliche Java Themen

Neue Themen


Oben