IO细述

Posted 2020-08-04 肥宅兜

Java IO1：IO和File

IO

大多数的应用程序都要与外部设备进行数据交换，最常见的外部设备包含磁盘和网络。IO就是指应用程序对这些设备的数据输入与输出，Java语言定义了许多类专门负责各种方式的输入、输出，这些类都被放在java.io包中。

 

File类

File类是IO包中唯一代表磁盘文件本身的对象，File类定义了一些与平台无关的方法来操作文件。通过调用File类提供的各种方法，能够完成创建、删除文件、重命名文件、判断文件的读写权限权限是否存在、设置和查询文件的最近修改时间等操作。

File类没有无参构造方法，最常用的是使用下面的构造方法来生成File对象（注意分隔符可以使用"/"和"\\"，但是使用"\\"必须写"\\\\"，因为涉及转义的问题）：

File(String pathName)

pathName指的是文件的路径名

 

File类中的方法

File定义了很多获取File对象标准属性的方法，写一段代码来看一下：

 1 public static void main(String[] args)
 2 {
 3     String fileName = "D:" + File.separator + "Files";
 4     File file = new File(fileName);
 5     
 6     if (file.exists() && file.isDirectory()) // 判断路径指向的文件/文件夹是否存在、是否目录
 7     {
 8         System.out.println("file是一个文件夹\\n");
 9             
10         File[] files = file.listFiles(); // 获取目录下的所有文件/文件夹（仅该层路径下）
11         System.out.print("路径下有文件：");
12         for (File f : files)
13         {
14             System.out.print(f + "\\t");
15         }
16         System.out.println();
17             
18         System.out.println("files[0]的文件名：" + files[0].getName()); // 获取文件名、文件夹名
19         System.out.println("files[0]的文件路径：" + files[0].getPath()); // 获取文件、文件夹路径
20         System.out.println("files[0]的绝对路径：" + files[0].getAbsolutePath()); // 获取文件、文件夹绝对路径
21         System.out.println("files[0]的父文件夹名：" + files[0].getParent()); // 获取文件父目录路径
22         System.out.println(files[0].exists() ? "files[0]的存在" : "files[0]的不存在"); // 判断文件、文件夹是否存在
23         System.out.println(files[0].canWrite() ? "files[0]的可写" : "files[0]的不可写"); // 判断文件是否可写
24         System.out.println(files[0].canRead() ? "files[0]的可读" : "files[0]的不可读"); // 判断文件是否可读
25         System.out.println(files[0].canExecute() ? "file[0]可执行" : "file[0]不可执行"); // 判断文件是否可执行
26         System.out.println(files[0].isDirectory() ? "files[0]的是目录" : "files[0]的不是目录"); // 判断文件、文件夹是不是目录
27         System.out.println(files[0].isFile() ? "files[0]的是文件" : "files[0]的不是文件"); // 判断拿文件、文件夹是不是标准文件
28         System.out.println(files[0].isAbsolute() ? "files[0]的路径名是绝对路径" : "files[0]的路径名不是绝对路径"); // 判断路径名是不是绝对路径
29         System.out.println("files[0]的最后修改时间：" + files[0].lastModified()); // 获取文件、文件夹上一次修改时间
30         System.out.println("files[0]的大小：" + files[0].length() + " Bytes"); // 获取文件的字节数，如果是一个文件夹则这个值为0
31         System.out.println("files[0]的路径转换为URI：" + files[0].toURI()); // 获取文件路径URI后的路径名
32             
33         if (files[0].exists())
34             files[0].delete(); // 删除指定的文件、文件夹
35         if (files[1].exists())
36             files[1].deleteOnExit(); // 当虚拟机终止时删除指定的文件、文件夹
37     }
38 }

运行结果为：

file是一个文件夹

路径下有文件：D:\\Files\\buffered.txt    D:\\Files\\example.txt    D:\\Files\\Inner    D:\\Files\\serializable.txt    D:\\Files\\stream.txt    D:\\Files\\test.txt    
files[0]的文件名：buffered.txt
files[0]的文件路径：D:\\Files\\buffered.txt
files[0]的绝对路径：D:\\Files\\buffered.txt
files[0]的父文件夹名：D:\\Files
files[0]的存在
files[0]的可写
files[0]的可读
file[0]可执行
files[0]的不是目录
files[0]的是文件
files[0]的路径名是绝对路径
files[0]的最后修改时间：1440313521120
files[0]的大小：21 Bytes
files[0]的路径转换为URI：file:/D:/Files/buffered.txt

示例代码应该是比较全面地演示了File的用法，其中有两点值得注意：

1、程序代码的第三行，写"D:/Files"和"D:\\\\Files"都是可以的，但像示例代码这么写应该是一种更好的做法，因为这么写使得代码的跨平台型、健壮性更好。"File.separator"会根据不同的操作系统取不同操作系统下的分隔符。其实File还有另一个分隔符pathSeparator，表示":"，不过因为Java主要用在Windows和Linux下，Linux下没有盘符的问题，所以一般直接打":"就好了

2、程序代码的第34、第36行，注意一下，删除的如果是一个文件夹的话，文件夹下还有文件/文件夹，是无法删除成功的

最后，再次重申，File是IO流的基础。

 

Java IO2：RandomAccessFile

 

RandomAccessFile

RandomAccessFile类可以说是Java语言中功能最为丰富的文件访问类，它提供了众多的文件访问方法。RandomAccessFile类支持"随机访问"方式，可以跳转到文件的任意位置处读写数据。要访问一个文件的时候，不想把文件从头读到尾，而是希望像访问一个数据库一样地访问一个文本文件，使用RandomAccessFile类是最佳选择。

RandomAccessFile对象类中有个位置指示器，指向当前读写处的位置，当读写n个字节后，文件指示器将指向这n个字节后的下一个字节处。刚打开文件时，文件指示器指向文件的开头处，可以移动文件指示器到新的位置，随后的读写将从新的位置开始。

