使用FileReader采用的默认编码

filereader采用的默认编码

很久以前听教学视频，里面讲到java采用的默认编码是iso-8859-1，一直记着。

但是最近重新看io流的时候，惊讶地发现，在不指定字符编码的情况下，filereader居然可以读取内容为中文的文本文件。要知道iso-8859-1可是西欧字符集，怎么能包含中文呢？于是百度了一下关键词“ios-8859-1显示中文”，结果很多人都有这个疑惑。

代码如下：

package day170903; 
import java.io.*; 
public class testdecoder {
	public static void main(string[] args) {
		filereader fr = null;
		try {
			fr = new filereader("g:/io/hello.txt");
			int len = 0;
			while((len=fr.read())!=-1) {
				system.out.println((char)len);
			}
		} catch (filenotfoundexception e) {
			e.printstacktrace();
		} catch (ioexception e) {
			e.printstacktrace();
		} finally {
			try {
				if(fr!=null) {
					fr.close();
				}
			} catch (ioexception e) {
				e.printstacktrace();
			}
		}
	}
}

事情的真相是什么呢？

编码一般是在构造方法处指定的，于是查看一下filereader的构造方法。也是奇葩，以前没怎么注意过，filereader竟然没有可以指定字符编码的构造方法。而且仅仅是简单地从inputstreamreader继承，并没有重写或扩展任何方法。这可能是历史上最吝啬的子类，完全就是啃老族。

不过好在java的文档注释写得很给力，在filereader这个类的开头有下面一段文档注释（中文部分为我劣质的翻译）：

/**
 * convenience class for reading character files.  the constructors of this
 * class assume that the default character encoding and the default byte-buffer
 * size are appropriate.  to specify these values yourself, construct an
 * inputstreamreader on a fileinputstream.
 *
 *这是一个很方便的读取字符文件（文本文件）的类。
 *这个类的构造方法假设默认的字符编码和默认的缓存数组大小是合适的（满足需要的）。
 *假如你想自己指定字符编码和缓存数组的大小，
 *请使用基于fileinputstream的inputstreamreader类。
 * <p><code>filereader</code> is meant for reading streams of characters.
 * for reading streams of raw bytes, consider using a
 * <code>fileinputstream</code>.
 *
 *filereader是设计为用来读取字符流的。
 *想要读取原始的字节流的话，可以考虑使用fileinputstream
 * @see inputstreamreader
 * @see fileinputstream
 *
 * @author      mark reinhold
 * @since       jdk1.1
 */

所以，设计者已经在文档注释中讲明白了这么设计的原因。但是对于我们来说，现在比较重要的是这个所谓的默认的字符编码是什么。

这个时候我们来看一下我们使用的filereader中的那个构造方法的具体内容。

    public filereader(string filename) throws filenotfoundexception {
        super(new fileinputstream(filename));
    }

filereader继承自inputstreamreader，调用了inputstreamreader的接受inputstream类型的形参的构造方法，也就是下面这个。

    public inputstreamreader(inputstream in) {
        super(in);
        try {
            sd = streamdecoder.forinputstreamreader(in, this, (string)null); // ## check lock object
        } catch (unsupportedencodingexception e) {
            // the default encoding should always be available
            throw new error(e);
        }
    }

当然inputstreamreader的这个构造方法又调用了其父类reader的下面的构造方法。

    protected reader(object lock) {
        if (lock == null) {
            throw new nullpointerexception();
        }
        this.lock = lock;
    }

在这里，它只是把得到的inputstream对象赋值给成员变量lock（看lock这个成员变量的文档注释的话，大概知道它是用来保证同步的），并没有说到字符编码的事。

既然通过super(in)向上查找到父类reader的构造方法也没有发现默认字符编码的踪迹，那么这条道就到头了。接下来应该看的是super(in)下面的代码，也就是那个异常捕捉语句块。主体语句只有下面一行内容。

sd = streamdecoder.forinputstreamreader(in, this, (string)null);

仔细看filereader和其它io流的代码的话会发现，很多输入流的读取功能（read及其重载方法）都是通过这个streamdecoder完成的，这是后话。在eclipse里面直接查看这个

streamdecoder的源码是不行的，需要去openjdk上找。

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/sun/nio/cs/streamdecoder.java

上面异常捕捉语句块主体部分调用的是streamdecoder的forinputstreamreader方法，对应的代码如下：

public static streamdecoder forinputstreamreader(inputstream in,
                                                 object lock,
                                                 string charsetname)
    throws unsupportedencodingexception
{
    string csn = charsetname;
    if (csn == null)
        csn = charset.defaultcharset().name();
    try {
        if (charset.issupported(csn))
            return new streamdecoder(in, lock, charset.forname(csn));
    } catch (illegalcharsetnameexception x) { }
    throw new unsupportedencodingexception (csn);
}

其实调用的时候，传递的第三个参数是字符串形式的null，这个其实就是我们要找的默认字符编码。

我们要找的是默认字符编码，其它代码不必深究。第一行是说把接收到的第三个参数赋值给csn（局部变量：字符编码），当然了，这个是被inputstreamreader的带字符编码参数的构造方法调用的时候才有意义的。没有指定字符编码的构造方法调用streamdecoder的forinputstreamreader的时候传递是null。所以接下来的if语句判断就成立了，那么csn这个变量得到的就是charset.defaultcharset().name()，见名知意，即默认字符编码。

接下来就要看charset这个类的defaultcharset方法的返回值——charset对象的name()方法的返回值是什么了。说起来有点绕，其实就是找里面的默认字符编码。

