Regex Tokenizer

Runtime

Top Contributor
Hallo Leute,

ich habe da eine Klasse geschrieben, die einen String mit Regex-Patterns splitten sollte. Ich kanns nicht mit string.split("hier wäre ein Regex pattern") machen, weil ich die Methode weder mehrere Patterns annehmen kann, noch die Stücke, in denen der Regex matcht zurückgibt:
Java:
package cyrill.jx.compiler;

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

class RegexTokenizer {

    private CharSequence input;
    private Matcher[] matchers;
    private int lastEnd = 0;
    private int line = 0;

    public RegexTokenizer(CharSequence input, Pattern[] patterns) {
        this.input = input;
        matchers = new Matcher[patterns.length];
        for (int i = 0; i < patterns.length; i++) {
            matchers[i] = patterns[i].matcher(input);
        }
    }

    public String nextToken() {
        for (int i = 0; i < input.length(); i++) {
            if (input.charAt(i) == '\n' || input.charAt(i) == '\r') {
                line++;
            }
            if (Character.isWhitespace(input.charAt(i))) {
                continue;
            }
            for (int j = 0; j < matchers.length; j++) {
                System.out.println(matchers[i].find(lastEnd));
                if (matchers[i].find(i) && matchers[i].start() == i) {
                    int start = matchers[i].start();
                    int end = matchers[i].end();
                    i += end;
                    return input.subSequence(start, end).toString();
                }
            }
        }
        //throw new CompilerException("in line: " + line);
        return null;
    }

    public boolean hasNextToken() {
        boolean hasNext = false;
        if (lastEnd == input.length() - 1) {
            return false;
        }
        for (int i = 0; i < matchers.length; i++) {
            if (matchers[i].find(lastEnd)) {
                hasNext = true;
            }
        }
        return hasNext;
    }
}

eingentlich wäre es ja einfach, aber ich bekomms irgendwie nicht hin :bahnhof:. Danke an alle, die mir helfen.

edit:
Grammatikfehler :D
 
Zuletzt bearbeitet:

Atze

