Метка порядка байтов портит чтение файлов в Java

108

Я пытаюсь читать файлы CSV с помощью Java. Некоторые файлы могут иметь отметку порядка байтов в начале, но не все. Когда он присутствует, порядок байтов читается вместе с остальной частью первой строки, что вызывает проблемы со сравнением строк.

Есть ли простой способ пропустить отметку порядка байтов, когда она присутствует?

Том
источник

Ответы:

115

РЕДАКТИРОВАТЬ : я сделал правильный выпуск на GitHub: https://github.com/gpakosz/UnicodeBOMInputStream


Вот класс, который я написал некоторое время назад, я просто отредактировал имя пакета перед вставкой. Ничего особенного, это очень похоже на решения, опубликованные в базе данных ошибок SUN. Включите это в свой код, и все будет в порядке.

/* ____________________________________________________________________________
 * 
 * File:    UnicodeBOMInputStream.java
 * Author:  Gregory Pakosz.
 * Date:    02 - November - 2005    
 * ____________________________________________________________________________
 */
package com.stackoverflow.answer;

import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;

/**
 * The <code>UnicodeBOMInputStream</code> class wraps any
 * <code>InputStream</code> and detects the presence of any Unicode BOM
 * (Byte Order Mark) at its beginning, as defined by
 * <a href="http://www.faqs.org/rfcs/rfc3629.html">RFC 3629 - UTF-8, a transformation format of ISO 10646</a>
 * 
 * <p>The
 * <a href="http://www.unicode.org/unicode/faq/utf_bom.html">Unicode FAQ</a>
 * defines 5 types of BOMs:<ul>
 * <li><pre>00 00 FE FF  = UTF-32, big-endian</pre></li>
 * <li><pre>FF FE 00 00  = UTF-32, little-endian</pre></li>
 * <li><pre>FE FF        = UTF-16, big-endian</pre></li>
 * <li><pre>FF FE        = UTF-16, little-endian</pre></li>
 * <li><pre>EF BB BF     = UTF-8</pre></li>
 * </ul></p>
 * 
 * <p>Use the {@link #getBOM()} method to know whether a BOM has been detected
 * or not.
 * </p>
 * <p>Use the {@link #skipBOM()} method to remove the detected BOM from the
 * wrapped <code>InputStream</code> object.</p>
 */
public class UnicodeBOMInputStream extends InputStream
{
  /**
   * Type safe enumeration class that describes the different types of Unicode
   * BOMs.
   */
  public static final class BOM
  {
    /**
     * NONE.
     */
    public static final BOM NONE = new BOM(new byte[]{},"NONE");

    /**
     * UTF-8 BOM (EF BB BF).
     */
    public static final BOM UTF_8 = new BOM(new byte[]{(byte)0xEF,
                                                       (byte)0xBB,
                                                       (byte)0xBF},
                                            "UTF-8");

    /**
     * UTF-16, little-endian (FF FE).
     */
    public static final BOM UTF_16_LE = new BOM(new byte[]{ (byte)0xFF,
                                                            (byte)0xFE},
                                                "UTF-16 little-endian");

    /**
     * UTF-16, big-endian (FE FF).
     */
    public static final BOM UTF_16_BE = new BOM(new byte[]{ (byte)0xFE,
                                                            (byte)0xFF},
                                                "UTF-16 big-endian");

    /**
     * UTF-32, little-endian (FF FE 00 00).
     */
    public static final BOM UTF_32_LE = new BOM(new byte[]{ (byte)0xFF,
                                                            (byte)0xFE,
                                                            (byte)0x00,
                                                            (byte)0x00},
                                                "UTF-32 little-endian");

    /**
     * UTF-32, big-endian (00 00 FE FF).
     */
    public static final BOM UTF_32_BE = new BOM(new byte[]{ (byte)0x00,
                                                            (byte)0x00,
                                                            (byte)0xFE,
                                                            (byte)0xFF},
                                                "UTF-32 big-endian");

    /**
     * Returns a <code>String</code> representation of this <code>BOM</code>
     * value.
     */
    public final String toString()
    {
      return description;
    }

    /**
     * Returns the bytes corresponding to this <code>BOM</code> value.
     */
    public final byte[] getBytes()
    {
      final int     length = bytes.length;
      final byte[]  result = new byte[length];

      // Make a defensive copy
      System.arraycopy(bytes,0,result,0,length);

      return result;
    }

    private BOM(final byte bom[], final String description)
    {
      assert(bom != null)               : "invalid BOM: null is not allowed";
      assert(description != null)       : "invalid description: null is not allowed";
      assert(description.length() != 0) : "invalid description: empty string is not allowed";

      this.bytes          = bom;
      this.description  = description;
    }

            final byte    bytes[];
    private final String  description;

  } // BOM

  /**
   * Constructs a new <code>UnicodeBOMInputStream</code> that wraps the
   * specified <code>InputStream</code>.
   * 
   * @param inputStream an <code>InputStream</code>.
   * 
   * @throws NullPointerException when <code>inputStream</code> is
   * <code>null</code>.
   * @throws IOException on reading from the specified <code>InputStream</code>
   * when trying to detect the Unicode BOM.
   */
  public UnicodeBOMInputStream(final InputStream inputStream) throws  NullPointerException,
                                                                      IOException

  {
    if (inputStream == null)
      throw new NullPointerException("invalid input stream: null is not allowed");

    in = new PushbackInputStream(inputStream,4);

    final byte  bom[] = new byte[4];
    final int   read  = in.read(bom);

    switch(read)
    {
      case 4:
        if ((bom[0] == (byte)0xFF) &&
            (bom[1] == (byte)0xFE) &&
            (bom[2] == (byte)0x00) &&
            (bom[3] == (byte)0x00))
        {
          this.bom = BOM.UTF_32_LE;
          break;
        }
        else
        if ((bom[0] == (byte)0x00) &&
            (bom[1] == (byte)0x00) &&
            (bom[2] == (byte)0xFE) &&
            (bom[3] == (byte)0xFF))
        {
          this.bom = BOM.UTF_32_BE;
          break;
        }

      case 3:
        if ((bom[0] == (byte)0xEF) &&
            (bom[1] == (byte)0xBB) &&
            (bom[2] == (byte)0xBF))
        {
          this.bom = BOM.UTF_8;
          break;
        }

      case 2:
        if ((bom[0] == (byte)0xFF) &&
            (bom[1] == (byte)0xFE))
        {
          this.bom = BOM.UTF_16_LE;
          break;
        }
        else
        if ((bom[0] == (byte)0xFE) &&
            (bom[1] == (byte)0xFF))
        {
          this.bom = BOM.UTF_16_BE;
          break;
        }

      default:
        this.bom = BOM.NONE;
        break;
    }

    if (read > 0)
      in.unread(bom,0,read);
  }

  /**
   * Returns the <code>BOM</code> that was detected in the wrapped
   * <code>InputStream</code> object.
   * 
   * @return a <code>BOM</code> value.
   */
  public final BOM getBOM()
  {
    // BOM type is immutable.
    return bom;
  }

  /**
   * Skips the <code>BOM</code> that was found in the wrapped
   * <code>InputStream</code> object.
   * 
   * @return this <code>UnicodeBOMInputStream</code>.
   * 
   * @throws IOException when trying to skip the BOM from the wrapped
   * <code>InputStream</code> object.
   */
  public final synchronized UnicodeBOMInputStream skipBOM() throws IOException
  {
    if (!skipped)
    {
      in.skip(bom.bytes.length);
      skipped = true;
    }
    return this;
  }

  /**
   * {@inheritDoc}
   */
  public int read() throws IOException
  {
    return in.read();
  }

  /**
   * {@inheritDoc}
   */
  public int read(final byte b[]) throws  IOException,
                                          NullPointerException
  {
    return in.read(b,0,b.length);
  }

  /**
   * {@inheritDoc}
   */
  public int read(final byte b[],
                  final int off,
                  final int len) throws IOException,
                                        NullPointerException
  {
    return in.read(b,off,len);
  }

  /**
   * {@inheritDoc}
   */
  public long skip(final long n) throws IOException
  {
    return in.skip(n);
  }

  /**
   * {@inheritDoc}
   */
  public int available() throws IOException
  {
    return in.available();
  }

  /**
   * {@inheritDoc}
   */
  public void close() throws IOException
  {
    in.close();
  }

  /**
   * {@inheritDoc}
   */
  public synchronized void mark(final int readlimit)
  {
    in.mark(readlimit);
  }

  /**
   * {@inheritDoc}
   */
  public synchronized void reset() throws IOException
  {
    in.reset();
  }

  /**
   * {@inheritDoc}
   */
  public boolean markSupported() 
  {
    return in.markSupported();
  }

  private final PushbackInputStream in;
  private final BOM                 bom;
  private       boolean             skipped = false;

} // UnicodeBOMInputStream

И вы используете это так:

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public final class UnicodeBOMInputStreamUsage
{
  public static void main(final String[] args) throws Exception
  {
    FileInputStream fis = new FileInputStream("test/offending_bom.txt");
    UnicodeBOMInputStream ubis = new UnicodeBOMInputStream(fis);

    System.out.println("detected BOM: " + ubis.getBOM());

    System.out.print("Reading the content of the file without skipping the BOM: ");
    InputStreamReader isr = new InputStreamReader(ubis);
    BufferedReader br = new BufferedReader(isr);

    System.out.println(br.readLine());

    br.close();
    isr.close();
    ubis.close();
    fis.close();

    fis = new FileInputStream("test/offending_bom.txt");
    ubis = new UnicodeBOMInputStream(fis);
    isr = new InputStreamReader(ubis);
    br = new BufferedReader(isr);

    ubis.skipBOM();

    System.out.print("Reading the content of the file after skipping the BOM: ");
    System.out.println(br.readLine());

    br.close();
    isr.close();
    ubis.close();
    fis.close();
  }

} // UnicodeBOMInputStreamUsage
Грегори Пакош
источник
2
Извините за длинные области прокрутки, жаль, что нет функции прикрепления
Грегори Пакош
Спасибо, Грегори, это именно то, что я ищу.
Том
3
Это должно быть в ядре Java API
Денис Княжев,
7
Прошло 10 лет, а я до сих пор получаю за это карму: D Я смотрю на тебя Ява!
Грегори Пакош
1
Проголосовали за, потому что в ответе содержится история о том, почему входной поток файлов не предоставляет возможность отказаться от спецификации по умолчанию.
MxLDevs
96

В библиотеке ввода-вывода Apache Commons есть инструмент, InputStreamкоторый может обнаруживать и удалять спецификации: BOMInputStream(javadoc) :

BOMInputStream bomIn = new BOMInputStream(in);
int firstNonBOMByte = bomIn.read(); // Skips BOM
if (bomIn.hasBOM()) {
    // has a UTF-8 BOM
}

Если вам также необходимо обнаруживать разные кодировки, он также может различать различные метки порядка байтов, например, UTF-8 и UTF-16 big + little endian - подробности см. По ссылке на документ выше. Затем вы можете использовать обнаруженныйByteOrderMark чтобы выбрать Charsetдля декодирования потока. (Вероятно, есть более упрощенный способ сделать это, если вам нужна вся эта функциональность - может быть, UnicodeReader в ответе BalusC?). Обратите внимание, что, как правило, нет очень хорошего способа определить, в какой кодировке находятся некоторые байты, но если поток начинается с спецификации, очевидно, это может быть полезно.

редактировать : если вам нужно обнаружить спецификацию в UTF-16, UTF-32 и т.д., то конструктор должен быть:

new BOMInputStream(is, ByteOrderMark.UTF_8, ByteOrderMark.UTF_16BE,
        ByteOrderMark.UTF_16LE, ByteOrderMark.UTF_32BE, ByteOrderMark.UTF_32LE)

Проголосуйте за комментарий @ martin-charlesworth :)

rescdsk
источник
Просто пропускает спецификацию. Должен быть идеальным решением для 99% случаев использования.
atamanroman
7
Я успешно использовал этот ответ. Однако я бы с уважением добавил booleanаргумент, указывающий, следует ли включать или исключать спецификацию. Пример:BOMInputStream bomIn = new BOMInputStream(in, false); // don't include the BOM
Кевин Мередит
19
Я бы также добавил, что это обнаруживает только спецификацию UTF-8. Если вы хотите обнаружить все спецификации utf-X, вам необходимо передать их конструктору BOMInputStream. BOMInputStream bomIn = new BOMInputStream(is, ByteOrderMark.UTF_8, ByteOrderMark.UTF_16BE, ByteOrderMark.UTF_16LE, ByteOrderMark.UTF_32BE, ByteOrderMark.UTF_32LE);
Мартин Чарльзуорт
Что касается комментария @KevinMeredith, я хочу подчеркнуть , что конструктор с булевым понятнее, но конструктор по умолчанию уже избавился от UTF-8 BOM, как JavaDoc предлагает:BOMInputStream(InputStream delegate) Constructs a new BOM InputStream that excludes a ByteOrderMark.UTF_8 BOM.
WesternGun
Пропуск решает большинство моих проблем. Если мой файл начинается с спецификации UTF_16BE, могу ли я создать InputReader, пропустив спецификацию и прочитав файл как UTF_8? Пока работает, хочу понять, есть ли крайний случай? Заранее спасибо.
Бхаскар
32

Более простое решение:

public class BOMSkipper
{
    public static void skip(Reader reader) throws IOException
    {
        reader.mark(1);
        char[] possibleBOM = new char[1];
        reader.read(possibleBOM);

        if (possibleBOM[0] != '\ufeff')
        {
            reader.reset();
        }
    }
}

Пример использования:

BufferedReader input = new BufferedReader(new InputStreamReader(new FileInputStream(file), fileExpectedCharset));
BOMSkipper.skip(input);
//Now UTF prefix not present:
input.readLine();
...

Он работает со всеми 5 кодировками UTF!


источник
1
Очень милый Андрей. Но не могли бы вы объяснить, почему это работает? Как шаблон 0xFEFF успешно соответствует файлам UTF-8, которые, похоже, имеют другой шаблон и 3 байта вместо 2? И как этот шаблон может соответствовать обеим сторонам UTF16 и UTF32?
Вахид Пазиранде
1
Как видите, я использую не поток байтов, а поток символов, открытый с ожидаемой кодировкой. Поэтому, если первый символ из этого потока - BOM - я его пропускаю. Спецификация может иметь разное байтовое представление для каждой кодировки, но это один символ. Прочтите, пожалуйста, эту статью, она мне помогает: joelonsoftware.com/articles/Unicode.html
Хорошее решение, просто убедитесь, что файл не пуст, чтобы избежать исключения IOException в методе пропуска перед чтением. Вы можете сделать это, вызвав if (reader.ready ()) {reader.read (possibleBOM) ...}
Snow
Я вижу, вы охватили 0xFE 0xFF, который является меткой порядка байтов для UTF-16BE. Но что, если первые 3 байта - это 0xEF 0xBB 0xEF? (знак порядка байтов для UTF-8). Вы утверждаете, что это работает для всех форматов UTF-8. Что может быть правдой (я не тестировал ваш код), но как тогда это работает?
bvdb 07
1
См. Мой ответ Вахиду: я открываю не поток байтов, а поток символов и читаю из него один символ. Неважно, какая кодировка utf используется для файла - префикс bom может быть представлен разным количеством байтов, но с точки зрения символов это всего лишь один символ
25

В Google Data API есть приложение, UnicodeReaderкоторое автоматически определяет кодировку.

Вы можете использовать его вместо InputStreamReader. Вот немного сжатый отрывок из его источника, который довольно прост:

public class UnicodeReader extends Reader {
    private static final int BOM_SIZE = 4;
    private final InputStreamReader reader;

    /**
     * Construct UnicodeReader
     * @param in Input stream.
     * @param defaultEncoding Default encoding to be used if BOM is not found,
     * or <code>null</code> to use system default encoding.
     * @throws IOException If an I/O error occurs.
     */
    public UnicodeReader(InputStream in, String defaultEncoding) throws IOException {
        byte bom[] = new byte[BOM_SIZE];
        String encoding;
        int unread;
        PushbackInputStream pushbackStream = new PushbackInputStream(in, BOM_SIZE);
        int n = pushbackStream.read(bom, 0, bom.length);

        // Read ahead four bytes and check for BOM marks.
        if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
            encoding = "UTF-8";
            unread = n - 3;
        } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
            encoding = "UTF-16BE";
            unread = n - 2;
        } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
            encoding = "UTF-16LE";
            unread = n - 2;
        } else if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE) && (bom[3] == (byte) 0xFF)) {
            encoding = "UTF-32BE";
            unread = n - 4;
        } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00) && (bom[3] == (byte) 0x00)) {
            encoding = "UTF-32LE";
            unread = n - 4;
        } else {
            encoding = defaultEncoding;
            unread = n;
        }

        // Unread bytes if necessary and skip BOM marks.
        if (unread > 0) {
            pushbackStream.unread(bom, (n - unread), unread);
        } else if (unread < -1) {
            pushbackStream.unread(bom, 0, 0);
        }

        // Use given encoding.
        if (encoding == null) {
            reader = new InputStreamReader(pushbackStream);
        } else {
            reader = new InputStreamReader(pushbackStream, encoding);
        }
    }

    public String getEncoding() {
        return reader.getEncoding();
    }

    public int read(char[] cbuf, int off, int len) throws IOException {
        return reader.read(cbuf, off, len);
    }

    public void close() throws IOException {
        reader.close();
    }
}
BalusC
источник
Кажется, в ссылке говорится, что Google Data API устарел? Где теперь искать Google Data API?
SOUser 07
1
@XichenLi: API GData устарел по назначению. Я не собирался предлагать напрямую использовать GData API (OP не использует какую-либо службу GData), но я намерен взять исходный код в качестве примера для вашей собственной реализации. Вот почему я включил его в свой ответ, готовый к копировальной пасте.
BalusC 07
В этом есть ошибка. Случай UTF-32LE недоступен. Для того, (bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00) && (bom[3] == (byte) 0x00)чтобы быть правдой, тогда UTF-16LE case ( (bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) уже соответствовал бы.
Джошуа Тейлор
Поскольку этот код взят из API данных Google, я опубликовал об этом выпуск 471 .
Джошуа Тейлор
13

В Apache Commons IOбиблиотеках BOMInputStream уже упомянута @rescdsk, но я не видел его уже , как получить InputStream без спецификации.

Вот как я это сделал в Scala.

 import java.io._
 val file = new File(path_to_xml_file_with_BOM)
 val fileInpStream = new FileInputStream(file)   
 val bomIn = new BOMInputStream(fileInpStream, 
         false); // false means don't include BOM
Кевин Мередит
источник
Single конструктор агд делает это: public BOMInputStream(InputStream delegate) { this(delegate, false, ByteOrderMark.UTF_8); }. По UTF-8 BOMумолчанию исключает .
Владимир Вагайцев
Хорошее замечание, Владимир. Я вижу это в документации - commons.apache.org/proper/commons-io/javadocs/api-2.2/org/… :Constructs a new BOM InputStream that excludes a ByteOrderMark.UTF_8 BOM.
Кевин Мередит
4

Чтобы просто удалить символы спецификации из вашего файла, я рекомендую использовать Apache Common IO

public BOMInputStream(InputStream delegate,
              boolean include)
Constructs a new BOM InputStream that detects a a ByteOrderMark.UTF_8 and optionally includes it.
Parameters:
delegate - the InputStream to delegate to
include - true to include the UTF-8 BOM or false to exclude it

Установите для include значение false, и ваши символы спецификации будут исключены.

Андреас Баасерад
источник
2

К сожалению, нет. Вам придется идентифицировать себя и пропустить. На этой странице подробно описано, на что вам следует обратить внимание. Также см. Этот вопрос SO для более подробной информации.

Брайан Агнью
источник
1

У меня была та же проблема, и, поскольку я не читал кучу файлов, я нашел более простое решение. Я думаю, что моя кодировка была UTF-8, потому что, когда я распечатал оскорбительный символ с помощью этой страницы: Получить значение Unicode символа, я обнаружил, что это так \ufeff. Я использовал код, System.out.println( "\\u" + Integer.toHexString(str.charAt(0) | 0x10000).substring(1) );чтобы распечатать оскорбительное значение Unicode.

Как только у меня появилось оскорбительное значение Unicode, я заменил его в первой строке моего файла, прежде чем продолжить чтение. Бизнес-логика этого раздела:

String str = reader.readLine().trim();
str = str.replace("\ufeff", "");

Это устранило мою проблему. Затем я смог продолжить обработку файла без проблем. Я добавил, trim()что в случае начального или конечного пробела, вы можете сделать это или нет, в зависимости от ваших конкретных потребностей.

Эми Б. Хиггинс
источник
1
У меня это не сработало, но я использовал .replaceFirst ("\ u00EF \ u00BB \ u00BF", ""), который сработал.
StackUMan