RandomAccessFile类在文件随机（相对于顺序）读取时有很大的优势，但该类仅限于操作文件，不能访问其他得IO设备，如网络、内存映像等。

 

RandomAccessFile构造方法

RandomAccessFile类为用户提供了两种构造方法：

1、RandomAccessFile(File file, String mode)

2、RandomAccessFile(String name, String mode)

其实第二种构造方法也是new一个File出来再调用第一种构造方法，建议使用第一种构造方法，因为第一篇文章就说了File是IO的基础，有一个File不仅仅可以通过RandomAccessFile对文件进行操作，也可以通过File对象对文件进行操作。至于mode，Java给开发者提供了四种mode：

模    式	作    用
r	表示以只读方式打开，调用结果对象的任何write方法都将导致抛出IOException
rw	打开以便读取和写入，如果该文件尚不存在，则尝试创建该文件
rws	打开以便读取和写入，相对于"rw"，还要求对文件内容或元数据的每个更新都同步写入到底层存储设备
rwd	打开以便读取和写入，相对于"rw"，还要求对文件内容的每个更新都同步写入到底层存储设备

注意第二点"rw"模式，对rw模式的解释意味着Java并不强求指定的路径下一定存在某个文件，假如文件不存在，会自动创建

 

RandomAccessFile中的方法

RandomAccessFile中有如下一些常用方法：

方    法	作    用
void close()	重要，关闭此随机访问文件流并释放与该流关联的所有系统资源
FileChannel getChannel()	返回与此文件关联的唯一FileChannel对象，NIO用到
long getFilePointer()	返回此文件中的当前偏移量
long length()	返回此文件的长度
int read()	从此文件中读取一个数据字节
int read(byte[] b)	将最多b.length个数据字节从此文件读入byte数组，返回读入的总字节数，如果由于已经达到文件末尾而不再有数据，则返回-1。在至少一个输入字节可用前，此方法一直阻塞
int read(byte[] b, int off, int len)	将最多len个数据字节从此文件的指定初始偏移量off读入byte数组
boolean readBoolean()	从此文件读取一个boolean，其余readByte()、readChar()、readDouble()等类似
String readLine()	从此文件读取文本的下一行
void seek(long pos)	重要，设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作
int skipBytes(int n)	重要，尝试跳过输入的n个字节以丢弃跳过的字节，返回跳过的字节数
void write(byte[] b)	将b.length个字节从指定byte数组写入到此文件中
void write(byte[] b, int off, int len)	将len个字节从指定byte数组写入到此文件，并从偏移量off处开始
void write(int b)	向此文件写入指定的字节
void writeBoolean(boolean v)	按单字节值将boolean写入该文件，其余writeByte(int v)、writeBytes(String s)、writeChar(int v)等都类似

 

RandomAccessFile使用实例

先定义一个实体类：

public class Employee
{
    private String                name;
    private int                   age;
    private final static int      LEN = 8;
    
    public Employee()
    {
        
    }
    
    public Employee(String name, int age)
    {
        if (name.length() > LEN)
        {
            name = name.substring(0, 8);
        }
        else
        {
            while (name.length() < LEN)
            {
                name = name + "\\u0000";
            }
        }
        this.name = name;
        this.age = age;
    }
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
    
    public int getAge()
    {
        return age;
    }
    
    public void setAge(int age)
    {
        this.age = age;
    }
}

第一部分，写文件，该文件在路径下并没有，所以Java会自动帮我们创建：

Employee e1 = new Employee("zhangsan", 23);
Employee e2 = new Employee("lisi", 24);
Employee e3 = new Employee("wangwu", 25);
        
RandomAccessFile raf0 = new RandomAccessFile("D:/employee.txt", "rw");
raf0.writeBytes(e1.getName());
raf0.writeInt(e1.getAge());
raf0.writeBytes(e2.getName());
raf0.writeInt(e2.getAge());
raf0.writeBytes(e3.getName());
raf0.writeInt(e3.getAge());
raf0.close();

文件创建好了，D盘下也有该文件了，所以读取一下，这里使用了一些小技巧来演示seek方法和skipBytes方法：

RandomAccessFile raf1 = new RandomAccessFile("D:/employee.txt", "r");
int len = 8;
raf1.skipBytes(12); // 跳过第一个员工的信息，其姓名8字节，年龄4字节
System.out.println("第二个员工的信息：");
String str = "";
for (int i = 0; i < len; i++)
{
    str = str + (char)raf1.readByte();
}
System.out.println("name：" + str);
System.out.println("age：" + raf1.readInt());
System.out.println("第一个员工的信息：");
raf1.seek(0);
str = "";
for (int i = 0; i < len; i++)
{
    str = str + (char)raf1.readByte();
}
System.out.println("name：" + str);
System.out.println("age：" + raf1.readInt());
System.out.println("第三个员工的信息：");
raf1.skipBytes(12); // 跳过第二个员工的信息
str = "";
for (int i = 0; i < len; i++)
{
    str = str + (char)raf1.readByte();
}
System.out.println("name：" + str.trim());
System.out.println("age：" + raf1.readInt());
raf1.close();

看一下运行结果：

第二个员工的信息：
name：lisi
age：24
第一个员工信息：
name：zhangsan
age：23
第三个员工信息：
name：wangwu
age：25

可能有人奇怪，"zhangsan"加上一个int跳过12个字节可以理解，但是"lisi"、"wangwu"为什么加上int要跳过12个字节呢？明明"lisi"只有4个字节，"wangwu"只有6个字节啊。这个就涉及到一个"字节对齐"的问题了，有兴趣的可以了解一下。另外，再说一下，RandomAccessFile使用完一定要及时close()。

 

Java IO3：字节流

流类

