Java, teile einen String durch verschiedene Tags und speichere ihn in einer Map

Ich habe die Anforderung, eine Art Markdown-Tags zu erstellen, um beim Erstellen von {{X2 }} mit IText.

Also, angesichts dieser Zeichenfolge:

String toCheck = "Example [N]bold text[N] other example [C]italic text[C]";

Sollte ergeben:

Beispiel Fettdruck anderes Beispiel Kursivtext

Also, lasst uns gehen:

Ich habe eine Aufzählung mit Schriftarten:

private enum FontType {
    BOLD, ITALIC, NORMAL
}

Um dies zu erreichen, möchte ich ein LinkedHashMap<String, Enum> erstellen, um die String-Fragmente mit dem entsprechenden Schrifttyp einzufügen (letzteres wird in com.itextpdf.text.Chunk umgewandelt und in ein einzelnes com.itextpdf.text.Paragraph eingefügt.

Wie kann ich das LinkedHashMap Ergebnis so erzielen?

pos String            enum
0   "Example "        NORMAL
1   "bold text"       BOLD
2   " other example " NORMAL
3   "italic text"     ITALIC

Ich habe ein benutzerdefiniertes Iterator erstellt, das mir die Tag-Position gibt:

public class OwnIterator implements Iterator<Integer> 
{
    private Iterator<Integer> occurrencesItr;

    public OwnIterator(String toCheck, String[] validPair) {
        // build regex to search for every item in validPair
        Matcher[] matchValidPair = new Matcher[validPair.length];
        for (int i = 0 ; i < validPair.length ; i++) {
            String regex = 
                    "(" +    // start capturing group
                    "\\Q" +  // quote entire input string so it is not interpreted as regex
                    validPair[i] +  // this is what we are looking for, duhh 
                    "\\E" +  // end quote
                    ")" ;    // end capturing group
            Pattern p = Pattern.compile(regex);
            matchValidPair[i] = p.matcher(toCheck);
        }
        // do the search, saving found occurrences in list
        List<Integer> occurrences = new ArrayList<>();
        for (int i = 0 ; i < matchValidPair.length ; i++) {
            while (matchValidPair[i].find()) {
                occurrences.add(matchValidPair[i].start(0)+1);  // +1 if you want index to start at 1 
            }
        }
        // sort the list 
        Collections.sort(occurrences);
        occurrencesItr = occurrences.iterator();
    }

    @Override
    public boolean hasNext()  {
        return occurrencesItr.hasNext();
    }

    @Override
    public Integer next() {
        return occurrencesItr.next();
    }

    @Override
    public void remove() {
        occurrencesItr.remove();
    }

}

Ich habe bereits überprüft, ob Tags ausgeglichen sind, und kann alle Tag-Positionen abrufen:

String[] validPair = {"[N]", "[C]" };
OwnIterator itr = new OwnIterator(toCheck, validPair);
while (itr.hasNext()) {
    System.out.println(itr.next());
}

Aber nachdem Sie alle Positionen erhalten haben, können Sie nicht herausfinden, wie Sie jeden Teil unterscheiden und den richtigen Aufzählungswert zuweisen können.

Einige Ideen? Vielleicht irre ich mich oder jemand kann einen besseren sehen?