Nummern/Text aus String bekommen

I

internet

Top Contributor
hallo zusammen,
ich möchte Folgendes tun:

Ein Text File nach bestimmten Kriterien suchen:
1. Nur die Zeilen ausgeben, die das Wort "Hallo" beinhalten.
Das habe ich auch schon implementiert, was auch läuft

2. Nach Hallo steht immer eine bestimmte Nummer, jedoch in folgenden Formen:
Hallo\":\" 0123456789 \"

Also hier steht nach der Nummer: \"

oder:
Hallo= 0123456789,

Und hier steht nach der Nummer: ,

Nun möchte ich eine Liste machen mit den verschiedenen Nummern, die nach "Hallo" steht.
Wie bekomme ich nun nur die einzelnen Nummern als String ?

mfg
 
Ich würde das mit Regex lösen (ungetestet): [c](\d*)[/c]. Dann einfach diese Gruppe zurückgeben lassen und ggf. noch als int parsen.
 
Leider kann ich dir nicht ganz folgen:
Hättest du ein Codebeispiel für mich?
Würde mir ungemein helfen.

Also int parsen muss nicht sein - String reicht vollkommen
 
Java: 
Matcher matcher=Pattern.compile("(\\d+)").matcher("Hallo\":\" 0123456789 \"");

if(matcher.find())
	System.out.println("Hallo: " + matcher.group(1));

Ergibt:
Code: 
Hallo: 0123456789
 
dann habe ich mich wohl falsch ausgedrück.
Die Nummer kann immer anders sein.
Also zB 0323242349234

Aber es steht vor der Nummer immer entweder Hallo\":\" oder Hallo=

Jetzt möchte ich eben diese Nummer bekommen.
 
RegEx ist wie ein neuer Hammer was? Lässt alle Probleme wie Nägel aussehen.
@TS: Sieh' dir mal den StreamTokenizer an.
 
Das ist im Prinzip nichts anderes als das was Tomate_Salat schon vorgeschlagen hat. Ich hoffe der Umgang mit
Code: 
Pattern
und
Code: 
Matcher
wird dadurch etwas klarer:

Java: 
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class NummernExtrahieren {

	public static void main(String[] args) {
		LinkedList<Integer> nummernListe = new LinkedList<Integer>();
		
		// \\d+ : Eine oder mehrere Zahlen von 0 bis 9 hintereinander
		Pattern nummer = Pattern.compile("\\d+");
		
		String beispielText =
			"Hallo ohne Zahl\n"
			"TEXT Hallo\":\" 123 \" TEXT\n"
			"Hallo\":\" 321 \"\n"
			"TEXT Hallo= 456, TEXT\n"
			"Hallo= 654,";
		
		Matcher nummernSuche = nummer.matcher(beispielText);
		
		boolean nummerGefunden;
		String gefundeneNummer;
		
		do {
			nummerGefunden = nummernSuche.find();
			if(nummerGefunden) {
				gefundeneNummer = nummernSuche.group();
				nummernListe.add(Integer.parseInt(gefundeneNummer));
			}
		}while(nummerGefunden);
		
		ausgabe(nummernListe);
	}
	
	private static void ausgabe(LinkedList<Integer> liste) {
		System.out.println("Nummern in der Liste: \n");
		for(int nummer : liste)
			System.out.println("- " + nummer);
	}
}
 
@internet: Das ist doch damit möglich, matcher.group(1) liefert dir diese Nummer. Kopier mein Beispiel und entferne aus dem System.out.println die Stelle: [c]"Hallo: " +[/c] und in der Konsole wird die Nummer ausgegeben.
 
Mit RegEx schafft man recht komplizierte Dinge, keine Frage. Nun sollen hier aber nun mal blos Zahlen an gewissen Stellen in einer Zeile einer Textdatei unbestimmter Grösse gefiltert werden. Warum sollte man sich dafür Unmengen der kompliziertesten Expressions ausdenken wollen? Etwa weil man es kann? :lol:
 