Top Contributor
was soll denn gesplitted werden? hast du n beispiel? und was soll rauskommen? lässt sich ohne beispiel schwer testen! :(
 

Runtime

Top Contributor
Input: "import blablabla;"
Output: null, null, null, null, null, null, null, null, null, null, null, null, null, null...
Alle Regex-Patterns:
Java:
new Object[][] {
                    {
                        END_STATEMENT,
                        STRING,
                        CHARACTER,
                        NUMBER,
                        OPERATOR_ASSIGNMENT,
                        OPERATOR_ADDITION,
                        OPERATOR_SUBTRACTION,
                        OPERATOR_MULTIPLICATION,
                        OPERATOR_DIVISION,
                        OPERATOR_INCREMENT,
                        OPERATOR_DECREMENT,
                        OPERATOR_AND,
                        OPERATOR_CONDITIONAL_AND,
                        OPERATOR_OR,
                        OPERATOR_CONDITIONAL_OR,
                        OPERATOR_XOR,
                        OPERATOR_COMPLEMENT,
                        OPERATOR_NULL_ASSIGN,
                        OPERATOR_FAST_IF_ELSE_QUESTION,
                        OPERATOR_FAST_IF_ELSE_SEPARATOR,
                        OPERATOR_OPEN_SEQUENCE,
                        OPERATOR_CLOSE_SEQUENCE,
                        OPERATOR_OPEN_PARAMETER,
                        OPERATOR_SEPARATE_PARAMETER,
                        OPERATOR_CLOSE_PARAMETER,
                        OPERATOR_OPEN_BLOCK,
                        OPERATOR_CLOSE_BLOCK,
                        OPERATOR_INTERVAL,
                        OPERATOR_POINT,
                        OPERATOR_REMAINDER,
                        OPERATOR_COMPARE_EQUAL,
                        OPERATOR_COMPARE_NOT_EQUAL,
                        OPERATOR_COMPARE_BIGGER_OR_EQUAL,
                        OPERATOR_COMPARE_BIGGER,
                        OPERATOR_COMPARE_LESS_EQUAL,
                        OPERATOR_COMPARE_LESS,
                        OPERATOR_BIT_COMPLEMENT,
                        OPERATOR_BIT_SIGNED_SHIFT_LEFT,
                        OPERATOR_BIT_SIGNED_SHIFT_RIGHT,
                        OPERATOR_BIT_UNSIGNED_SHIFT_RIGHT,
                        KEYWORD_CLASS,
                        KEYWORD_ENUM,
                        KEYWORD_INTERFACE,
                        KEYWORD_IMPORT,
                        KEYWORD_PACKAGE,
                        KEYWORD_BIND,
                        KEYWORD_OPERATOR,
                        KEYWORD_EXTENDS,
                        KEYWORD_IMPLEMENTS,
                        KEYWORD_IF,
                        KEYWORD_ELSE,
                        KEYWORD_TRY,
                        KEYWORD_CATCH,
                        KEYWORD_FINALLY,
                        KEYWORD_INSTANCEOF,
                        KEYWORD_NEW,
                        KEYWORD_SWITCH,
                        KEYWORD_CASE,
                        KEYWORD_SUPER,
                        KEYWORD_THIS,
                        KEYWORD_THROW,
                        KEYWORD_THROWS,
                        KEYWORD_RETURN,
                        KEYWORD_BREAK,
                        KEYWORD_CONTINUE,
                        KEYWORD_GOTO,
                        KEYWORD_WITH,
                        KEYWORD_ACCESS_PUBLIC,
                        KEYWORD_ACCESS_PRIVATE,
                        KEYWORD_ACCESS_PROTECTED,
                        KEYWORD_PROPERTY_ABSTRACT,
                        KEYWORD_PROPERTY_SYNCHRONIZED,
                        KEYWORD_PROPERTY_TRANSIENT,
                        KEYWORD_PROPERTY_FINAL,
                        KEYWORD_PROPERTY_STATIC,
                        KEYWORD_PROPERTY_VOLATILE,
                        KEYWORD_PROPERTY_NATIVE,
                        KEYWORD_PROPERTY_DYNAMIC,
                        KEYWORD_SHORTCUT_BOOLEAN,
                        KEYWORD_SHORTCUT_INTEGER,
                        KEYWORD_SHORTCUT_BYTE,
                        KEYWORD_SHORTCUT_LONG,
                        KEYWORD_SHORTCUT_FLOAT,
                        KEYWORD_SHORTCUT_SHORT,
                        KEYWORD_SHORTCUT_CHARACTER,
                        KEYWORD_SHORTCUT_DOUBLE,
                        KEYWORD_SHORTCUT_VOID,
                        KEYWORD_SHORTCUT_STRING,
                        KEYWORD_SHORTCUT_OBJECT,
                        KEYWORD_LOOP_DO,
                        KEYWORD_LOOP_FOR,
                        KEYWORD_LOOP_WHILE,
                        KEYWORD_LOOP_WHILENOT,
                        OPERATOR_ASSIGN_ADDITION,
                        OPERATOR_ASSIGN_SUBTRACTION,
                        OPERATOR_ASSIGN_DIVISION,
                        OPERATOR_ASSIGN_MULTIPLICATION,
                        OPERATOR_ASSIGN_REMAINDER,
                        IDENTIFIER
                    },
                    {
                        ";",
                        "\"[^\n]{0,}\"",
                        "'[^\n]'",
                        "(0x[\\da-fA-F]{0,})|(\\d{0,}([bilfdBILFD]){0,1})",
                        "(?<![^/*\\-\\+%])=",
                        "\\+(?![=+])",
                        "\\-(?![=-])",
                        "\\*(?!=)",
                        "/(?!=)",
                        "\\+{2}",
                        "\\-{2}",
                        "&{1}",
                        "&{2}",
                        "\\|{1}",
                        "\\|{2}",
                        "\\^",
                        "!(?!=)",
                        "\\?=",
                        "\\?(?!=)",
                        ":",
                        "\\[",
                        "\\]",
                        "\\(",
                        ",",
                        "\\)",
                        "\\{",
                        "\\}",
                        "\\.{2}",
                        "\\.(?!\\.)",
                        "%(?!=)",
                        "={2}",
                        "!=",
                        ">=",
                        ">(?![=>])",
                        "<=",
                        "<(?![=<])",
                        "~",
                        "<{2}",
                        ">>(?!>)",
                        ">{3}",
                        "\\bclass\\b",
                        "\\benum\\b",
                        "\\binterface\\b",
                        "\\bimport\\b",
                        "\\bpackage\\b",
                        "\\bbind\\b",
                        "\\boperator\\b",
                        "\\bextends\\b",
                        "\\bimplements\\b",
                        "\\bif\\b",
                        "\\belse\\b",
                        "\\btry\\b",
                        "\\bcatch\\b",
                        "\\bfinally\\b",
                        "\\binstanceof\\b",
                        "\\bnew\\b",
                        "\\bswitch\\b",
                        "\\bcase\\b",
                        "\\bsuper\\b",
                        "\\bthis\\b",
                        "\\bthrow\\b",
                        "\\bthrows\\b",
                        "\\breturn\\b",
                        "\\bbreak\\b",
                        "\\bcontinue\\b",
                        "\\bgoto\\b",
                        "\\bwith\\b",
                        "\\bpublic\\b",
                        "\\bprivate\\b",
                        "\\bprotected\\b",
                        "\\babstract\\b",
                        "\\bsynchronized\\b",
                        "\\btransient\\b",
                        "\\bfinal\\b",
                        "\\bstatic\\b",
                        "\\bvolatile\\b",
                        "\\bnative\\b",
                        "\\bdynamic\\b",
                        "\\bboolean\\b",
                        "\\binteger\\b",
                        "\\bbyte\\b",
                        "\\blong\\b",
                        "\\bfloat\\b",
                        "\\bshort\\b",
                        "\\bchar\\b",
                        "\\bdouble\\b",
                        "\\bvoid\\b",
                        "\\bstring\\b",
                        "\\bobject\\b",
                        "\\bdo\\b",
                        "\\bfor\\b",
                        "\\bwhile\\b",
                        "\\bwhilenot\\b",
                        "\\+=",
                        "\\-=",
                        "/=",
                        "\\*=",
                        "%=",
                        "\\w{1,}"
                    }
                };

edit:
was rauskommen sollte:
import, blablabla, ;
 
Zuletzt bearbeitet:

nrg

Top Contributor
hoffe mal ich habe dich richtig verstanden. du könntest z.B. versuchen, dir den nächsten Matcher in hasNextToken zu merken:

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

class RegexTokenizer {

	private CharSequence input;
	private Matcher[] matchers;
	private Matcher nextMatcher;
	private int lastEnd = 0;

	public static void main(String[] args) {
		String test = "hallo welt;das ist ein test,zum splitten eines Strings anhand mehrerer RegEx;mal sehen,ob es klappt";
		Pattern[] patterns = new Pattern[3];
		patterns[0] = Pattern.compile("\\s");
		patterns[1] = Pattern.compile(",");
		patterns[2] = Pattern.compile(";");
		RegexTokenizer rtok = new RegexTokenizer(test, patterns);
		while (rtok.hasNextToken()) {
			System.out.println(rtok.nextToken());
		}
	}
	public RegexTokenizer(CharSequence input, Pattern[] patterns) {
		this.input = input;
		matchers = new Matcher[patterns.length];
		for (int i = 0; i < patterns.length; i++) {
			matchers[i] = patterns[i].matcher(input);
		}
	}

	public CharSequence nextToken() {
		CharSequence token = input.subSequence(lastEnd, nextMatcher.start());
		lastEnd = nextMatcher.end();
		nextMatcher = null;
		return token;
	}

	public boolean hasNextToken() {
		boolean hasNext = false;
		if (lastEnd == input.length() - 1) {
			return false;
		}
		for (int i = 0; i < matchers.length; i++) {
			if (matchers[i].find(lastEnd)) {
				if (nextMatcher == null || matchers[i].start() < nextMatcher.start())
					nextMatcher = matchers[i];
				hasNext = true;
			}
		}
		return hasNext;
	}
}

edit: könntest vllt noch einen zweiten Konstruktor machen, der dir einen boolean returnDelimiters erlaubt. Somit könntest du auch die Trenntokens zurückgeben. Weiß ja nicht, was du damit vor hast.

ahja und anständige Exceptions würde ich auch noch einbauen. z.B. würde eine NPE fliegen, wenn du nextToken() vor hasNextToken() aufrufst oder nextToken() 2x hintereinander. Das kannst du natürlich zum einen etwas geschickt verhindern oder zum anderen eine IllegalStateException oder so schmeissen.
Das Ganze hab ich jetzt in dem Beispiel überhaupt nicht berücksichtigt. Musst du selbst entscheiden, wie du das haben willst.
 
Zuletzt bearbeitet:

diel2001

Bekanntes Mitglied
Warum machst du es dir so schwer, man kann auch folgendes schreiben :

Java:
meinString.split("\\.|;|\\s");

Hier sind jetzt 3 Trenner angeben
 
Zuletzt bearbeitet:

nrg

Top Contributor
Es sollte immer den Teil zurückgeben, bei dem es den fühesten match gibt. Übrigens gibt er immer noch nur null werte aus.

also willlst du jetzt sowohl tokens (stücke zwischen den matches) und matches zurückgeben oder nur eines der beiden? Ein Tokenizer macht das Erste und optional das Zweite (siehe mein edit im Vorpost). Wenn du nur das Zweite willst, hat das imho nichts mit einem split/tokenizer Algo zu tun. Wäre allerdings dem obigen Code ziemlich identisch (das Zusammensetzen vom returnwert in nextToken() wird ein bisschen abgeändert).
 

nrg

Top Contributor
die sache mit split ist eh hinfällig, weil der to was anderes sucht.

@to: wie gesagt: schreib den o.g. Code etwas um, dann sollte er auch das machen, was du suchst...
 

Runtime

Top Contributor
Wenn ich weiss, welche Regex gematcht hat, kann ich auch noch gleich den Typ angeben.

edit: Rechtschreibefehler
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
H Frage regex greater than less than Allgemeine Java-Themen 7
N Regex schlägt nicht an Allgemeine Java-Themen 10
W Variable Initialisierung mit dem Ergebnis einer Regex Allgemeine Java-Themen 1
T regex case insensitive trimmed Allgemeine Java-Themen 6
S Zeichen | in regex Allgemeine Java-Themen 8
X Regex mit mehreren Bedingungen machen Allgemeine Java-Themen 5
N Hilfe bei RegEx benötigt Allgemeine Java-Themen 3
C Java17 und Regex Allgemeine Java-Themen 13
OnDemand RegEx /compilebekomme nicht die erwarteten Werte Allgemeine Java-Themen 9
N Gierigen Regex in nicht-gierigen umwandeln Allgemeine Java-Themen 4
N E-Mail Validator (ohne Regex!) Allgemeine Java-Themen 7
OnDemand Regex von bis Allgemeine Java-Themen 6
W Versionsnummer auslesen - Regex ist zickig Allgemeine Java-Themen 2
L RegEx für Teile einer Berechnung Allgemeine Java-Themen 14
G Regex Allgemeine Java-Themen 2
L regex ganzer string? Allgemeine Java-Themen 2
MiMa Geldbetrag mit regex ermitteln. Allgemeine Java-Themen 14
W RegEx Stringliteral finden - Jflex Allgemeine Java-Themen 5
D Regex Probleme Allgemeine Java-Themen 2
Kirby.exe Regex charakter ignorieren Allgemeine Java-Themen 12
S Java SAT (Haltbarkeitsproblem) mit Regex Allgemeine Java-Themen 6
S [Regex] Nur diese Zeichen beachten Allgemeine Java-Themen 1
M Bitte Hilfe mit REGEX (Negieren) Allgemeine Java-Themen 4
J Compilerfehler bis in java.util.regex.Pattern... Allgemeine Java-Themen 2
C PDFBox: Nach RegEx ganze Zeile Allgemeine Java-Themen 4
S Regex mit UND-Verknüpfung Allgemeine Java-Themen 1
P RegEx für Zeiten Allgemeine Java-Themen 7
D Regex: Komplettes Wort bekommen Allgemeine Java-Themen 3
Neumi5694 Operatoren regEx für das Erstellen eines Strings verwenden Allgemeine Java-Themen 3
P RegEx Allgemeine Java-Themen 3
W String Parsen und auf eigenes Muster anwenden (kein Regex) Allgemeine Java-Themen 11
Y regex | n-faches Vorkommen oder gar keins Allgemeine Java-Themen 6
turmaline Regex gegen Regex prüfen Allgemeine Java-Themen 4
HarleyDavidson Regex - Optimierung Allgemeine Java-Themen 4
M Regex für Zahleneingabe in JavaFX Textfield Allgemeine Java-Themen 18
T Best Practice Wortregeln RegEx Allgemeine Java-Themen 11
A ALTER TABLE mit Hilfe von RegEx zerlegen, splitten Allgemeine Java-Themen 5
H Interpreter-Fehler Regex kompiliert nicht Allgemeine Java-Themen 5
M RegEx alle Matches ausgeben Allgemeine Java-Themen 5
Iron Monkey Mit Regex nach Beträge suchen Allgemeine Java-Themen 4
T REGEX Erklaerung Allgemeine Java-Themen 14
T Nur innerhalb des regex-Match ersetzen Allgemeine Java-Themen 9
H Pic Download / Regex Problem Allgemeine Java-Themen 7
F Frage zu Regex möglich Allgemeine Java-Themen 4
M Regex... mal wieder Allgemeine Java-Themen 3
H RegEx - Ersetze alles bis Leerzeichen Allgemeine Java-Themen 5
S regex verbrät CPU Allgemeine Java-Themen 6
V Regex Bereichs Filter Allgemeine Java-Themen 4
127.0.0.1 RegEx _ und 0-9 Allgemeine Java-Themen 45
S Entfernen von allen Nicht-Buchstaben chars aus einem String ohne Regex..? Allgemeine Java-Themen 10
P Java String Regex Allgemeine Java-Themen 2
AyKay Regex XPath Allgemeine Java-Themen 4
C Regex (Case insensitive und Umlaute) Allgemeine Java-Themen 4
D Regex Raute erkennen Allgemeine Java-Themen 2
nrg Zweistelligen Zahlenbereich mit RegEx Allgemeine Java-Themen 8
GilbertGrape Regex-Problem Allgemeine Java-Themen 2
W Denkblockade RegEx Allgemeine Java-Themen 2
S eigene regEx schreiben Allgemeine Java-Themen 4
C Regex expandieren Allgemeine Java-Themen 6
C Regex Überschniedung von Ausdrücken Allgemeine Java-Themen 16
reibi RegEX - Teilstring Allgemeine Java-Themen 6
R Java-RegEx terminiert nicht Allgemeine Java-Themen 3
M Regex: Ich stehe auf dem Schlauch Allgemeine Java-Themen 2
V Kleines Regex-Problem Allgemeine Java-Themen 3
B Regex "Problem" Allgemeine Java-Themen 4
B RegEx: (Um-)formulieren eines Pattern zur Identifizierung komplexer URLs Allgemeine Java-Themen 7
P RegEx mit HTML Parser für Java möglich? Allgemeine Java-Themen 10
J Regex: Fertige URLS aus Javascript Allgemeine Java-Themen 3
N Java regex Allgemeine Java-Themen 5
K Regex JSON Allgemeine Java-Themen 3
J RegEx Ausdruck Allgemeine Java-Themen 2
J Regex: URLS aus CSS Allgemeine Java-Themen 2
G RegEx- Ausdruck Allgemeine Java-Themen 4
G RegEx kein Unterstrich Allgemeine Java-Themen 2
A Text via RegEx durchsuchen und teile ersetzten Allgemeine Java-Themen 5
C Regex: Zahl ohne führende Null Allgemeine Java-Themen 13
W RegEx Zeile parsen Medium Allgemeine Java-Themen 8
X Java String Regex - Sonderzeichen Filtern Allgemeine Java-Themen 5
S Dateiname mit Regex parsen Allgemeine Java-Themen 3
Loyd Noch ne Regex-Frage: Verschachtelte Ausdrücke Allgemeine Java-Themen 4
R Java Regex Frage Allgemeine Java-Themen 17
Daniel_L RegEx-Frage: Ersetzen in UBB ausschließen Allgemeine Java-Themen 2
M Große Datei mit Regex durchsuchen Allgemeine Java-Themen 4
S regex für einen Link Allgemeine Java-Themen 3
E Regex alles nach ? löschen Allgemeine Java-Themen 4
M RegEx-Frage Allgemeine Java-Themen 2
E Regex HTML Tag und Inhalt löschen Allgemeine Java-Themen 4
H RegEX und eMail Allgemeine Java-Themen 4
L-ectron-X Regex zum Entfernen von mehrzeiligen Kommentaren Allgemeine Java-Themen 2
martin82 Regex - JTable - Filter Allgemeine Java-Themen 10
nrg Kleine Hilfe mit RegEx Allgemeine Java-Themen 2
B Regex-Fehler nach lib-Update Allgemeine Java-Themen 2
K Contrains oder Regex Allgemeine Java-Themen 3
J replaceAll , "[", "]" & regex Allgemeine Java-Themen 12
P RegEx und $-Zeichen als Literal Allgemeine Java-Themen 5
P RegEx - Worte ausschließen Allgemeine Java-Themen 8
S Regex - was isst denn {javaLetter} und {javaDigit}? Allgemeine Java-Themen 2
D Wie werden Regex-Gruppen kompiliert? Allgemeine Java-Themen 2
Stillmatic RegEx Matches ausgeben Allgemeine Java-Themen 10
A Regex gesucht Allgemeine Java-Themen 9

Ähnliche Java Themen

Neue Themen


Oben