Java IO

文件传输基础——Java IO 流

1. 编码问题

GBK 编码中文占用 2 个字节，英文占用 1 个字节
UTF-8 编码中文占用 3 个字节，英文占用 1 个字节
java 是双字节编码，utf-16be 编码占用 2 个字节，英文占用 2 个字节

当字节序列是某种编码方式时，这时候想把字节序列编程字符串，也必须使用相同的编码方式，否则会出现乱码。

文本文件在计算机中存储的就是字节序列。可以是任意编码的字节序列。

如果我们在中文机器上直接创建文本文件，那么该文本文件只认识ANSI 编码。

联通、联 是一种巧合，他们正好符合了 UTF-8 编码的规则。

2. File 类使用

java.io.File 用于表示文件或者目录。File 类只能用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问。

2.1. 构造函数

File f = new File(String args0);
File f = new File(URI args0);
File f = new File(File args0, String args1);
File f = new File(String args0, String args1);

2.2. 基本 API

File f = new File("c:/demo");
System.out.println(f.exists());
if (!f.exists()) {
    f.mkdir();
    // 创建多级目录
    f.mkdirs();
    System.out.println("f created");
} else {
    f.delete();
    System.out.println("f deleted");
}
System.out.println(f.isDirectory());
System.out.println(f.isFile());
System.out.println(f.getPath());
System.out.println(f.getName());
System.out.println(f.getParent());

File f1 = new File("hello.txt");
if (!f1.exists()) {
    f1.createNewFile();
    System.out.println("f1 created");
} else {
    f1.delete();
    System.out.println("f1 deleted");
}
System.out.println(f1);
System.out.println(f1.getAbsolutePath());
System.out.println(f1.getPath());
System.out.println(f1.getName());
System.out.println(f1.getParent());
System.out.println(f1.getParentFile());

static void listDirectory(File dir) {
    if (!dir.exists()) {
        throw new IllegalArgumentException("目录" + dir + "不存在！");
    }
    if (!dir.isDirectory()) {
        throw new IllegalArgumentException(dir + "不是目录！");
    }
    String[] filenames = dir.list();
    if (filenames != null && filenames.length > 0) {
        for (String string : filenames) {
            System.out.println(string);
        }
    }
    File[] files = dir.listFiles();
    if (files != null && files.length > 0) {
        for (File file : files) {
            if (file.isDirectory()) {
                System.out.println(file.getAbsolutePath());
                listDirectory(file);
            } else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

3. RandomAccessFile 类使用

RandomAccessFile 类是 Java 提供的对文件内容的访问类。既可以读文件，也可以写文件。可以随机访问文件，可以访问文件的任意位置。

3.1. Java 文件模型

在硬盘上的文件是 Byte Byte Byte 存储的，是数据的集合。

3.2. 打开文件的两种模式

r
rw

3.3. 构造函数

RandomAccessFile raf = new RandomAccessFile(file, "rw");

3.4. 文件指针

打开文件后，文件指针 int pointer = 0;

3.5. 读/写方法

write()方法只能写一个字节（后 8 位）。也就是说，如果要写一个int，需要写 4 次，同时指针指向下一个位置，准备再次写入。

raf.write(int a);

read()只读一个字节。

int b = raf.read();

文件读写完成后一定要关闭。

raf.close();

4. 字节流的使用

4.1. 输入输出流

输入流
输出流

4.2. 输入输出单位

字节流
字符流

4.3. 两个抽象父类

InputStream：抽象了应用程序读取数据的方式
OutputStream：抽象了应用程序写出数据的方式

4.4. 文件读写结束

EOF
-1

4.5. 输入流的基本方法

// 读取一个字节，无符号填充到 int 的低 8 位，-1 是 EOF
int b = in.read();

// 读取数据直接填充到字节数组 buf
in.read(byte[] buf);

in.read(byte[] buf, int start, int size);

4.6. 输出流的基本方法

// 写出 1 个 byte 到流，b 的低 8 位
out.write(int b);

// 将字节数组 buf 写入到流
out.write(byte[] buf);

out.write(byte[] buf, int start, int size);

4.7. FileXXX 子类

FileInputStream：具体实现了在文件上读取数据
FileOutputStream：具体实现了向文件中写出 Byte 数据的方法

4.8. DataXXX 子类

DataInputStream：对流功能的扩展，可以更加方便地读取 int / long / 字符型等类型数据
DataOutputStream：对流功能的扩展，可以更加方便地写出 int / long / 字符型等类型数据

实际上就是包装，底层实现还是写字节的方式。

4.8.1. DataOutputStream

writeInt()
writeDouble()
writeUTF()
writeChar()
writeChars()

4.8.2. DataInputStream

readInt()
readDouble()
readUTF()
readChar()

4.9. BufferedXXX 子类

BufferedInputStream
BufferedOutputStream

这两个流类为 I/O 提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了 I/O 性能（主要是输入输出性能）。

5. 字符流的使用

5.1. 基本概念

编码问题
文本：char 是 16 为无符号整数，是字符的 Unicode 编码（双字节编码）
文件：Byte Byte Byte 的数据序列
文本文件：文本（char）按照某种编码方案（如 UTF-8、UTF-16be、GBK）序列化为 Byte 的存储结果

5.2. 字符流的抽象类

Reader：输入流
Writer：输出流

字符的处理，一次处理一个字节。字符的底层仍然是字节序列。

5.3. 字符流的基本实现

InputStreamReader：完成 Byte 流解析为 char 流，按照指定编码解析
OutputStreamWriter：提供 char 流到 Byte 流，按照指定编码处理

5.4. FileXXX 子类

FileReader
FileWriter

5.5. BufferedXXX 子类

BufferedReader：String line = br.readLine();
BufferedWriter：bw.write(line);
PrintWriter + Buffer

6. 对象序列化

6.1. 概念

对象序列化：将 Object 转换为 Byte 序列
对象反序列化：将 Byte 序列转换为 Object

6.2. 序列化流

ObjectOutputStream：writeObject()
ObjectInputStream：readObject()

6.3. 序列化接口

对象必须实现序列化接口，才能进行序列化，否则出现异常。

Serializable 接口没有任何方法，只是一个标准。

6.4. transient 关键字

transient 修饰后的元素，该元素不会进行 JVM 默认的序列化。但是也可以自己完成这个元素的序列化。

public class Student implements Serializable {
    private String stuNo;
    private transient String stuName;
    private transient int stuAge;

    // ...

    private void writeObject(ObjectOutputStream s)
            throws IOException {
        // 把 JVM 默认能序列化的元素进行序列化
        s.defaultWriteObject();
        // 自己完成其他元素的序列化
        s.writeObject(stuName);
        s.writeInt(stuAge);
    }

    private void readObject(ObjectInputStream s)
            throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        this.stuName = (String) s.readObject();
        this.stuAge = s.readInt();
    }
}

ArrayList 自定义元素的序列化，只让有效的元素进行序列化，调高序列化的效率。

6.5. 序列化中子父类构造函数问题

一个类实现了 Serializable 接口，那么其子类都可以进行序列化。

序列化时，递归调用父类的构造函数。

反序列化时，如果其父类没有实现 Serializable 接口，那么父类的构造函数会被调用，如果其父类实现了 Serializable 接口，那么我们将看不到父类构造函数调用过程。

happyflyer / java-io Goto Github PK

java-io's Introduction