public static charset defaultcharset() {
    if (defaultcharset == null) {
        synchronized (charset.class) {
            string csn = accesscontroller.doprivileged(
                new getpropertyaction("file.encoding"));
            charset cs = lookup(csn);
            if (cs != null)
                defaultcharset = cs;
            else
                defaultcharset = forname("utf-8");
        }
    }
    return defaultcharset;
}

这代码看起来很费劲，而且接着又要看其它代码。最终结果是这个所谓的默认字符编码，其实就是jvm启动时候的本地编码。

这个要查看的话，就在对应的项目上点击右键，选择properties选项，在弹出的属性窗口中，可以看到当前项目在jvm中运行时候的默认字符编码。对于咱们中国人来说，一般都是“gbk”，不过可以根据需要从下拉框选择。

这代码看起来很费劲，而且接着又要看其它代码。最终结果是这个所谓的默认字符编码，其实就是jvm启动时候的本地编码。

这个要查看的话，就在对应的项目上点击右键，选择properties选项，在弹出的属性窗口中，可以看到当前项目在jvm中运行时候的默认字符编码。对于咱们中国人来说，一般都是“gbk”，不过可以根据需要从下拉框选择。

所以开头那个疑问，完全是因为不知道默认的编码其实是gbk而产生的误解。反过来测试一下就好了，先用outputstreamwriter往文件中写入下面一句法语

est-ce possible que tu sois en train de penser à moi lorsque tu me manques?

我在想你的时候，你会不会也刚好正在想我？

写入的时候指定字符编码为iso-8859-1，然后用inputstreamreader读取，读取的时候不指定字符编码（即采用默认字符编码）。那么，假如不能正确还原这句话，就说明默认的字符编码并不是iso-8859-1。

package day170903; 
import java.io.*; 
public class testdefaultcharencoding {
	public static void main(string[] args) {
		inputstreamreader isr = null;
		outputstreamwriter osw = null;
		try {
			osw = new outputstreamwriter(new fileoutputstream("g:/io/iso-8859-1.txt"),"iso-8859-1");
			isr = new inputstreamreader(new fileinputstream("g:/io/iso-8859-1.txt"));
			char[] chars = "est-ce possible que tu sois en train de penser à moi lorsque tu me manques?".tochararray();
			osw.write(chars);
			osw.flush();
			int len = 0;
			while((len=isr.read())!=-1) {
				system.out.print((char)len);
			}
		} catch (unsupportedencodingexception | filenotfoundexception e) {
			e.printstacktrace();
		} catch (ioexception e) {
			e.printstacktrace();
		} finally {
			try {
				if(isr!=null) {
					isr.close();
				}
				if(osw!=null) {
					osw.close();
				}
			} catch (ioexception e) {
				e.printstacktrace();
			}
		}
	}
}

输出结果是：

est-ce possible que tu sois en train de penser ? moi lorsque tu me manques?

大部分都正确还原了，因为法语中大部分也是英文字母。但是那个法语特有的（相比于英语）à 读出来以后无法识别，变成了问号。

假如默认编码真的是iso-8859-1，那么读取是完全没有问题的。现在有问题，正好说明默认编码不是iso-8859-1。

基本上到这儿就完事了，但是还要说一句。虽然我们可以很方便地知道在不指定字符编码的情况下，jvm将会采用什么编码，但是还是建议采用字符类的时候加上字符编码，因为写清楚字符编码可以让别人明白你的原意，而且能避免代码转手后换了一个开发工具后可能出现的编码异常问题。

filereader的编码问题

有一个utf-8编码的文本文件，用filereader读取到一个字符串，然后转换字符集：str=new string(str.getbytes(),"utf-8");结果大部分中文显示正常，但最后仍有部分汉字显示为问号！

public static list<string> getlines( string filename )  
{  
    list<string> lines = new arraylist<string>();  
    try  
    {  
        bufferedreader br = new bufferedreader(new filereader(filename));  
        string line = null;  
        while( ( line = br.readline() ) != null )  
            lines.add(new string(line.getbytes("gbk"), "utf-8"));  
        br.close();  
    }  
    catch( filenotfoundexception e )  
    {  
    }  
    catch( ioexception e )  
    {  
    }  
    return lines;  
}  

文件读入时是按os的默认字符集即gbk解码的，我先用默认字符集gbk编码str.getbytes(“gbk”)，此时应该还原为文件中的字节序列了，然后再按utf-8解码，生成的字符串按理说应该就应该是正确的。

为什么结果中还是有部分乱码呢？

问题出在filereader读取文件的过程中，filereader继承了inputstreamreader，但并没有实现父类中带字符集参数的构造函数，所以filereader只能按系统默认的字符集来解码，然后在utf-8 -> gbk -> utf-8的过程中编码出现损失，造成结果不能还原最初的字符。

原因明确了，用inputstreamreader代替filereader，inputstreamreader isr=new inputstreamreader(new fileinputstream(filename),"utf-8");这样读取文件就会直接用utf-8解码，不用再做编码转换。

public static list<string> getlines( string filename )  
{  
    list<string> lines = new arraylist<string>();  
    try  
    {  
        bufferedreader br = new bufferedreader(new inputstreamreader(new fileinputstream(filename), "utf-8"));  
        string line = null;  
        while( ( line = br.readline() ) != null )  
            lines.add(line);  
        br.close();  
    }  
    catch( filenotfoundexception e )  
    {  
    }  
    catch( ioexception e )  
    {  
    }  
    return lines;  
}  

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。