Java的流式输入/输出是建立在四个抽象类的基础上的：InputStream、OutputStream、Reader、Writer。它们用来创建具体的流式子类。尽管程序通过具体子类执行输入/输出操作，但顶层类定义了所有流类的基本通用功能。

InputStream和OutputStream为字节流设计，Reader和Writer为字符流设计，字节流和字符流形成分离的层次结构。一般来说，处理字符或字符串使用字符流类，处理字节或二进制对象使用字节流。

操作文件流时，不管是字符流还是字节流，都可以按照以下方式进行：

1、使用File类找到一个对象

2、通过File类的对象去实例化字节流或字符流的子类

3、进行字节（字符）的读、写操作

4、关闭文件流

 

OutputStream（字节输出流）

OutputStream是定义了Java流式字节输入模式的抽象类。该类的所有方法返回一个void值并且在出错的情况下引发一个IOException，OutputStream提供的抽象方法有：

方    法	作    用
void close()	关闭输入流，关闭后的写操作会引发IOException
flush()	刷新此输入流并强制写出所有缓冲的输出字节
write(byte[] b)	向输入流写入单个字节，注意参数是一个int型，它允许设计者不必把参数转换成字节型就可以调用write()方法
write(byte[] b, int off, int len)	以b[off]为起点，向文件写入字节数组b中len个字节
write(int b)	向一个输出流写一个完整的字节数组

 

FileOutputStream（文件字节输出流）

FileOutpuStream应该是Java中最常见的字节输出流了，它创建一个可向文件写入字节的类OutputStream，它常用的构造方法如下：

1、FileOutputStream(String name)

2、FileOutputStream(File file)

3、FileOutputStream(File file, boolean append)

前两个构造方法类似，前者输入文件的绝对路径，后者输入File的实例对象，和RandomAccessFile一样，推荐后者。第三个构造方法有一点不同，append如果设置为true，文件则以搜索路径模式打开。FileOutputStream的创建不依赖于文件是否存在，在创建对象时，FileOutputSStream会在打开输出文件之前就创建它。这种情况下如果试图打开一个只读文件，会引发IOException。FileOutputStream，写一个例子，现在我的D盘路径下并没有"stream.txt"这个文件：

public static void main(String[] args) throws Exception
{
    File file = new File("D:/stream.txt");
    OutputStream out = new FileOutputStream(file);;
    byte b0[] = "abcdefghijklmnopqrstuvwxyz".getBytes(); //操作字节流，要转换成字节
    out.write(b0);
    out.close();
}

此时打开"stream.txt"：

看到D盘下多了"stream.txt"，且文件中的内容和我们写入的一致，同样这个例子也证明了FileOutputStream并不依赖指定路径下的文件是否存在。那如果指定路径下本来就有文件，那么写将会覆盖而不是追加，很好证明：

public static void main(String[] args) throws Exception
{
    File file = new File("D:/stream.txt");
    OutputStream out = new FileOutputStream(file);;
    byte b0[] = "abcdefghijklmnopqrstuvwxyz".getBytes(); //操作字节流，要转换成字节
    out.write(b0);
    out.close();
}

此时再打开"stream.txt"：

"stream.txt"中的内容变掉了，证明了结论。

 

InputStream（字节输入流）

InputStream是定义了Java流式字节输入模式的抽象类。该类所有方法在出错的时候都会引发一个IOException，InputStream提供的抽象方法有：

方    法	作    用
int available()	返回当前可读的字节数
void close()	关闭此输入流并释放与该流关联的所有系统资源，关闭之后再读取会产生IOException
int mark(int readlimit)	在输入流中放置一个标记，该流在读取N个Bytes字节前都保持有效
boolean markSupported()	如果调用的流支持mark()/reset()就返回true
int read()	如果下一个字节可读取则返回一个整形，遇到文件尾时返回-1
int read(byte b[])	试图读取buffer.length个字节到buffer中，并返回实际成功读取的字节数，遇到文件尾则返回-1
int read(byte b[], int off, int len)	将输入流中最多len个数组直接读入byte数组，off表示数组b中写入数据的初始偏移量。注意，三个read方法，在输入数据可用、检测到流末尾或者抛出异常前，此方法将一直阻塞
void reset()	重新设置输入指针到先前设置的标记处
long skip(long n)	跳过和丢弃此输入流中数据的n个字节

 

FileInputStream（文件字节输入流）

FileInputStream应该是Java中最常见的字节输入流了，它创建一个能从文件读取字节的InputStream类，它的两个常用构造方法如下：

1、FileInputStream(String name)

2、FileInputStream(File file)

和FileOutputStream差不多，推荐后者的用法。FileInputStream，同样写一个例子，操作的是上面D盘下生成的"stream.txt"：

public static void main(String[] args) throws Exception
{
    File file = new File("D:/stream.txt");
    InputStream in = new FileInputStream(file);
    byte b1[] = new byte[(int)file.length()];
    int i = 0;
    i = in.read(b1);
    System.out.println(i);
    System.out.println(new String(b1, 0, i));
}

运行结果为：

20
Hello World!!!

要区分清楚，OutputStream的作用是将内容由Java内存输出到文件中、InputStream是将内容由文件输入到Java内存中。read(byte b[])方法之前讲明了，表示"试图读取buffer.length个字节到buffer中，并返回实际读取的字节数"，返回的是实际字节的大小。不要误以为"Hello World!!!"是14个字符即28个字节，字节流底层是以byte为单位的，因此文件里面只有14个字节罢了，至于返回的是20，还是因为"字节对齐"的问题。

这里没有演示skip方法，因为比较简单，skip多少无非少读几个字节罢了，skip(3)，那么读出的就是"lo World!!!"，可以自己尝试一下。

 

 

Java IO4：字符编码

字符编码，这本不属于IO的内容，但字节流之后写的应该是字符流，既然是字符流，那就涉及一个"字符编码的"问题，考虑到字符编码不仅仅是在IO这块，Java中很多场景都涉及到这个概念，因此这边文章就专门详细写一下字符编码，具体的网上有很多，但本文目的是尽量讲清楚各种编码方式的作用，个人认为，不求、也没有必要对字符编码理解地多么深入。

 

