String tokenizer / parser

[Markus XXX]

Hallo zusammen.

Ich lese Daten aus einer Datei ein, z.B.

1) bla bla C:\Programme\bla\ bla bla
2) bla bla "C:\program files\test" bla bla

Der Unterschied von 1) und 2) ist, daß bei 2) ein Token mittels Hochkommas markiert ist.
Ich suche also eine Möglichkeit das mittels StringTokenizer, regulärem Ausdruck, etc
so zu zerlesen, daß, sollten Hochkommas vorhanden sein, diese ein Token markieren, sollten keine vorhanden sein, dann halt nicht :autsch:

2) wäre dann also
bla
bla
C:\program files\test
bla
bla

 

[XHelp]

Mit dem StringTokenizer kommst du da glaube ich nicht weit. Soweit ich weiß kannst du da kein "Escape"-Zeichen angeben.
Warum willst du es nicht selber umsetzen?
Ansonsten könntest du dir angucken, wie es bei CSV-Daten gemacht wird.

 

[student@work]

Also Du hast auf jeden Fall mehrere Möglichkeiten.

1) Von Hand.

-> Gehe den Eingabestring in einer Schleife durch und merke Dir irgendwo, wenn Du in einem "Block" bist, der von Anführunszeichen umgeben ist. So habe ich das zumindest früher immer gemacht.

2) Regulärer Ausdruck.

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


public class Test {

	
	
	public static final Pattern PATTERN = Pattern.compile("((\\w|\\\\|:)+)" + "|" + "(\"(\\w|\\\\|:|\\s)*\")");



	public static void main(String[] args) {

		String s1 = "bla bla C:\\Programme\\bla\\ bla bla";
		String s2 = "bla bla \"C:\\program files\\test\" bla bla";

		print(scan(s1));
		print(scan(s2));
	}



	public static void print(List<String> tokens) {
		for (String token : tokens) {
			System.out.println("->" + token + "<-");
		}
		System.out.println();
	}

	
	
	public static List<String> scan(String string) {

		List<String> tokens = new ArrayList<String>();

		Matcher m = PATTERN.matcher(string);
		
		while (m.find()) {
			tokens.add(m.group());
		}
		
		return tokens;
	}



}

Ohne Gewähr der Vollständigkeit, hab das mal kurz so eingetippt. Für Deine Beispielstrings passt das,
aber wenn Du noch SOnderzeichen, etc. verwendest, musst Du den Regulären Ausdruck auch anpassen.


3) Evtl. geht sowas auch mit einem java.util.Scanner, das habe ich aber nie probiert.

Noch ein Tipp: Das was Du machst ist auch eine Funktion, welche Kommandozeileninterpretern (boar langes Wort), bzw. Shells unterstützen. Wenn Du einen Java-Quelltext von so einem Programm findest,
einfach mal spicken.

 

[Markus XXX]

Das Schreiben eines eigenen Parsers ist vom Prinzip her schon klar, aber wieso das Rad neu erfinden wenn es eventuell schon erfunden wurde?
Ich dachte mir leider auch schon daß ein StringTokenizer hier nicht ausreicht, aber es hätte ja sein können, daß ich hier etwas übersehe.
Das Beispiel mit dem regulären Ausdruck ist echt gut! Besten Dank für den Tritt in die richtige Richtung :applaus: