Java を使用して CSV ファイルを読み込もうとしています。一部のファイルには、最初にバイト オーダー マークがある場合がありますが、すべてではありません。存在する場合、バイト順は最初の行の残りと一緒に読み取られるため、文字列の比較で問題が発生します。
存在するときにバイトオーダーマークをスキップする簡単な方法はありますか?
85194 次
11 に答える
120
編集：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
于 2009-12-02T20:20:41.683 に答える
103
Apache Commons IOライブラリには、BOMInputStreamを検出して破棄できる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 ビッグ + リトルエンディアンなど、さまざまな異なるバイトオーダー マークを区別することもできます。次に、検出された を使用して、ストリームをデコードするByteOrderMarkを選択できます。Charset(この機能のすべてが必要な場合は、おそらくこれを行うためのより合理的な方法があります。BalusC の回答の UnicodeReader でしょうか?)。一般に、一部のバイトがどのエンコーディングに含まれているかを検出する良い方法はありませんが、ストリームが BOM で始まる場合、明らかにこれが役立つ可能性があることに注意してください。
編集: UTF-16、UTF-32 などで BOM を検出する必要がある場合、コンストラクターは次のようになります。
new BOMInputStream(is, ByteOrderMark.UTF_8, ByteOrderMark.UTF_16BE,
ByteOrderMark.UTF_16LE, ByteOrderMark.UTF_32BE, ByteOrderMark.UTF_32LE)
@martin-charlesworth のコメントに賛成票を投じてください :)
于 2011-09-12T15:28:52.747 に答える
33
より簡単な解決策:
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 エンコーディングすべてで動作します。
于 2013-08-16T13:57:11.223 に答える
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();
}
}
于 2009-12-02T20:29:54.977 に答える
2
残念ながらありません。自分自身を特定してスキップする必要があります。このページでは、注意する必要があることについて詳しく説明します。詳細については、この SO の質問も参照してください。
于 2009-12-02T20:09:01.023 に答える
1
IMO 与えられた答えはどれも本当に満足のいくものではありません。BOM をスキップして、現在のプラットフォームのデフォルト エンコーディングでストリームの残りを読み取るだけでは、決定的に間違っています。注意: Unix/Linux と Windows のプラットフォームのデフォルトは異なります。前者は UTF-8、後者は ANSI です。このような解決策は、ストリームの残りの部分 (BOM の後) に 7 ビットの ASCII 文字しか含まれていない場合にのみ機能します (構成のようなファイルに近いほとんどのプログラマーでは、これは真実です)。しかし、ASCII 以外の文字があるとすぐに、このアプローチでは失敗します。
そのため、バイト配列/ストリームを文字列に (およびその逆に) 変換できるすべての Java クラス/メソッドには、使用するエンコーディングを示す 2 番目のパラメーター (Reader、Writer、Scanner、String.getBytes() など) があります。
世界には UTF-xx だけでなく、非常に多くの文字エンコーディングがあります。2021 年になっても、エンド ユーザー アプリケーション間でエンコーディングの問題が非常に多く、特にアプリケーションが異なるプラットフォーム (iOS、Windows、Unix) で実行されている場合はなおさらです。これらの問題はすべて、プログラマーが文字エンコーディングのしくみを学ぶのが面倒だったためにのみ存在します。
したがって、最初に使用するエンコーディングを評価し、次に見つかったエンコーディングを使用して文字列/ストリーム変換を実行することが絶対に必要です。それぞれの仕様を参照することが最初のステップです。また、ストリームを読んでいるときにどのエンコーディングに遭遇したか確信が持てない場合にのみ、自分で評価する必要があります。ただし、注意: このような評価は常に「最良の推測」にすぎません。すべての可能性をカバーできるアルゴリズムはありません。
この意味で、2021 年 2 月 6 日の Lee の回答 (およびコーディング例) は、BOM がない場合に UTF-8 にフォールバックすることを除いて、IMO が最良の回答です。
于 2021-12-04T12:54:30.650 に答える
1
私は同じ問題を抱えていましたが、大量のファイルを読み取っていなかったので、より簡単な解決策を実行しました。このページの助けを借りて問題のある文字を印刷したとき、文字のユニコード値を取得すると、それが\ufeff. コードを使用System.out.println( "\\u" + Integer.toHexString(str.charAt(0) | 0x10000).substring(1) );して、問題のあるユニコード値を出力しました。
問題のある Unicode 値を取得したら、ファイルの最初の行でそれを置き換えてから、読み取りを続けました。そのセクションのビジネス ロジック:
String str = reader.readLine().trim();
str = str.replace("\ufeff", "");
これで問題が解決しました。その後、問題なくファイルの処理を続けることができました。先頭または末尾の空白の場合に備えて追加しましたtrim()が、特定のニーズに基づいて、それを行うかどうかを決めることができます。
于 2018-01-17T19:23:35.907 に答える