Java: So ermitteln Sie die korrekte Zeichensatzcodierung eines Streams

Mit Bezug auf den folgenden Thread: Java-App: ISO-8859-1-codierte Datei kann nicht korrekt gelesen werden

Wie kann die korrekte Zeichensatzcodierung eines Eingabestreams / einer Eingabedatei am besten programmgesteuert ermittelt werden?

Ich habe versucht, Folgendes zu verwenden:

File in =  new File(args[0]);
InputStreamReader r = new InputStreamReader(new FileInputStream(in));
System.out.println(r.getEncoding());

Bei einer Datei, von der ich weiß, dass sie mit ISO8859_1 codiert ist, liefert der obige Code ASCII, was nicht korrekt ist und es mir nicht ermöglicht, den Inhalt der Datei korrekt auf der Konsole wiederzugeben.

Ich habe diese Bibliothek ähnlich wie jchardet zum Erkennen der Codierung in Java verwendet: http://code.google.com/p/juniversalchardet/

Sie können die Codierung eines beliebigen Bytestreams nicht bestimmen. Dies ist die Natur der Kodierungen. Eine Codierung bedeutet eine Zuordnung zwischen einem Bytewert und seiner Darstellung. Jede Kodierung "könnte" also die richtige sein.

Die Methode getEncoding () gibt die Codierung zurück, die für den Stream eingerichtet wurde (lesen Sie JavaDoc ). Die Kodierung wird für Sie nicht erraten.

Einige Streams geben an, mit welcher Codierung sie erstellt wurden: XML, HTML. Aber kein beliebiger Bytestrom.

Auf jeden Fall könnten Sie versuchen, eine Kodierung selbst zu erraten, wenn Sie müssen. Jede Sprache hat eine gemeinsame Frequenz für jedes Zeichen. Im Englischen erscheint das Zeichen sehr oft, aber ê wird sehr, sehr selten erscheinen. In einem ISO-8859-1-Stream gibt es normalerweise keine 0x00-Zeichen. Aber ein UTF-16-Stream hat viele davon.

Oder: Sie könnten den Benutzer fragen. Ich habe bereits Anwendungen gesehen, die Ihnen einen Ausschnitt der Datei in verschiedenen Codierungen präsentieren und Sie bitten, die "richtige" auszuwählen.

Überprüfen Sie dies: http://site.icu-project.org/ (icu4j) Sie haben Bibliotheken zum Erkennen von Zeichensätzen von IOStream könnte so einfach sein:

BufferedInputStream bis = new BufferedInputStream(input);
CharsetDetector cd = new CharsetDetector();
cd.setText(bis);
CharsetMatch cm = cd.detect();

if (cm != null) {
   reader = cm.getReader();
   charset = cm.getName();
}else {
   throw new UnsupportedCharsetException()
}

Hier sind meine Favoriten:

TikaEncodingDetector

Abhängigkeit:

<dependency>
  <groupId>org.apache.any23</groupId>
  <artifactId>apache-any23-encoding</artifactId>
  <version>1.1</version>
</dependency>

Stichprobe:

public static Charset guessCharset(InputStream is) throws IOException {
  return Charset.forName(new TikaEncodingDetector().guessEncoding(is));    
}

GuessEncoding

Abhängigkeit:

<dependency>
  <groupId>org.codehaus.guessencoding</groupId>
  <artifactId>guessencoding</artifactId>
  <version>1.4</version>
  <type>jar</type>
</dependency>

Stichprobe:

  public static Charset guessCharset2(File file) throws IOException {
    return CharsetToolkit.guessEncoding(file, 4096, StandardCharsets.UTF_8);
  }

Sie können die Datei auf jeden Fall für einen bestimmten Zeichensatz validieren, indem Sie sie mit a dekodierenCharsetDecoder und auf Fehler bei "fehlerhafter Eingabe" oder "nicht zuordnbaren Zeichen" achten. Dies sagt Ihnen natürlich nur, wenn ein Zeichensatz falsch ist. es sagt dir nicht, ob es richtig ist. Dazu benötigen Sie eine Vergleichsbasis, um die dekodierten Ergebnisse auszuwerten. Wissen Sie beispielsweise im Voraus, ob die Zeichen auf eine Teilmenge beschränkt sind oder ob der Text einem strengen Format entspricht? Das Fazit ist, dass die Zeichensatzerkennung ohne Garantie ein Rätselraten ist.

Welche Bibliothek soll ich benutzen?

Zum jetzigen Zeitpunkt entstehen drei Bibliotheken:

• GuessEncoding
• ICU4j
• juniversalchardet

Ich schließe Apache Any23 nicht ein da es ICU4j 3.4 unter der Haube verwendet.

Wie man erkennt, wer das Recht erkannt hat Zeichensatz (oder so nah wie möglich)?

Es ist unmöglich, den von den oben genannten Bibliotheken erkannten Zeichensatz zu zertifizieren. Es ist jedoch möglich, sie nacheinander zu fragen und die zurückgegebene Antwort zu bewerten.

Wie kann ich die zurückgegebene Antwort bewerten?

Jeder Antwort kann ein Punkt zugewiesen werden. Je mehr Punkte eine Antwort hat, desto mehr Vertrauen hat der erkannte Zeichensatz. Dies ist eine einfache Bewertungsmethode. Sie können andere ausarbeiten.

Gibt es einen Beispielcode?

Hier ist ein vollständiger Ausschnitt, der die in den vorherigen Zeilen beschriebene Strategie implementiert.

public static String guessEncoding(InputStream input) throws IOException {
    // Load input data
    long count = 0;
    int n = 0, EOF = -1;
    byte[] buffer = new byte[4096];
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    while ((EOF != (n = input.read(buffer))) && (count <= Integer.MAX_VALUE)) {
        output.write(buffer, 0, n);
        count += n;
    }
    
    if (count > Integer.MAX_VALUE) {
        throw new RuntimeException("Inputstream too large.");
    }

    byte[] data = output.toByteArray();

    // Detect encoding
    Map<String, int[]> encodingsScores = new HashMap<>();

    // * GuessEncoding
    updateEncodingsScores(encodingsScores, new CharsetToolkit(data).guessEncoding().displayName());

    // * ICU4j
    CharsetDetector charsetDetector = new CharsetDetector();
    charsetDetector.setText(data);
    charsetDetector.enableInputFilter(true);
    CharsetMatch cm = charsetDetector.detect();
    if (cm != null) {
        updateEncodingsScores(encodingsScores, cm.getName());
    }

    // * juniversalchardset
    UniversalDetector universalDetector = new UniversalDetector(null);
    universalDetector.handleData(data, 0, data.length);
    universalDetector.dataEnd();
    String encodingName = universalDetector.getDetectedCharset();
    if (encodingName != null) {
        updateEncodingsScores(encodingsScores, encodingName);
    }

    // Find winning encoding
    Map.Entry<String, int[]> maxEntry = null;
    for (Map.Entry<String, int[]> e : encodingsScores.entrySet()) {
        if (maxEntry == null || (e.getValue()[0] > maxEntry.getValue()[0])) {
            maxEntry = e;
        }
    }

    String winningEncoding = maxEntry.getKey();
    //dumpEncodingsScores(encodingsScores);
    return winningEncoding;
}

private static void updateEncodingsScores(Map<String, int[]> encodingsScores, String encoding) {
    String encodingName = encoding.toLowerCase();
    int[] encodingScore = encodingsScores.get(encodingName);

    if (encodingScore == null) {
        encodingsScores.put(encodingName, new int[] { 1 });
    } else {
        encodingScore[0]++;
    }
}    

private static void dumpEncodingsScores(Map<String, int[]> encodingsScores) {
    System.out.println(toString(encodingsScores));
}

