String nach bestimmten kriterien splitten

[Aldimann]

Hi zsam,

ich hab für folgendes Problem zwar Lösungsansätze, finde die aber alle nicht so optimal und stehe irgendwie auf dem schlauch.

Ich möchte aus einer CSV Datei values in eine Property Datei schreiben.Die CSV ist so Aufgabaut das erst der Key kommt und danach eine Zahl X an Values (hat auch seinen Grund ). Key sowie Values werden durch ein Semikolon ( ; ) separiert. Problem ist jetzt, wenn ein Semikolon in einem Property Value steht.

In der CSV ist das kein Problem weil Teile die zusammengehören in Anführungszeichen stehen, und eben das müsste ich jetzt auch mit java machen.

Bsp. zur CSV:


Export.comment;"'>&nbsp;</td><td><span class='normal'>Kommentar:</span></td><td><span class='normal'>";


Export.comment ist der Key der Rest EIN Value.

Würde das ganze jetzt in einem String stehen und ich rufe auf diesen spilt(";") auf, so käme dabei raus:
{"Export.comment", ""'>&nbsp", "</td><td><span class='normal'>Kommentar:</span></td><td><span class='normal'>""};

Also würde mein Value der eigentlich zusammen gehört auseinander gerissen.

Ich möchte aber das folgendes dabei rauskommen würde:

{"Export.comment", "'>&nbsp;</td><td><span class='normal'>Kommentar:</span></td><td><span class='normal'>"};

Dafür müsste er halt merken, dass alles in den Anführungszeichen zusammen gehört und danach stellt sich mir die Frage wie ich das wieder in mein Array bekomme ohne Daten doppelt zu haben, aber den Rest des Strings auch zu splitten.

Ich weiß recht kompliziert wie ich das alles erkläre. :/

Meine Idee wäre jetzt schonmal mit einer while schleife über den Text in den Anführungszeichen zu gehen um diese in einen anderen String zu speichern.

 

[bygones]

mit indexOf das erste ; ermitteln und dann ueber substring den anfang bzw den rest rausholen

bzw wenns propertie werden soll
[c]s.replaceFirst(";", "=")[/c]
dann hast den Key und den value getrennt

 

[Aldimann]

Das Problem ist die Datei könnte auch so aussehen das nach dem ersten Value ein zweiter Value kommt.

Um das mal auf zu klären, das sind i18n Property Dateien, und in einer Zeile steht halt für einen Key die Values in der jeweiligen Sprache, das ganze könnte somit z.B. auch so aussehen:

einKey; "Hallo; du"; "Hello; you"; "Bonjour; sont";

also komme ich da mit replaceFirst nicht weit :/

 

[Michael...]

Hier mal ein erster Ansatz, lässt sich sicherlich noch verfeinern:

String test = "einKey; \"Hallo; du\"; \"Hello; you\"; \"Bonjour; sont\";";
System.out.println(test);
System.out.println("***********************");
String[] item = test.split("\"?\\s*;\\s*\"");
for (int i=0; i<item.length; i++)
	System.out.println(item[i]);

Ausserdem müssen beim letzten Wert noch die letzten zwei Zeichen abgetrennt werden.

 

[Aldimann]

Könnte mir nur jmd mal den split string erklären?

 

[Michael...]

Trenne wenn Du:
\"? - 0 oder 1 " findest
\\s* - gefolgt von beliebig vielen whitespaces
; - gefolgt von einen ;
\\s* - gefolgt von beliebig vielen whitespaces
\" - gefolgt von "

 

[Aldimann]

Kann man diese Schalter irgendwo nachlesen?

Hab grad a bissl gegoogelt aber Spontan nix gefunden

 

[Michael...]

Es handelt sich dabei um reguläre Ausdrücke (oder kurz RegEx). Ein einfache Übersicht gibt's z.B. hier:
Regulärer Ausdruck ? Wikipedia

 

[Ebenius]

Sicher, dass Double-Quotes nicht auch drin vorkommen können? Mir sieht das nach einem CSV aus, da ist [c]"[/c] üblicher Weise ebenfalls abbildbar über [c]""[/c]. Und dann funktioniert der Split nicht mehr.

[Edit] Ich hätte mal den Eingangsbeitrag richtig lesen sollen. Ich bin wohl noch nicht richtig wach. :noe: Es sind also CSVs. Michaels Reg-Ex hab ich auch erstmal falsch interpretiert. Also nochmal neu:

Muss ein String denn in Quotes stehen? Oder nur, dann, wenn er Semikolons (oder doppelte Anführungsstriche) beinhaltet? Wenn optional, dann funktioniert die Reg-Ex oben nicht:

[c]key; [/c]|[c]"Ein; Eintrag"; [/c]|[c]Ein anderer Eintrag[/c]

Wie sieht ein doppeltes Anführungszeichen aus? Wenn das so aussieht: [c]""[/c] ... dann funktioniert die Reg-Ex auch nicht:

[c]key; [/c]|[c]"Ein; Eintrag"; [/c]|[c]"Ein anderer; ""Eintrag"[/c]

Ebenius

 

[Aldimann]

Ah danke michael! Wieder ein Stück schlauer.

Ja leider ist Reg-ex noch nicht ganz darauf zugeschnitten, wie ich sie brauche.

Die Values müssen nicht zwangsweise in Anführungszeichen stehen, sondern tuen dies eigentlich nur, wenn innerhalb des Values ein Semikolon ist.


Deinen zweiten Fall verstehe ich nicht ganz aber ich glaub du meinst das hier:

[c]key;[/c] [c]"Hier; steht ein Text in dem "LOL" gesagt wird" ;[/c][c] "anderer Value...";[/c]

Wenn in einem Value ein Zitat o.Ä. ist, was auch in Anführungszeichen gesetzt wird...

Irgendwie ist hier die Problemlösung nicht ganz so einfach wie es am Anfang aussieht :/

 

[Ebenius]

Nö, ein CSV-Parser ist ne hübsche Maschine. Ich wollte schon immer eine schreiben, bin grad dabei, aber noch nicht fertig.

Ebenius

 

[Aldimann]

Dann hast du doch schon bestimmt eine Idee für mein Problem?

 

[Ebenius]

Das macht ja richtig Freude. Scheint gut zu funktionieren, aber der JUnit-TestCase testet noch nicht alles, deswegen weiß ich nicht, ob alles funktioniert... Hier also der gute CSVParser:

/* $Id: CSVParser.java,v 1.1 2009/12/10 13:44:43 ebenius Exp $ */

/* Copyright 2009 Sebastian Haufe

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       [url]http://www.apache.org/licenses/LICENSE-2.0[/url]

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */

package com.ebenius.util.text;

import java.io.IOException;
import java.io.LineNumberReader;
import java.io.Reader;
import java.text.ParseException;
import java.util.*;

/**
 * CSV parser processing character data from a {@link Reader}.
 * <p>
 * This class is not thread safe!
 * 
 * @version $Revision: 1.1 $ as of $Date: 2009/12/10 13:44:43 $
 * @author Sebastian Haufe
 */
public class CSVParser {

  // -------------------------------------------------------------------------
  // State machine
  // -------------------------------------------------------------------------

  enum AnalyzerState {
    UNINTIALIZED,
    UNQUOTED_WHITESPACE,
    UNQUOTED_CHARACTER,
    IGNORED_WHITESPACE,
    SEPARATOR,
    QUOTE_START,
    QUOTED_CHARACTER,
    QUOTED_QUOTE_OR_END,
    QUOTED_QUOTE,
    QUOTE_TRAILING_WHITESPACE,
    ILLEGAL_CHARACTER,
    EOL;

    private Collection<AnalyzerState> followers;

    private AnalyzerState[] determineFollowers(AnalyzerState state) {
      switch (this) {
      case UNINTIALIZED:
      case EOL:
      case IGNORED_WHITESPACE:
      case SEPARATOR:
        return new AnalyzerState[] { EOL, IGNORED_WHITESPACE, SEPARATOR,
          UNQUOTED_CHARACTER, QUOTE_START };

      case UNQUOTED_CHARACTER:
      case UNQUOTED_WHITESPACE:
        return new AnalyzerState[] { UNQUOTED_CHARACTER, EOL, SEPARATOR,
          UNQUOTED_WHITESPACE, ILLEGAL_CHARACTER };

      case QUOTE_START:
      case QUOTED_CHARACTER:
      case QUOTED_QUOTE:
        return new AnalyzerState[] { QUOTED_CHARACTER, QUOTED_QUOTE_OR_END };
      case QUOTED_QUOTE_OR_END:
        return new AnalyzerState[] { QUOTE_TRAILING_WHITESPACE, QUOTED_QUOTE,
          EOL, SEPARATOR, ILLEGAL_CHARACTER };
      case QUOTE_TRAILING_WHITESPACE:
        return new AnalyzerState[] { QUOTE_TRAILING_WHITESPACE, EOL,
          SEPARATOR, ILLEGAL_CHARACTER };

      case ILLEGAL_CHARACTER:
        return new AnalyzerState[] { ILLEGAL_CHARACTER };
      }
      assert false;
      return new AnalyzerState[] {};
    }

    Collection<AnalyzerState> getTransitions() {
      if (followers == null) {
        final List<AnalyzerState> l = Arrays.asList(determineFollowers(this));
        followers = Collections.unmodifiableCollection(l);
      }
      return followers;
    }

    AnalyzerState evaluateTransition(char c, char separator, char quote) {
      AnalyzerState follower = UNINTIALIZED;
      switch (this) {
      case UNINTIALIZED:
      case EOL:
      case IGNORED_WHITESPACE:
      case SEPARATOR:
        if (c == separator) {
          follower = SEPARATOR;
        } else if (isLineEnd(c)) {
          follower = EOL;
        } else if (c == quote) {
          follower = QUOTE_START;
        } else if (isWhiteSpace(c)) {
          follower = IGNORED_WHITESPACE;
        } else {
          follower = UNQUOTED_CHARACTER;
        }
        break;

      case UNQUOTED_CHARACTER:
      case UNQUOTED_WHITESPACE:
        if (c == separator) {
          follower = SEPARATOR;
        } else if (isLineEnd(c)) {
          follower = EOL;
        } else if (c == quote) {
          follower = ILLEGAL_CHARACTER;
        } else if (isWhiteSpace(c)) {
          follower = UNQUOTED_WHITESPACE;
        } else {
          follower = UNQUOTED_CHARACTER;
        }
        break;

      case QUOTE_START:
      case QUOTED_CHARACTER:
      case QUOTED_QUOTE:
        if (c == quote) {
          follower = QUOTED_QUOTE_OR_END;
        } else {
          follower = QUOTED_CHARACTER;
        }
        break;

      case QUOTED_QUOTE_OR_END:
        if (c == separator) {
          follower = SEPARATOR;
        } else if (isLineEnd(c)) {
          follower = EOL;
        } else if (c == quote) {
          follower = QUOTED_QUOTE;
        } else if (isWhiteSpace(c)) {
          follower = QUOTE_TRAILING_WHITESPACE;
        } else {
          follower = ILLEGAL_CHARACTER;
        }
        break;

      case QUOTE_TRAILING_WHITESPACE:
        if (c == separator) {
          follower = SEPARATOR;
        } else if (isLineEnd(c)) {
          follower = EOL;
        } else if (isWhiteSpace(c)) {
          follower = QUOTE_TRAILING_WHITESPACE;
        } else {
          follower = ILLEGAL_CHARACTER;
        }
        break;

      case ILLEGAL_CHARACTER:
        follower = ILLEGAL_CHARACTER;
        break;
      }
      assert getTransitions().contains(follower);
      return follower;
    }

    private boolean isLineEnd(char c) {
      return c == '\n';
    }

    boolean isWhiteSpace(char c) {
      return c == ' ' || c == '\t';
    }
  }

  // -------------------------------------------------------------------------
  // Instance fields
  // -------------------------------------------------------------------------

  private final char separator;
  private final char quote;
  private final LineNumberReader in;
  private int lineOffset = 0;

  private final StringBuilder wordBuffer = new StringBuilder();

  // -------------------------------------------------------------------------
  // Constructors
  // -------------------------------------------------------------------------

  /**
   * Creates a new {@code CSVParser}.
   * 
   * @param in the reader to read data from
   * @param separator the column separator
   * @param quote the quote character
   * @throws IllegalArgumentException if {@code reader} is {@code null},
   *           {@code quote} is SPC or TAB, or {@code separator} and {@code
   *           quote} are equal
   */
  @SuppressWarnings("nls")
  public CSVParser(Reader in, char separator, char quote) {
    if (in == null) {
      throw new IllegalArgumentException("reader not allowed null");
    }
    if (separator == quote) {
      throw new IllegalArgumentException(
            "separator and quote character not allowed equal");
    }
    if (quote == ' ' || quote == '\t') {
      throw new IllegalArgumentException("quote character not allowed SPC");
    }

    if (in instanceof LineNumberReader) {
      this.in = (LineNumberReader) in;
    } else {
      this.in = new LineNumberReader(in);
    }
    this.separator = separator;
    this.quote = quote;
  }

  // -------------------------------------------------------------------------
  // Public API
  // -------------------------------------------------------------------------

  /**
   * Reads a logical line from the input. Returns {@code null} if the
   * 
   * @return the parsed line or {@code null} if the end of stream is reached
   * @throws ParseException if parsing the line fails due to illegal format
   * @throws IOException if reading from the stream fails
   */
  @SuppressWarnings("nls")
  public String[] readLine() throws ParseException, IOException {
    final List<String> result = new LinkedList<String>();
    wordBuffer.setLength(0);
    AnalyzerState prevState = AnalyzerState.UNINTIALIZED;
    int unquotedWhiteSpaceStart = -1;
    int totalOffset = lineOffset;
    do {
      final int readResult = in.read();
      final char c = (char) readResult;

      // end of character sequence
      if (readResult == -1) {
        switch (prevState) {
        case QUOTE_START:
        case QUOTED_CHARACTER:
        case QUOTED_QUOTE:
          throw new ParseException(
                buildParseExceptionMessage(in.toString(), in.getLineNumber(),
                      lineOffset, prevState, AnalyzerState.EOL), totalOffset);

        case EOL:
          assert false : "Loop must have terminated on EOL";
          break;

        case ILLEGAL_CHARACTER:
          assert false : "Must have thrown exception on ILLEGAL_CHARACTER";
          break;

        case UNINTIALIZED: // end of stream
          return null;

        case IGNORED_WHITESPACE:
          assert false : prevState + " is never assigned to prevState";
          break;

        case UNQUOTED_WHITESPACE:
          wordBuffer.setLength(unquotedWhiteSpaceStart);
          result.add(new String(wordBuffer));
          break;

        case SEPARATOR: // trailing empty cell (word is empty!)
        case QUOTED_QUOTE_OR_END: // it is the quote end then
        case QUOTE_TRAILING_WHITESPACE: // quote had been closed before
        case UNQUOTED_CHARACTER: // word ends with the character
          result.add(new String(wordBuffer));
          break;
        }

        break; // break loop
      }

      ++totalOffset;
      final AnalyzerState newState =
            prevState.evaluateTransition(c, separator, quote);
      switch (newState) {
      case ILLEGAL_CHARACTER:
        throw new ParseException(buildParseExceptionMessage(in.toString(), in
              .getLineNumber(), lineOffset, prevState, newState), totalOffset);
      case IGNORED_WHITESPACE:
        continue;

      case UNINTIALIZED:
        assert false;
        break;

      case QUOTED_CHARACTER:
      case QUOTED_QUOTE:
        wordBuffer.append(c);
        break;

      case QUOTED_QUOTE_OR_END:
      case QUOTE_START:
      case QUOTE_TRAILING_WHITESPACE:
        break;

      case EOL:
      case SEPARATOR:
        if (unquotedWhiteSpaceStart != -1) {
          wordBuffer.setLength(Math.min(unquotedWhiteSpaceStart, wordBuffer
                .length()));
        }
        result.add(new String(wordBuffer));
        wordBuffer.setLength(0);
        break;

      case UNQUOTED_CHARACTER:
        if (unquotedWhiteSpaceStart != -1) {
          unquotedWhiteSpaceStart = -1;
        }
        wordBuffer.append(c);
        break;

      case UNQUOTED_WHITESPACE:
        if (unquotedWhiteSpaceStart == -1) {
          unquotedWhiteSpaceStart = wordBuffer.length();
        }
        wordBuffer.append(c);
        break;
      }

      prevState = newState;
    } while (prevState != AnalyzerState.EOL);

    lineOffset = totalOffset;
    return result.toArray(new String[result.size()]);
  }

  // -------------------------------------------------------------------------
  // Helper methods
  // -------------------------------------------------------------------------

  @SuppressWarnings("nls")
  private static String buildParseExceptionMessage(
        String in,
        int lineNumber,
        int lineOffset,
        AnalyzerState sourceState,
        AnalyzerState destinationState) {
    final StringBuilder sb = new StringBuilder(in.length() * 3);
    sb.append("Parse Error in line '").append(lineNumber);
    sb.append(" at ").append(lineOffset).append(":\n");
    sb.append(in);
    if (destinationState == AnalyzerState.EOL) {
      sb.append("<EOL>");
    }
    sb.append('\n');
    for (int i = 0; i < lineOffset; i++) {
      sb.append(' ');
    }
    sb.append("^\nExpected one of:");
    for (AnalyzerState follower : sourceState.getTransitions()) {
      if (follower == AnalyzerState.ILLEGAL_CHARACTER) {
        continue;
      }
      sb.append("\n\t<").append(follower).append('>');
    }
    return sb.toString();
  }
}

Und hier der JUnit(3)-Test-Case:

/* $Id: CSVParserTest.java,v 1.1 2009/12/10 13:44:43 ebenius Exp $ */

/* Copyright 2009 Sebastian Haufe

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       [url]http://www.apache.org/licenses/LICENSE-2.0[/url]

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */

package com.ebenius.util.text;

import java.io.IOException;
import java.io.StringReader;
import java.text.ParseException;
import java.util.*;

import junit.framework.TestCase;

import com.ebenius.util.text.CSVParser.AnalyzerState;

/**
 * Test case for {@link CSVParser}
 * 
 * @version $Revision: 1.1 $ as of $Date: 2009/12/10 13:44:43 $
 * @author Sebastian Haufe
 */
@SuppressWarnings("nls")
public class CSVParserTest extends TestCase {

  // -------------------------------------------------------------------------
  // Tests
  // -------------------------------------------------------------------------

  /**
   * Cross-checks {@link AnalyzerState#evaluateTransition(char, char, char)}
   * evaluated transitions from all states for the test characters {@code 'a',
   * ' ', ';', '"', '\n'} against all {@link AnalyzerState#getTransitions()
   * transitions available}.
   */
  public void testEvaluatedTransitionAllowed() {
    final char[] chars = { 'a', ' ', ';', '"', '\n' };
    for (AnalyzerState source : AnalyzerState.values()) {
      for (char c : chars) {
        final AnalyzerState dest = source.evaluateTransition(c, ';', '"');
        final Collection<AnalyzerState> transitions = source.getTransitions();
        if (!transitions.contains(dest)) {
          fail("Transition from <"
                + source
                + " ('"
                + c
                + "') to <"
                + dest
                + "> not listed in followers: "
                + Arrays.toString(transitions.toArray()));
        }
      }
    }
  }

  /**
   * Tests several unquoted CSVs.
   * 
   * @throws ParseException if parsing fails
   */
  public void testUnquotedCSV() throws ParseException {
    parseLine("empty stream", "", ';', '"');
    parseLine("one entry", "Eintrag1", ';', '"', "Eintrag1");
    parseLine("two entries", "Eintrag1;Eintrag2", ';', '"', "Eintrag1",
          "Eintrag2");
    parseLine("trimmed spaces", " Eintrag 1     ;  Eintrag  2   ", ';', '"',
          "Eintrag 1", "Eintrag  2");
    parseLine("trimmed spaces & empty entries",
          " Eintrag 1     ;  Eintrag  2   ;;", ';', '"', "Eintrag 1",
          "Eintrag  2", "", "");
  }

  /**
   * Tests several quoted CSVs.
   * 
   * @throws ParseException if parsing fails
   */
  public void testQuotedCSV() throws ParseException {
    parseLine("one entry", "\"Eintrag1\"", ';', '"', "Eintrag1");
    parseLine("two entries", "\"Eintrag1\";\"Eintrag2\"", ';', '"',
          "Eintrag1", "Eintrag2");
    parseLine("trimmed spaces", " \"Eintrag 1\"     ;  \"Eintrag  2\"   ",
          ';', '"', "Eintrag 1", "Eintrag  2");
    parseLine("trimmed & untrimmed spaces & empty entries",
          " \"  Eintrag 1  \"   ;\"Eintrag  2 \"  ;;\"\"", ';', '"',
          "  Eintrag 1  ", "Eintrag  2 ", "", "");
    parseLine("quoted quote",
          " \"\"\"Eintrag 1\"\"\"   ;\"  \"\" Eintrag  2 \"\" \"  ;\"\"\"\"",
          ';', '"', "\"Eintrag 1\"", "  \" Eintrag  2 \" ", "\"");
    parseLine("quoted linefeed",
          "\"Eintrag\n\n\n1\";\"  Eintrag\n\"\"\n\n2 \"", ';', '"',
          "Eintrag\n\n\n1", "  Eintrag\n\"\n\n2 ");
  }

  /**
   * Tests several multi-line CSVs.
   * 
   * @throws ParseException if parsing fails
   */
  public void testMultiLineCSV() throws ParseException {
    CSVParser p;
    final String simple = "Spalte A;Spalte B\n1A;1B\n2A;2B";
    p = createParser(simple, ';', '"');
    parseLine("quoted simple 2x3, line 1", p, "Spalte A", "Spalte B");
    parseLine("quoted simple 2x3, line 2", p, "1A", "1B");
    parseLine("quoted simple 2x3, line 3", p, "2A", "2B");
    parseLine("quoted simple 2x3, EOF", p);

    final String mixed = "\"Spalte\n\nA\";Spalte B\n1A;1B\n2A;\"2\n\n\nB\"";
    p = createParser(mixed, ';', '"');
    parseLine("quoted mixed 2x3, line 1", p, "Spalte\n\nA", "Spalte B");
    parseLine("quoted mixed 2x3, line 2", p, "1A", "1B");
    parseLine("quoted mixed 2x3, line 3", p, "2A", "2\n\n\nB");
    parseLine("quoted mixed 2x3,  EOF", p);
  }

  private void parseLine(
        String message,
        String input,
        char separator,
        char quote,
        String... expected) throws ParseException {
    parseLine(message, createParser(input, separator, quote), expected);
  }

  private void parseLine(String message, CSVParser parser, String... expected)
        throws ParseException {
    try {
      final String[] result = parser.readLine();
      assertEquals(message, formatArray(expected), formatArray(result));
    } catch (IOException ex) {
      fail("StringReader throws IO exception???");
      ex.printStackTrace();
    }
  }

  private CSVParser createParser(String input, char separator, char quote) {
    final CSVParser parser =
          new CSVParser(new StringReader(input), separator, quote);
    return parser;
  }

  private List<String> formatArray(String[] array) {
    if (array == null || array.length == 0) {
      return null;
    }

    final List<String> result = Arrays.asList(array);
    for (ListIterator<String> it = result.listIterator(); it.hasNext();) {
      final String s = it.next().replace(' ', '+').replaceAll("\n", "\\\\n");
      it.set('\'' + s + '\'');
    }
    return result;
  }
}

Apache2-Lizenz: Du kannst es einfach kopieren und nutzen.

Ebenius

 

[Aldimann]

Danke schön!

Hab zwar gestern dann noch was eigenes programmiert, aber ich werde mir deinen Code mit sicherheit demnächst nochmal anschauen, weil deiner ziemlich sicher besser ist als meiner ...

Also nochmal danke