und was genau ist an \\d+ so kompliziert? Von Ausdenken kann auch nicht die Rede sein. Warum sollte man es tun? Weil es dafür geeignet ist. Man muss eben nur bereit sein, sich mit Regex auseinander zu setzen.
 
Okay...
Java: 
import java.io.FileReader;
import java.io.StreamTokenizer;

public final class StreamSearch
{
	public static void main(String[] args)
	throws Throwable
	{
		StreamTokenizer st = new StreamTokenizer(new FileReader("./test.txt"));
		int token;
		do {
			token = st.nextToken();
			if(token == StreamTokenizer.TT_WORD && "Hallo".equals(st.sval)) {
				do {
					token = st.nextToken();
					if(token == StreamTokenizer.TT_NUMBER) {
						System.out.println("- " + st.nval);
					}
				} while(token != StreamTokenizer.TT_EOF && token != StreamTokenizer.TT_EOL);
			}
		} while(token != StreamTokenizer.TT_EOF);
	}
}
😉
 
... hier haben wir die Bestätigung:
Java: 
Matcher matcher=Pattern.compile("(\\d+)").matcher(eingabe);
 
if(matcher.find()) { 
// ...
}

ist wesentlich kürzer,flexibler und verständlicher.
 
Jep, sieht so aus, auf den ersten Blick. Aber erstens, das was bei RegEx innerhalb des If-Blocks abläuft ist nicht weniger als beim Tokenizer und zweitens auf was wendest du das an? Lass mich raten: Auf einen String. Wenn nicht auf die gesammte Datei unbestimmter Länge, dann auf einzelne Zeilen. Im Gegensatz zum Tokenizer wird dadurch aber im ersten Fall der Speicher und im zweiten Fall mehr der GC durch ständiges "pattern.matcher(String text)" - es sei denn der Matcher wäre mutable - und der interne Stringbuffer belastet. Seh' ich das falsch?
Also, wenn es um das Suchen simpler Zahlen in einer Textdatei geht, ist man meiner Meinung nach immer noch mit RegEx sehr schlecht bedient. Andererseits ist der Tokenizer natürlich auch kein Allheilmittel. Was mal interessant wär, ein Tokenizer in welchem man nach verschiedenen Expressions suchen könnte.
[EDIT]Ok, Matcher ist mutable, durch "matcher.reset(Charsequence text)". Dennoch bleibt immerhin die Belastung des internen StringBuffers.[/Edit]
 
Zuletzt bearbeitet von einem Moderator:
Natürlich ist die Laufzeit und die RAM-Belastung nicht zu vergleichen. Wie bereits gefühlte 1000 Mal besprochen: Man soll sich nicht Gedanken um einen Flaschenhals machen, wo es gar nicht notwendig ist.
 
Eine für einen Anfänger sicher wesentlich einfacher zu verstehende Lösung ...

Java: 
public class ExtractNumbers {

	final static String anfang = "Hallo";
	final static char sep1 = ':';
	final static char end1 = '\\';
	final static char sep2 = '=';
	final static char end2 = ',';

	final static String[] input = {
		"Hallo:111\\blabla",
		"blubber Hallo=222,",
		"Hallo:333,", // ungültige Kombination
		"Hallo=444\\" // ungültige Kombination
	};

	private static String extract(String in) {
		int index1 = in.indexOf(anfang);
		int index2 = 0;
		index1 += anfang.length();
		char ch = in.charAt(index1);
		index1 += 1;
		if (ch == sep1) {
			index2 = in.indexOf(end1, index1);
		} else if (ch == sep2) {
			index2 = in.indexOf(end2, index1);
		} else {
			// keine Anfangsmarke gefunden
			return "";
		}
		if (index2 < index1) {
			// kein Abschlusscharacter gefunden
			return "";
		}
		return in.substring(index1, index2);
	}

	public static void main(String[] args) {
		for (String s : input)
			System.out.println(extract(s));
	}
}
 
Jep, sieht so aus, auf den ersten Blick. Aber erstens, das was bei RegEx innerhalb des If-Blocks abläuft ist nicht weniger als beim Tokenizer
Zum Vergrößern anklicken....
kenne die interne Struktur von Regex nicht, von daher kann ich nicht viel dazu sagen. Wenn er aber eh das gleiche mit weniger Source macht, spricht das imho doch wiederrum für Regex.