private static String toString(Map<String, int[]> encodingsScores) {
    String GLUE = ", ";
    StringBuilder sb = new StringBuilder();

    for (Map.Entry<String, int[]> e : encodingsScores.entrySet()) {
        sb.append(e.getKey() + ":" + e.getValue()[0] + GLUE);
    }
    int len = sb.length();
    sb.delete(len - GLUE.length(), len);

    return "{ " + sb.toString() + " }";
}

Verbesserungen: DieguessEncoding Methode liest den Eingabestream vollständig. Bei großen Eingangsströmen kann dies ein Problem sein. Alle diese Bibliotheken würden den gesamten Eingabestream lesen. Dies würde einen großen Zeitaufwand für die Erkennung des Zeichensatzes bedeuten.

Es ist möglich, das anfängliche Laden von Daten auf einige Bytes zu beschränken und die Zeichensatzerkennung nur für diese wenigen Bytes durchzuführen.

Die obigen Bibliotheken sind einfache Stücklistendetektoren, die natürlich nur funktionieren, wenn sich am Anfang der Datei eine Stückliste befindet. Schauen Sie sich http://jchardet.sourceforge.net/ an, das den Text scannt

Soweit ich weiß, gibt es in diesem Zusammenhang keine allgemeine Bibliothek, die für alle Arten von Problemen geeignet wäre. Daher sollten Sie für jedes Problem die vorhandenen Bibliotheken testen und die beste auswählen, die den Einschränkungen Ihres Problems entspricht. Oft ist jedoch keine davon geeignet. In diesen Fällen können Sie Ihren eigenen Codierungsdetektor schreiben! Wie ich geschrieben habe ...

Ich habe ein Meta-Java-Tool zum Erkennen der Zeichensatzcodierung von HTML-Webseiten mit IBM ICU4j und Mozilla JCharDet als integrierten Komponenten geschrieben. Hier finden Sie mein Tool. Bitte lesen Sie vor allem den Abschnitt README. In meinem Artikel finden Sie auch einige grundlegende Konzepte für dieses Problem und in seinen Referenzen.

Unten habe ich einige hilfreiche Kommentare abgegeben, die ich in meiner Arbeit erlebt habe:

• Die Zeichensatzerkennung ist kein narrensicherer Prozess, da sie im Wesentlichen auf statistischen Daten basiert und tatsächlich davon ausgeht, dass keine Erkennung erfolgt
• icu4j ist in diesem Zusammenhang das Hauptwerkzeug von IBM, imho
• Sowohl TikaEncodingDetector als auch Lucene-ICU4j verwenden icu4j und ihre Genauigkeit hatte keinen signifikanten Unterschied zu dem icu4j in meinen Tests (höchstens% 1, wie ich mich erinnere).
• icu4j ist viel allgemeiner als jchardet, icu4j ist nur ein bisschen voreingenommen gegenüber Codierungen der IBM-Familie, während jchardet stark auf utf-8 voreingenommen ist
• Aufgrund der weit verbreiteten Verwendung von UTF-8 in der HTML-Welt; jchardet ist insgesamt eine bessere Wahl als icu4j, aber nicht die beste Wahl!
• icu4j eignet sich hervorragend für ostasiatische spezifische Codierungen wie EUC-KR, EUC-JP, SHIFT_JIS, BIG5 und die Codierungen der GB-Familie
• Sowohl icu4j als auch jchardet sind ein Debakel im Umgang mit HTML-Seiten mit Windows-1251- und Windows-1256-Codierungen. Windows-1251 alias cp1251 wird häufig für kyrillische Sprachen wie Russisch verwendet, und Windows-1256 alias cp1256 wird häufig für Arabisch verwendet
• Fast alle Codierungserkennungswerkzeuge verwenden statistische Methoden, sodass die Genauigkeit der Ausgabe stark von der Größe und dem Inhalt der Eingabe abhängt
• Einige Codierungen sind im Wesentlichen gleich, nur mit teilweisen Unterschieden. In einigen Fällen kann die erratene oder erkannte Codierung falsch sein, aber gleichzeitig wahr! Wie bei Windows-1252 und ISO-8859-1. (Siehe den letzten Absatz unter 5.2 in meinem Artikel.)

