Alle Werte eines Strings zusammen addieren

[JanaEscobar]

Guten Tag zusammen,

ich schreibe momentan ein Programm womit ich aus einen Text die Zahlen herausfiltern kann, was auch gut klappt.
jetzt habe ich mit Matcher mir die Zahlen ausgeben lassen und würde die gerne addieren.#

Die Zahlen werden in einen String gespeichert, nun wollte ich gerne alles zusammen addieren.

Soll ich das Problem lieber mit List lösen, so muss ich nur herausfinden wie viele Werte ich habe und die dann zusammen addieren,oder?


Kann mir einer ein Tipp geben, wie ich ins Ziel komme?

So sieht mein Code aus:

   String Rechnung = "Entsorgung 100€ Waschen 200€ Transport 400€ schlafen 200€ Saufen 100€ , Prostituierte 80€";
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher(Rechnung);
        while ( m.find() ) {
            System.out.println(m.group());
            
           summe = m.group(); // 100 , 200 , 400 , 200, 100

          System.out.println(summe);

Gruß,

Jana

 

[temi]

Du könntest z.B. Integer.parseInt() verwenden, um die einzelnen als Strings repräsentierten Zahlen je in einen int-Wert umzuwandeln, mit dem du dann rechnen kannst.

 

[Dimax]

summe = m.group();

summe += m.group();

 

[MoxxiManagarm]

Alternativ zum Pattern+Matcher+Parser könntest du auch einfach den Scanner verwenden.

summe += m.group();

Eine group ist aber ein String und kein int ;-)

 

[JanaEscobar]

Du könntest z.B. Integer.parseInt() verwenden, um die einzelnen als Strings repräsentierten Zahlen je in einen int-Wert umzuwandeln, mit dem du dann rechnen kannst.

Ich glaube das ist nur eine bedingte Lösung.
Sobald du mehrere Zahlen addieren willst, fehlen dir Variablen.

Gruß,

Jana

 

[sascha-sphw]

Wenn Du

Du könntest z.B. Integer.parseInt() verwenden,

mit

summe += m.group();

kombinierst, könnte sowas dabei raus kommen.

public static void main(String[] args) {
    String Rechnung = "Entsorgung 100€ Waschen 200€ Transport 400€ schlafen 200€ Saufen 100€ , Prostituierte 80€";
    Pattern p = Pattern.compile("[0-9]+");
    Matcher m = p.matcher(Rechnung);

    int summe = 0;
    while (m.find()) {
        System.out.println(String.format("found: '%s'", m.group()));
        summe += Integer.parseInt(m.group()); // 100 , 200 , 400 , 200, 100
    }
    System.out.println(String.format("sum: %d", summe));
}

Für was brauchst Du noch zusätzliche Variablen?

 

[JanaEscobar]

Wenn Du

mit

kombinierst, könnte sowas dabei raus kommen.

public static void main(String[] args) {
    String Rechnung = "Entsorgung 100€ Waschen 200€ Transport 400€ schlafen 200€ Saufen 100€ , Prostituierte 80€";
    Pattern p = Pattern.compile("[0-9]+");
    Matcher m = p.matcher(Rechnung);

    int summe = 0;
    while (m.find()) {
        System.out.println(String.format("found: '%s'", m.group()));
        summe += Integer.parseInt(m.group()); // 100 , 200 , 400 , 200, 100
    }
    System.out.println(String.format("sum: %d", summe));
}

Für was brauchst Du noch zusätzliche Variablen?

oh, ich hätte mal richtig lesen sollen.
Entschuldigung für das Mistverständnis.

Gruß,

Jana

 

[mrBrown]

Alternativ:

int summe = Pattern.compile("[0-9]+").matcher(rechnung).results()
  .map(MatchResult::group)
  .mapToInt(Integer::parseInt)
  .sum()

 

[insert2020]

So:

	public static long sumup(String input) {
		long sum = 0;
		Pattern pat = Pattern.compile("\\d+");
		Matcher mat = pat.matcher(input);
		while (mat.find()) {
			try {
				sum += Integer.parseInt(mat.group());
			} catch (NumberFormatException e) {
				System.out.println(e.getMessage());
			}
		}
		return sum;
	}

	public static void main(String[] args) {
		System.out.println(sumup("123 45"));
	}

Bei Dezimalzahlen wird es nochmal etwas kniffliger... 😉

 

[mrBrown]

So:

    public static long sumup(String input) {
        long sum = 0;
        Pattern pat = Pattern.compile("\\d+");
        Matcher mat = pat.matcher(input);
        while (mat.find()) {
            try {
                sum += Integer.parseInt(mat.group());
            } catch (NumberFormatException e) {
                System.out.println(e.getMessage());
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(sumup("123 45"));
    }

Bei Dezimalzahlen wird es nochmal etwas kniffliger... 😉

Die NFE wirft man allerdings besser weiter, anstatt dann einfach ein falsches Ergebnis zurückzugeben.

Was soll bei Dezimalzahlen kniffeliger werden?

 

[insert2020]

anstatt dann einfach ein falsches Ergebnis zurückzugeben

Warum sollte das Ergebnis denn falsch sein, 1234567890 wird sicher nicht zur Summe gehören sollen.

 

[mrBrown]

Warum sollte das Ergebnis denn falsch sein, 1234567890 wird sicher nicht zur Summe gehören sollen.

Wenn es nicht zur Summe gehören soll, ist der RegEx falsch -> Exception werfen, damit es gefixt wird.
Wenn es zur Summe gehört ist das parsen als Integer falsch -> Exception werfen, damit es gefixt wird.

 

[insert2020]

ist der RegEx falsch

Nein, du kannst keinen Regex angeben, der nur Zeichen annimmt, die den Wertebereich eines int umfassen. Insofern ist das try-catch völlig richtig.

Es wäre zudem schön, wenn du etwas freundlicher sein könntest.

 

[thecain]

Es dann einfach zu ignorieren scheint mir aber auch nicht korrekt...

und hier war doch niemand unfreundlich...

 

[insert2020]

Es dann einfach zu ignorieren scheint mir aber auch nicht korrekt

Naja, nicht ignorieren... solche Werte werden dann eben übergangen, wobei es aber eine zusätzliche Ausgabe gibt, das ein verdächtiger Wert aufgetreten ist usw.
Sofort returnen würde ich eigentlich nicht. Es muss aber nicht falsch sein, das kann die TE selber entscheiden.

 

[kneitzel]

Nein, du kannst keinen Regex angeben, der nur Zeichen annimmt, die den Wertebereich eines int umfassen. Insofern ist das try-catch völlig richtig.

Wieso kann man so einen Regex nicht angeben? Er wird etwas komplexer vom Aufbau her, aber natürlich geht es.

Vom Prinzip her kann man es ja mal zeigen an Zahlen bis 27.
Das sind dann 0 1 oder nichts + Ziffer von 0-9 oder 2 + Ziffer von 0-7

So kann man das dann mit 3, 4, ... 10 Ziffern machen bis hin zu einem maximalen Wert von 2147483647.

Aber du willst den vollen Wertebereich schon offensichtlich nicht haben. Also könnte man dann begrenzen auf etwas, das Sinn macht. Evtl. würde ich da auch auf Long wechseln, denn wenn er Apple, Alphabet und welche Firma auch sonst noch vom Wert her aufsummieren will, sind 2 Milliarden evtl etwas wenig....