字符集和字符编码

第一个概念就是字符集和字符编码之间的区别：

1、字符集（charset）

字符集指的是一个系统支持的所有抽象字符的集合。字符是各种文字和符号的总称，包括各国家文字、标点符号、图形符号、数字等，常见的字符集有ASCII字符集、GB2312字符集、BIG5字符集、GB18030字符集、Unicode字符集等。

2、字符编码（encoding）

计算机要准确处理各种字符集文字，就要进行字符编码，以便计算机能够识别和存储各种文字。因此字符编码就是讲符号转换为计算机可以接受的数字系统的数，称为数字代码。

 

ASCII码

计算机里面只有数字0和1（严格说连0和1都没有，只有开和关，无非是用0和1表示开关的状态罢了），在计算机软件里的一切都是用数字标识的额，屏幕上显示的一个一个字符也是数字。最初使用的计算机在美国，用到的字符很少，因此每一个字符都用一个数字表示，一个字节所能表示的数字反内卫足以容纳所有这些字符。实际上表示这些字符的数字的字节最高位都是0，也就是说这些数字都在0~127之间，如字符a对应97，字符b对应数字98，这种字符与数字的对应编码固定下来之后，这套编码规则被称为ASCII码（美国标准信息交换码）。一张简单的ASCII码表如图：

从表中可以看出ASCII码分为两部分：

1、0~31是控制字符，如换行、回车、删除等

2、32~126是打印字符，可以通过键盘输入并且能够显示出来

 

GB2312和GBK

随着计算机在其它国家的普及，许多国家把本地字符集引入了计算机，大大扩展了计算机中字符的范围。一个字节所能表示的范围不足以容纳中文字符（看看上面的ASCII码表就知道了），中国大陆将每一个中文字符都用两个字节表示，原有的ASCII码字符的编码保持不变。

为了将一个中文字符与两个ASCII码字符相区别，中文字符的每个字节最高位为1，中国大陆为每一个中文字符都指定了一个对应的数字，并于1980年制定了一套《信息技术 中文编码字符集》，这套规范就是GB2312。GB2312是双字节编码，总的编码范围是A1~F7，其实A1~A9是富豪区，总共包含682个符号；B0~F7是汉字区，总共包含6763个汉字。

GBK是在1995年制定的后续标准，全称为《汉字内码扩展规范》，是国家技术监督局为Windows 95所制定的新的汉字内码规范。GBK的出现是为了扩展GBK2312，并加入更多的汉字。GBK的编码范围是8140~FEFE（去掉XX7F），总共有23940个码位，能表示21003个汉字，它的编码是和GB2312兼容的，也就是说用GB2312编码的汉字可以用GBK来解码，并且不会有乱码问题。GBK还是现如今中文Windows操作系统的系统默认编码。

 

Unicode

在一个国家的本地化系统中出现的一个字符，通过电子邮件传送到另外一个国家的本地化系统中，看到的就不是那个原始字符了，而是另外那个国家的一个字符或乱码，因为计算机里面并没有真正的字符，字符都是以数字的形式存在的，通过邮件传送一个字符，实际上传送的是这个字符对应的字符编码，同一个数字在不同的国家和地区代表的很可能是不同的符号。

为了解决各个国家和地区之间各自使用不同的本地化字符编码带来的不便，人们将全世界所有的符号进行了统一编码，称之为Unicode（统一码、万国码）。所有字符不再区分国家和地区，都是人类共有的符号，如"中"字在Unicode中不再是GBK中的D6D0，而是在任何地方都是4e2d，如果所有的计算机系统都使用这种编码方式，那么4e2d这个字在任何地方都代表汉字中的"中"。Unicode编码的字符都占用两个字节的大小，也就是说全世界所有字符个数不会超过65536个。

当然Unicode只包含65536个字符就想包含全世界所有的字符是远远不够的，所以Unicode提供了字符平面映射，链接地址上就是Wiki百科对于字符平面映射的解读。另外要提一点的是，Unicode是Java和XML的基础。

 

UTF-8和UTF-16

Unicode是一种字符集标准，而具体该标准应该如何应用到计算机中，则是另一个话题了，常用的Unicode编码方式有两种：

1、UTF-16。两个字节表示Unicode转换格式，这是定长的表示方法。也就是说不管什么字符都可以使用两个字节表示，两个字节是16Bit，所以叫做UTF-16。UTF-16编码非常方便，每两个字节表示一个字符，这个在字符串操作时大大简化了操作。

2、UTF-8。UTF-16统一采用了两个字节表示一个字符，虽然在表示上非常简单，但是很大一部分字符用一个字节表示就够了，现在需要两个字节，存储空间放大了一倍。UTF-8就采取了一种变长技术，每个编码区域有不同的字码长度，不同类型的字符可以是由1~6个字节组成。

两种编码方式比较，相对来说，UTF-16的编码效率较高，从字符到字节的相互转换可以更简单，进行字符串操作也更好，它更适合在本地磁盘和内存之间使用，可以进行字符和字节之间的快速切换。但是UTF-16并不适合在网络之间传输，因为网络传输易损坏字节流，一旦字节流损坏将很难恢复，所以相比较而言UTF-8更适合网络传输。另外UTF-8对ASCII字符采用单字节存储，单个字符损坏也不会影响后面的其他字符，在编码效率上介于GBK和UTF-16之间，所以，UTF-8在编码效率和编码安全性上做了平衡，是理想的中文编码方式。

 

Java与字符编码

Java中的字符使用的都是Unicode字符集，编码方式为UTF-16，Java技术在通过Unicode保证跨平台特性的前提下也支持了全扩展的本地平台字符集，而显示输出和键盘输入都是采用的本地编码。因此，免不了二者的转化问题。