Ich habe eine nette Bibliothek von Drittanbietern gefunden, die die tatsächliche Codierung erkennen kann: http://glaforge.free.fr/wiki/index.php?wiki=GuessEncoding

Ich habe es nicht ausgiebig getestet, aber es scheint zu funktionieren.

Wenn Sie ICU4J verwenden ( http://icu-project.org/apiref/icu4j/ )

Hier ist mein Code:

String charset = "ISO-8859-1"; //Default chartset, put whatever you want

byte[] fileContent = null;
FileInputStream fin = null;

//create FileInputStream object
fin = new FileInputStream(file.getPath());

/*
 * Create byte array large enough to hold the content of the file.
 * Use File.length to determine size of the file in bytes.
 */
fileContent = new byte[(int) file.length()];

/*
 * To read content of the file in byte array, use
 * int read(byte[] byteArray) method of java FileInputStream class.
 *
 */
fin.read(fileContent);

byte[] data =  fileContent;

CharsetDetector detector = new CharsetDetector();
detector.setText(data);

CharsetMatch cm = detector.detect();

if (cm != null) {
    int confidence = cm.getConfidence();
    System.out.println("Encoding: " + cm.getName() + " - Confidence: " + confidence + "%");
    //Here you have the encode name and the confidence
    //In my case if the confidence is > 50 I return the encode, else I return the default value
    if (confidence > 50) {
        charset = cm.getName();
    }
}

Denken Sie daran, alles zu versuchen, was Sie brauchen.

Ich hoffe das funktioniert bei dir.

Wenn Sie die Kodierung Ihrer Daten nicht kennen, ist es nicht so einfach zu bestimmen, aber Sie könnten versuchen, eine Bibliothek zu verwenden, um sie zu erraten . Auch gibt es eine ähnliche Frage .

Für ISO8859_1-Dateien gibt es keine einfache Möglichkeit, sie von ASCII zu unterscheiden. Bei Unicode-Dateien kann man dies jedoch im Allgemeinen anhand der ersten paar Bytes der Datei erkennen.

UTF-8- und UTF-16-Dateien enthalten ganz am Anfang der Datei ein Byte Order Mark (BOM). Die Stückliste ist ein nicht unterbrechender Raum mit einer Breite von Null.

Leider erkennt Java dies aus historischen Gründen nicht automatisch. Programme wie Notepad überprüfen die Stückliste und verwenden die entsprechende Codierung. Mit Unix oder Cygwin können Sie die Stückliste mit dem Befehl file überprüfen. Beispielsweise:

$ file sample2.sql 
sample2.sql: Unicode text, UTF-16, big-endian

Für Java empfehle ich Ihnen, diesen Code zu überprüfen, der die gängigen Dateiformate erkennt und die richtige Codierung auswählt: So lesen Sie eine Datei und geben automatisch die richtige Codierung an

Eine Alternative zu TikaEncodingDetector ist die Verwendung von Tika AutoDetectReader .

Charset charset = new AutoDetectReader(new FileInputStream(file)).getCharset();

In einfachem Java:

final String[] encodings = { "US-ASCII", "ISO-8859-1", "UTF-8", "UTF-16BE", "UTF-16LE", "UTF-16" };

List<String> lines;

for (String encoding : encodings) {
    try {
        lines = Files.readAllLines(path, Charset.forName(encoding));
        for (String line : lines) {
            // do something...
        }
        break;
    } catch (IOException ioe) {
        System.out.println(encoding + " failed, trying next.");
    }
}

Bei diesem Ansatz werden die Codierungen einzeln ausprobiert, bis eine funktioniert oder wir keine mehr haben. (Übrigens enthält meine Codierungsliste nur diese Elemente, da es sich um die auf jeder Java-Plattform erforderlichen Zeichensatzimplementierungen handelt: https://docs.oracle.com/javase/9/docs/api/java/nio/charset/Charset.html )

Können Sie den entsprechenden Zeichensatz im Konstruktor auswählen :

new InputStreamReader(new FileInputStream(in), "ISO8859_1");