internet hat gesagt.:
1. Nur die Zeilen ausgeben, die das Wort "Hallo" beinhalten.
Das habe ich auch schon implementiert, was auch läuft
Zum Vergrößern anklicken....
Spacerat hat gesagt.:
und zweitens auf was wendest du das an? Lass mich raten: Auf einen String. Wenn nicht auf die gesammte Datei unbestimmter Länge, dann auf einzelne Zeilen.
Zum Vergrößern anklicken....
Laut der Vorgabe des TO's stellt sich mir die Frage nicht. Die Zeile aus der die Nummer gefiltert werden soll ist bereits bekannt.
 
...statt dessen ist es notwendig mit Kanonen auf Spatzen zu schiessen, weswegen man sich ein API schnappt, mit welchem sonst viel kompliziertere Dinge gelöst werden können, man aber damit als Anfänger noch nicht so Vertraut ist und sich erstmal einlesen muß. Ehrlich gesagt, der Aufwand wäre mir angesichts der Codekomplexität viel zu hoch. So richtig überzeugt mich da RegEx nicht wirklich.
Java: 
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class RegExSearch
{
	public static void main(String[] args)
	throws Throwable
	{
		BufferedReader br = new BufferedReader(new FileReader("./test.txt"));
		String line;
		Matcher matcher = Pattern.compile("(\\d+)").matcher("");
		while((line = br.readLine()) != null) {
			matcher.reset(line);
			if(matcher.find()) {
				System.out.println("- " + matcher.group(1));
			}
		}
	}
}
[EDIT]Was mir grad' bei dem verwendeten RegEx-Muster noch auffällt; Wo ist der Bezug zum Suchbegriff "Hallo"?[/EDIT]
 
Zuletzt bearbeitet von einem Moderator:
Da ist kein bezug auf das Hallo, weil es nach der Fragestellung des TOs schlicht nicht notwendig war/ist. Anfangs ist Regex wirklich abschreckend, aber es ist eines der Dinge, die sich lohnen zu lernen. Zumal es nicht nur in Java vorteile bringt. Es hat mir schon oft beim Suchen von bestimmten Text-passagen in Editoren geholfen + beim Suchen/Ersetzen.
 
Tomate_Salat hat gesagt.:
Zumal es nicht nur in Java vorteile bringt. Es hat mir schon oft beim Suchen von bestimmten Text-passagen in Editoren geholfen + beim Suchen/Ersetzen.
Zum Vergrößern anklicken....

Oder auch in anderen Programmiersprachen...
@Spacerat: Ich sehe hier ebenfalls kein Grund, Regex anzuprangern. Wenn du es nicht magst, ok. Aber doch nicht hier darum diskutieren. Dein Alternativcode find ich aber super, so sieht der Anfänger, wie man es ohne Regex machen kann.
 
faetzminator hat gesagt.:
Ich sehe hier ebenfalls kein Grund, Regex anzuprangern. Wenn du es nicht magst, ok. Aber doch nicht hier darum diskutieren. Dein Alternativcode find ich aber super, so sieht der Anfänger, wie man es ohne Regex machen kann.
Zum Vergrößern anklicken....
Das ist genau der Punkt. Natürlich kommt man hier da und dort an RegEx nicht vorbei, aber in diesem Fall. Wer hat eigentlich gesagt, dass ich RegEx nicht mag? Es ist hier halt nicht notwendig, den blutigen Anfänger mit solch' schweren Geschütz zu belasten.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Text zu Handy-Nummern-Eingabe
Antworten: 9
String.format (%s, %d) für Nummern
Antworten: 37
JTextPane Inhalt(Text und Bilder) als HTML text bekommen
Antworten: 3
Nächster möglicher Tag bekommen / Nächste mögliche Zeit bekommen
Antworten: 24
ISBN nummern überprüfen
Antworten: 1

Zurück
Oben