看一个很简单的例子：

public static void main(String[] args) throws Exception
{
    // 这里将字符串通过getBytes()方法，编码成GB2312
    byte b[] = "大家一起来学习Java语言".getBytes("GB2312");
    File file = new File("D:/Files/encoding.txt");
    OutputStream out = new FileOutputStream(file);
    out.write(b);
    out.close();
}

看一下文件中是什么：

正常输出，无编码问题，但是如果这样：

public static void main(String[] args) throws Exception
{
    // 这里将字符串通过getBytes()方法，编码成GB2312
    byte b[] = "大家一起来学习Java语言".getBytes("ISO8859-1");
    File file = new File("D:/Files/encoding.txt");
    OutputStream out = new FileOutputStream(file);
    out.write(b);
    out.close();
}

再看一下文件中是什么：

乱码问题就出现了，通过上述操作的完整过程分析一下原因。

要再次说明的是，Java中的String都是Unicode字符集的。Java中的各个类，对于英文字符的支持都非常好，可以正常地写入文件中，但对于中文字符就未必了。从Java源代码到输入文件正确的内容，要经过"Java源代码->Java字节码->虚拟机->文件"几个步骤，在上述过程中的每一步都必须正确地处理汉字的编码，才能够使最终有我们期望的结果。

"Java源代码->Java字节码"，标准的Java编译器Javac使用的字符集是系统默认的字符集，比如在中文Windows操作系统上就是GBK（上面GBK的部分已经说明过了），而在Linux操作系统上就是ISO8859-1，所以大家会发现Linux操作系统上编译的类中源文件中的中文字符都出现了问题，解决办法就是在编译的时候添加encoding参数，这样才能够与平台无关，用法是：javac -encoding GBK。

"Java字节码->虚拟机->文件"，Java运行环境（JRE）分英文版和国际版，但只有国际版才支持非英文字符。Java开发工具包（JDK）肯定支持多国字符，但并非所有的计算机用户都安装了JDK。很多操作系统应用软件为了能够更好地支持Java，都内嵌了JRE的国际版本，为支持自己多国字符提供了方便。

问题就出"Java源代码->Java字节码上"，这是由于JDK设置环境变量引起的。用程序看一下JDK环境变量：

public static void main(String[] args)
{
    System.getProperties().list(System.out);
}

看一下输出的全部信息，有点长：

 1 -- listing properties --
 2 java.runtime.name=Java(TM) SE Runtime Environment
 3 sun.boot.library.path=E:\\MyEclipse10\\Common\\binary\\com.sun....
 4 java.vm.version=11.3-b02
 5 java.vm.vendor=Sun Microsystems Inc.
 6 java.vendor.url=http://java.sun.com/
 7 path.separator=;
 8 java.vm.name=Java HotSpot(TM) 64-Bit Server VM
 9 file.encoding.pkg=sun.io
10 user.country=CN
11 sun.java.launcher=SUN_STANDARD
12 sun.os.patch.level=
13 java.vm.specification.name=Java Virtual Machine Specification
14 user.dir=F:\\代码\\MyEclipse\\TestIO
15 java.runtime.version=1.6.0_13-b03
16 java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
17 java.endorsed.dirs=E:\\MyEclipse10\\Common\\binary\\com.sun....
18 os.arch=amd64
19 java.io.tmpdir=C:\\Users\\dell1\\AppData\\Local\\Temp\\
20 line.separator=
21 
22 java.vm.specification.vendor=Sun Microsystems Inc.
23 user.variant=
24 os.name=Windows Vista
25 sun.jnu.encoding=GBK
26 java.library.path=E:\\MyEclipse10\\Common\\binary\\com.sun....
27 java.specification.name=Java Platform API Specification
28 java.class.version=50.0
29 sun.management.compiler=HotSpot 64-Bit Server Compiler
30 os.version=6.2
31 user.home=C:\\Users\\dell1
32 user.timezone=
33 java.awt.printerjob=sun.awt.windows.WPrinterJob
34 file.encoding=GBK
35 java.specification.version=1.6
36 user.name=dell1
37 java.class.path=F:\\代码\\MyEclipse\\TestIO\\bin
38 java.vm.specification.version=1.0
39 sun.arch.data.model=64
40 java.home=E:\\MyEclipse10\\Common\\binary\\com.sun....
41 java.specification.vendor=Sun Microsystems Inc.
42 user.language=zh
43 awt.toolkit=sun.awt.windows.WToolkit
44 java.vm.info=mixed mode
45 java.version=1.6.0_13
46 java.ext.dirs=E:\\MyEclipse10\\Common\\binary\\com.sun....
47 sun.boot.class.path=E:\\MyEclipse10\\Common\\binary\\com.sun....
48 java.vendor=Sun Microsystems Inc.
49 file.separator=\\
50 java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
51 sun.cpu.endian=little
52 sun.io.unicode.encoding=UnicodeLittle
53 sun.desktop=windows
54 sun.cpu.isalist=amd64

注意一下34行，表明了JDK使用的是GBK字符集（GBK是GB2312上的扩展，所以用GB2312字符集当然是没有问题的），这意味着Java对String的操作，都做了Unicode到GBK的转换。既然JDK用的GBK编码，那么用ISO8859-1字符集显示GBK编码出来的中文当然是有问题的。

这只是一个例子，在我们的应用程序中涉及I/O操作时，一般只要注意指定统一的编解码Charset集，就不会出现乱码问题。对有些应用程序如果不注意指定字符编码，则在中文环境中会使用操作系统的默认编码。如果编解码都在中文环境中，通常也没有问题，但还是强烈建议不要使用操作系统的默认编码，因为这样会使你的应用程序的编码格式和运行时环境绑定起来，这样在跨环境时很可能出现乱码问题。

 

Java IO5：字符流

字符流

