✔ JAVA filter für String

[Malaxo]

Keine Ahnung wie der Titel heissen soll versuche es mal zu erklären.

Ich lese von einer Text datei Zeile für Zeile aus, danach suche ich nach einem Wort, wenn dieses Wort enthalten ist in der Zeile gebe ich diese aus.

Momentaner output: Ich bin eine Zeile [DASA] [ISTB] gut so.

Nun will ich alles zwischen den Zeichen "[" und "]" ausgeben und zwar so, das immer 2 Zeichen zusammen gehören. Ergebniss:
DA
SA
IS
TB

hab mir Regex, Split, StringTokenizer und trim angesehen. Kriegs jedoch nicht hin das ich nur schon den Inhalt zwischen den zwei Zeichen "[ ]" ausgeben kann.

Hat mir da jemand einen Tipp oder ein kleines beispiel?

 

[Franz Degenhardt]

Eventuell hilft dir folgender Ansatz:

		String s = "Ich bin eine Zeile [DASA] [ISTB] gut so.";
		Matcher m = Pattern.compile("\\[\\w+\\]").matcher(s);
		while (m.find()) {
                        System.out.println(m.group());
			System.out.println(s.substring(m.start(), m.end()));
		}

regex pattern kann noch angepasst werden, weiss nicht genau ob es für den Dateiinhalt passt.
Gruppieren in 2er Gruppen muss noch gemacht werden.

edit:
Links:
http://java.sun.com/docs/books/tutorial/essential/regex/quant.html
http://www.regular-expressions.info/java.html

 

[Thomas Darimont]

Hallo,

schau mal hier:

package de.tutorials.training;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TextExtractionExample {
    public static void main(String[] args) {
        String text ="Ich bin eine Zeile [DASA] [ISTB] gut so.";
        Matcher matcher = Pattern.compile("\\[([^\\]]+)").matcher(text);
        int fromPosition = 0;
        while(matcher.find(fromPosition)){
            System.out.println(matcher.group(1));
            fromPosition = matcher.end();
        }
    }
}

Ansonsten...

package de.tutorials.training;

public class TextExtractionExample {
	public static void main(String[] args) {
		String text = "Ich bin eine Zeile [DASA] [ISTB] gut so.";
		for (int i = text.indexOf('['); i > 0; i = text.indexOf('[', i+1)) {
			String s = text.substring(i+1, text.indexOf(']', i));
			System.out.println(new NSplit(s, 2));
		}
	}
	
	static class NSplit{
		final String s;
		final int n;
		
		public NSplit(String s, int n) {
			this.s = s;
			this.n = n;
		}
		
		public String toString() {
			return String.format("%s\n%s",s.substring(0, n) ,s.substring(n,s.length()));
		}
	}
}

Gruß Tom

 

[Malaxo]

Super, Danke viel mals.

Nun hab ich damit etwas rum gebastelt um es richtig zu verstehen. Habe versucht nur das Letzte Element der Zeile die von "[ ]" umklammert sind aus zu lesen.

Dann ist mir Folgendes passiert:

String text ="Ich bin eine Zeile [DASA] [ISTB] gut so.";
	        Matcher matcher = Pattern.compile("\\[([^\\]]+)").matcher(text);
	        int fromPosition = 0;
	        while(matcher.find(fromPosition)){
	            System.out.println(matcher.find()); 
	            System.out.println(matcher.group(1));
	            fromPosition = matcher.end();
	        }

Output:
True
ISTB

Wiso bekomme ich jetzt nicht:
True
DASA
True
ISTB
?
Bis das Passierte, dachte ich ich habe es verstanden.

Und wie kann ich nur das letzte element das den Matcher erfüllt ausgeben?

 

[Thomas Darimont]

Hallo,

nur den letzten Eintrag bekommst du beispielsweise so:

String text = "Ich bin eine Zeile [DASA] [ISTB] gut so.";
System.out.println(text.replaceAll(".*\\[([^\\]]+)\\].*", "$1"));

Gruß Tom

 

[vfl_freak]

Hallo zusammen,

(wieder mal) ein kleiner Tipp am Rande in diesem Zusammenhang!

Wir nutzen hier in der Firma zum Testen von regulären Ausdrücken das nette kleine Tool "RegEx coach"!

Es kann (zusammen mit seiner Doku) hier runtergeladen werden:
http://weitz.de/files/regex-coach.exe (Windows installer) oder http://weitz.de/files/regex-coach.tgz (Linux tar archive)

Es eignet sich gut zur Einarbeitung in dieses Thema und man kann im Editor verschiedene reguläre Ausdrücke testen!

Gruß
Klaus

 

[Franz Degenhardt]

String text ="Ich bin eine Zeile [DASA] [ISTB] gut so.";
	        Matcher matcher = Pattern.compile("\\[([^\\]]+)").matcher(text);
	        int fromPosition = 0;
	        while(matcher.find(fromPosition)){
	            System.out.println(matcher.find()); 
	            System.out.println(matcher.group(1));
	            fromPosition = matcher.end();
	        }

Output:
True
ISTB

Wiso bekomme ich jetzt nicht:
True
DASA
True
ISTB

matcher.find() sucht das nächste vorkommen ähnlich wie iterator.next().
Durch den zweimaligen Aufruf, einmal im Kopf der Schleife, ein zweites mal im Rumpf der Schleife hast du das erste element übersprungen.

 

[Malaxo]

Okay

System.out.println(text.replaceAll(".*\\[([^\\]]+)\\].*", "$1"));

Ist super, danke. Muss mich mal noch mit Regex beschäftigen.

"RegEx coach" <- Das wird bestimmt helfen, danke auch.