字节流提供了处理任何类型输入/输出操作的功能（因为对于计算机而言，一切都是0和1，只需把数据以字节形式表示就够了），但它们不可以直接操作Unicode字符，因为上一篇文章写了，一个Unicode字符占用2个字节，而字节流一次只能操作一个字节。既然Java的口号就是"一次编写、处处运行"，那么包含直接的字符输入/输出的支持是必要的。因此就有一些字符输入/输出流，之前已经说明过了，字符流顶层是Reader和Writer这两个抽象类，因此就从这里开始本文。

 

Reader

Reader是定义Java的字符输入流的抽象类，该类的所有方法在出错的情况下都将引发IOException。Reader类中有这些方法：

方    法	作    用
abstract void close()	关闭该流并释放与之关联的所有资源
void mark(int readAheadLimit)	标记流中的当前位置
boolean markSupported()	判断此流是否支持mark()操作
int read()	从文件中读取单个字符
int read(char[] cbuf)	从文件中读取字符到cbuf
abstract int read(char[] cbuf, int off, int len)	将文件中的字符读入cbuf数组，从off位置开始，读取len个字符。三个read方法在字符可用、发生I/O异常或者已经到达流的末尾前，此方法会一直阻塞
int read(CharBuffer target)	试图将文件中的字符读入指定的字符缓冲区
boolean ready()	判断是否准备读取此流
voi reset()	重置该流
long skip(long n)	跳过n个字符

 

Writer

Writer是定义字符输出流的抽象类，所有该类的方法都返回一个void值并在出错的条件下引发IOException。Writer类中的方法有：

方    法	作    用
Writer append(char c)	将制定字符添加到此writer
Writer append(CharSequence csq)	将制定字符序列添加到此writer
Writer append(CharSequence csq, int start, int end)	将指定字符序列的子序列添加到此writer.Appendable
abstract void close()	关闭此流，但要先flush()它
abstract void flush()	刷新该流的缓冲
void write(char[] cbuf)	将cbuf中的内容写入文件
abstract void write(char[] cbuf, int off, int len)	将字符数组cbuf中从off开始的len个字节写入文件
void write(int c)	写入单个字符到文件中
void write(String str)	写入字符串到文件中
void write(String str, int off, int len)	写入str从off位置开始的len个字符到文件中

 

FileReader和FileWriter

FileReader类创建了一个可以读取文件内容的Reader类，最常用的构造方法是：

1、FileReader(String fileName)

2、FileReader(File file)

FileWriter创建了一个可以写文件的Writer类，最常用的构造方法是：

1、FileWriter(String fileName)

2、FileWriter(String fileName, boolean append)

3、FileWriter(File file)

其中第二个构造方法，如果append为true，那么输出是追加到文件结尾的。FileWriter类的创建不依赖文件是否存在，在创建文件之前，FileWriter将在创建对象时打开它来作为输出。如果试图打开一个只读文件，那么将引发一个IOException。看一下FileWriter和FileReader的使用，现在D盘目录下没有"writer.txt"：

public static void main(String[] args) throws Exception
{
    File file = new File("D:/writer.txt");
    Writer out = new FileWriter(file);
    // 声明一个String类型对象
    String str = "Hello World!!!";
    out.write(str);
    out.close();
        
    // 读文件操作
    Reader in = new FileReader(file);
    // 开辟一个空间用于接收文件读进来的数据
    char c0[] = new char[1024];
    int i = 0;
    // 将c0的引用传递到read()方法之中，同时此方法返回读入数据的个数
    i = in.read(c0);
    in.close();
        
    if (-1 == i)
    {
        System.out.println("文件中无数据");
    }
    else
    {
        System.out.println(new String(c0, 0, i));
    }
}

利用FileWriter和FileReader进行了一次的读写操作，先看一下D盘下是否有"writer.txt"，假如有"writer.txt"那"writer.txt"中又是什么：

看来利用FileWriter写入一个内存中的字符串到文件中是成功了，那么利用利用FileReader读入文件中的内容到内存呢，看一下运行结果：

Hello World!!!

打印结果和文件中的内容一致，说明FileReader的操作也成功。

这就是FileWriter和FileReader的使用，和FileOutputStream和FileInputStream的使用差不多，不过实际操作中一般不会用FileWriter和FileReader，这将在下一篇文章进行讲解。

 

Java IO6：字符流进阶及BufferedWriter、BufferedReader

字符流和字节流的区别

 1 public static void main(String[] args) throws Exception
 2 {
 3     File file = new File("D:/writer.txt");
 4     Writer out = new FileWriter(file);
 5     // 声明一个String类型对象
 6     String str = "Hello World!!!";
 7     out.write(str);
 8     out.close();
 9         
10     // 读文件操作
11     Reader in = new FileReader(file);
12     // 开辟一个空间用于接收文件读进来的数据
13     char c0[] = new char[1024];
14     int i = 0;
15     // 将c0的引用传递到read()方法之中，同时此方法返回读入数据的个数
16     i = in.read(c0);
17     in.close();
18         
19     if (-1 == i)
20     {
21         System.out.println("文件中无数据");
22     }
23     else
24     {
25         System.out.println(new String(c0, 0, i));
26     }
27 }

第8行"out.close()"注释掉可以看一下效果，"writer.txt"一定是空的，控制台上输出的是"文件中无数据"，说明一下原因。

字符流和字节流非常相似，但也有区别，从网上找了一张图：

、

从图上看，字符流和字节流最大的区别在于，字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流操作时使用了缓冲区，通过缓冲区再操作文件。这也解释了上面程序的那个问题，为什么不对资源进行close()就无法写入文件的原因。因为在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果没有关闭，缓冲区中的内容是无法输出的。

什么是缓冲区？简单理解，缓冲区就是一块特殊的内存区域。为什么要使用缓冲区？因为如果一个程序频繁操作一个资源（文件或数据库），则性能会很低，为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域读取数据即可，因为读取内存的速度要快于读取磁盘中文件内容的速度。

在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区。

如果不想在关闭时再输出字符流的内容也行，使用Writer的flush()方法就可以了。

 

字符流的原理

Java支持字符流和字节流，字符流本身就是一种特殊的字节流，之所以要专门有字符流，是因为Java中有大量对于字符的操作，所以专门有字符流。字节流和字符流的转换是以InputStreamReader和OutputStreamWriter为媒介的，InputStreamReader可以将一个字节流中的字节解码成字符，OutputStreamWriter可以将写入的字符编码成自节后写入一个字节流。

InputStreamReader中的解码字节，是由StreamDecoder完成的，StreamDecoder是Reader的实现类，定义在InputStreamReader的开头：

public class InputStreamReader extends Reader {

    private final StreamDecoder sd;

同样，OutputStreadWriter中的编码字节，是由StreamEncoder完成的，StreamEncoder是Writer的实现类，定义在OutputStreamWriter的开头：

public class OutputStreamWriter extends Writer {

    private final StreamEncoder se;

假如不对StreamDecoder和StreamEncoder指定Charset编码格式，将使用本地环境中的默认字符集，例如中文环境中将使用GBK编码。

InputStreamReader有两个主要的构造函数：

1、InputStreamReader(InputStream in)

2、InputStreamReader(InputStream in, String charsetName)

OutputStreamWriter也有两个主要的构造函数：

1、OutputStreamWriter(OutputStream out)

2、OutputStreamWriter(OutputStream out, String charsetName)

从构造函数就可以看出，字符流是利用字节流实现的。InputStreamReader和OutputStreamWriter的两个构造函数的区别在于，一个是使用的默认字符集，一个可以指定字符集名称。其实FileReader和FileWriter可以看一下源码，很简单，只有构造函数，里面都是分别根据传入的文件绝对路径或者传入的File实例，new出FileInputStream和FileOutputStream，在调用InputStreamReader和OutputStreamWriter的构造方法。这么做，帮助开发者省去了实例化FileInputStream和FileOutputStream的过程，让开发者可以直接以fileName或file作为构造函数的参数。

 

BufferedWriter、BufferedReader

为了达到最高的效率，避免频繁地进行字符与字节之间的相互转换，最好不要直接使用FileReader和FileWriter这两个类进行读写，而使用BufferedWriter包装OutputStreamWriter，使用BufferedReader包装InputStreamReader。同样，在D盘下没有"buffered"这个文件，代码示例为：

public static void main(String[] args) throws Exception
{
    File file = new File("D:/buffered.txt");
    Writer writer = new FileWriter(file);
    BufferedWriter bw = new BufferedWriter(writer);
    bw.write("1234\\n");
    bw.write("2345\\n");
    bw.write("3456\\n");
    bw.write("\\n");
    bw.write("4567\\n");
    bw.close();
    writer.close();
        
    if (file.exists() && file.getName().endsWith(".txt"))
    {
        Reader reader = new FileReader(file);
        BufferedReader br = new BufferedReader(reader);
        String str = null;
        while ((str = br.readLine())!= null)
        {
            System.out.println(str);
        }
        reader.close();
        br.close();
    }    
}

运行一下，首先D盘下多出了"buffered.txt"这个文件，文件中的内容为：

然后看一下控制台的输出结果：

1234
2345
3456

4567

没什么问题，输出了文件中的内容。注意两点：

1、利用BufferedWriter进行写操作，写入的内容会放在缓冲区内，直到遇到close()、flush()的时候才会将内容一次性写入文件。另外注意close()的顺序，一定要先关闭BufferedWriter，再关闭Writer，不可以倒过来，因为BufferedWriter的写操作是通过Writer的write方法写的，如果先关闭Writer的话，就无法将缓冲区内的数据写入文件了，会抛出异常

2、利用BufferedReader进行读操作，不可以用父类Reader指向它，因为readLine()这个方法是BufferedReader独有的，readLine()的作用是逐行读取文件中的内容

 

Java IO7：管道流、对象流

前言

前面的文章主要讲了文件字符输入流FileWriter、文件字符输出流FileReader、文件字节输出流FileOutputStream、文件字节输入流FileInputStream，这些都是常见的流类。当然除了这些流类之外，Java还提供了很多的流类给用户使用，本文就看一下别的流。

 

管道流

管道流主要用于连接两个线程的通信。管道流也分为字节流（PipedInputStream、PipedOutputStream）和字符流（PipedReader、PipedWriter）。比如一个PipedInputStream必须和一个PipedOutputStream对象进行连接而产生一个通信管道，PipedOutputStream向管道中写入数据，PipedInputStream从管道中读取数据。管道流的工作如下图所示：

下面看一下管道流的用法。既然管道流的作用是用于线程间的通信，那么势必有发送线程和接收线程，两个线程通过管道流交互数据。首先写一个发送数据的线程：

public class Sender implements Runnable
{
    private PipedOutputStream out = new PipedOutputStream();
    
    public PipedOutputStream getOutputStream()
    {
        return out;
    }
    
    public void run()
    {
        String str = "Receiver, 你好!";
        try
        {
            out.write(str.getBytes()); // 向管道流中写入数据（发送）
            out.close();
        } 
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }    
}

用流写数据的时候注意关注一下，该流是否支持直接写String，不可以的话要用String的getBytes()方法获取字符串的字节。既然有一个发送数据的线程了，接下来来一个接收数据的线程：

public class Receiver implements Runnable
{
    private PipedInputStream in = new PipedInputStream();
    
    public PipedInputStream getInputStream()
    {
        return in;
    }
    
    public void run()
    {
        String s = null;
        byte b0[] = new byte[1024];
        try
        {
            int length = in.read(b0);
            if (-1 != length)
            {
                s = new String(b0, 0 , length);
                System.out.println("收到了以下信息：" + s);
            }
            in.close();
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

两个线程都有了，写一个main线程，利用管道输出流的connect方法连接管道输出流和管道输入流：

public static void main(String[] args)
{
    try
    {
        Sender sender = new Sender();
        Receiver receiver = new Receiver();
        Thread senderThread = new Thread(sender);
        Thread receiverThread = new Thread(receiver);
        PipedOutputStream out = sender.getOutputStream(); // 写入
        PipedInputStream in = receiver.getInputStream(); // 读出
        out.connect(in);// 将输出发送到输入
        senderThread.start();
        receiverThread.start();
    } 
    catch (IOException e)
    {
        e.printStackTrace();
    } 
}

输出结果应该很明显了，大家都知道，接收线程接收到了来自发送线程通过管道流输出流发送的数据：

收到了以下信息：Receiver, 你好!

注意一下，PipedInputStream运用的是一个1024字节固定大小的循环缓冲区，写入PipedOutputStream的数据实际上保存到了对应的PipedInputStream的内部缓冲区。PipedInputStream执行读操作时，读取的数据实际上来自这个内部缓冲区。如果对应的PipedInputStream输入缓冲区已满，任何企图写入PipedOutputStream的线程都将被阻塞。而且这个写操作线程将一直阻塞，直至出现读取PipedInputStream的操作从缓冲区删除数据。

这意味着，向PipedOutputStream写入数据的线程不应该是负责从对应PipedInputStream读取数据的唯一线程（所以这里开了两个线程分别用于读写）。假定t线程试图一次对PipedOutputStream的write()方法的调用中向对应的PipedOutputStream写入2000字节的数据，在t线程阻塞之前，它最多能够写入1024字节的数据（PipedInputStream内部缓冲区的大小）。然而，一旦t被阻塞，读取PipedInputStream的操作就再也不能出现了，因为t是唯一读取PipedInputStream的线程，这样，t线程已经完全被阻塞。

 

对象流

序列化，在这篇文章中已经讲得比较清楚了，这一部分主要是再次简单过一下对象流的知识而已。

Java中提供了ObjectInputStream、ObjectOutputStream这两个类用于对象序列化操作，这两个类是用于存储和读取对象的输入输出流类，只要把对象中的所有成员变量都存储起来，就等于保存了这个对象，之后从保存的对象之中再将对象读取进来就可以继续使用此对象。ObjectInputStream、ObjectOutputStream可以帮助开发者完成保存和读取对象成员变量取值的过程，但要求读写或存储的对象必须实现了Serializable接口。

看一下例子，先来一个实现了Serializable接口的实体类Person：

public class Person implements Serializable
{
    /**
     * 序列化
     */
    private static final long serialVersionUID = 7827863437931135333L;
    
    private transient String     name;
    private int                    age;
    private final static String sex = "man";
    
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    public String toString()
    {
        return "姓名：" + this.name + "， 年龄：" + this.age + ", 性别：" + sex;
    }
}

调用ObjectOutputStream和ObjectInputStream写一个序列化和反序列化的方法，我现在D盘下没有"serializable.txt"：

public static void main(String[] args) throws Exception
{
    File file = new File("D:/serializable.txt");
    serializable(file);
    deserializable(file);
}
    
// 序列化对象方法
public static void serializable(File file) throws Exception
{
    OutputStream outputFile = new FileOutputStream(file);
    ObjectOutputStream oos = new ObjectOutputStream(outputFile);
    oos.writeObject(new Person("张三", 25));
    oos.close();
}
    
// 反序列化对象方法
public static void deserializable(File file) throws Exception
{
    InputStream inputFile = new FileInputStream(file);
    ObjectInputStream ois = new ObjectInputStream(inputFile);
    Person p = (Person)ois.readObject();
    System.out.println(p);
}

现在运行一下，D盘下多了一个"serializable.txt"，文件里面的内容是：

看到乱码，因为序列化之后本身就是按照一定的二进制格式组织的文件，这些二进制格式不能被文本文件所识别，所以乱码也是正常的。

当然，控制台上也是有输出的：

姓名：null， 年龄：25, 性别：man

这证明了被transient修饰的成员变量不会被序列化。

 

 

IO简单总结

 

字节流、字符流继承关系

前几篇文章讲解了字节流、字符流的使用，不过Java提供给用户的流类远不止此，限于篇幅原因，没办法一一讲解，而且也没有必要一一讲解，就像我在写博客的时候多次提到的，有问题的时候学会查JDK API即可。OK，虽然不一一讲解每种流，我自己简单画了几张UML图，说明一下字节输入流、字节输出流、字符输入流、字符输出流这四个流类的子类继承关系。

1、字节输入流

2、字节输出流

3、字符输入流

4、字符输出流

 

总结一下流类的使用

1、File是一些文件/文件夹操作的源头，File代表的就是文件/文件夹本身，因此无论如何，使用IO的第一步是建议开发者根据路径实例化出一个File

2、考虑使用字符流还是字节流。操作文本一般使用字符流，即Reader和Writer；操作字节文件使用字节流，即InputStream和OutputStream

3、选择使用输入流还是输出流。把内容从文件读入Java内存使用输入流，即Reader和InputStream；把内容从Java内存读到文件使用输出流，即Writer和OutputStream

4、使用字符流使用BufferedReader和BufferedWriter，它们的构造函数中的参数分别是Reader和Writer，因此既可以实例化出FileReader和FileWriter，也可以实例化出InputStreamReader和OutputStreamWriter，作为构造函数的参数传入BufferedReader和BufferedWriter

5、FileInputStream和FileOutputStream可以直接操作文件的读写，它们没有做缓存

6、ObjectOutputStream和ObjectInputStream，它们分别以OutputStream和InputStream作为构造函数的参数，因此可以实例化出FileOutputStream和FileInputStream并传入

另外，请知，IO是Java的23种设计模式中的装饰器模式的典型应用