Java 文件 I/O 流详细解读

File(String filePath)                   // 创建指定文件路径的 File 对象
File(String filePath, String fileName)  // 创建指定文件路径和指定文件名的 File 对象
File(File dirObj, String fileName)

File f1 = new File("/");
File f2 = new File("/", "a.txt");
File f3 = new File(f1, "a.txt");

File f1 = new File("e:" + File.separator + "test.txt");

if (f1.exists()) {
    f1.delete();
    System.out.println("文件删除成功");
} else {
    try {
        f1.createNewFile();
        System.out.println("文件创建成功");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

System.out.println(f1.getName()); // test.txt
System.out.println(f1.getPath()); // e:/test.txt
System.out.println(f1.getAbsolutePath()); // e:/test.txt
System.out.println(f1.getParent()); // e:/
System.out.println(f1.canRead()); // true
System.out.println(f1.canWrite()); // true
System.out.println(f1.isDirectory()); // false
System.out.println(f1.isFile()); // true
System.out.println(f1.isAbsolute()); // true
System.out.println(f1.lastModified()); // 1519556856932
System.out.println(f1.length() + "Byte"); // 0Byte

RandomAccessFile(File file, String mode)     // 创建一个随机访问文件流，文件属性由 File 参数指定
RandomAccessFile(String name, String mode)   // 创建一个随机访问文件流，文件名由 name 参数指定

import java.io.File;
import java.io.RandomAccessFile;

// 向文件中写入三个员工的信息，并读出
public class Test {
    public static void main(String[] args) throws Exception {
        Employee person1 = new Employee("zhangsan", 18);
        Employee person2 = new Employee("lisi", 20);

        File file = new File("C:/Users/bxm09/Desktop/test.txt");
        if (file.exists()) {
            file.delete();
        }

        RandomAccessFile f1 = new RandomAccessFile("C:/Users/bxm09/Desktop/test.txt", "rw");
        f1.write(person1.name.getBytes());
        f1.writeInt(person1.age);
        f1.write(person2.name.getBytes());
        f1.writeInt(person2.age);
        f1.close();

        RandomAccessFile f2 = new RandomAccessFile("C:/Users/bxm09/Desktop/test.txt", "r");
        System.out.println("第 2 个员工的信息：");
        f2.skipBytes(12); // 跳过指定字节
        String p1Name = "";
        for (int i = 0; i < 8; i++) {
            p1Name += (char) f2.readByte();
        }
        System.out.println("name：" + p1Name);
        System.out.println("age：" + f2.readInt());

        System.out.println("第 1 个员工的信息：");
        f2.seek(0); // 设置文件指针偏移量
        String p2Name = "";
        for (int i = 0; i < 8; i++) {
            p2Name += (char) f2.readByte();
        }
        System.out.println("name：" + p2Name);
        System.out.println("age：" + f2.readInt());
        f2.close();
    }
}

// 员工类
class Employee {
    String name; // 员工姓名
    int age; // 员工年龄
    final static int LENGTH = 8; // 规定 name 为 8 个字符，方便读取。8 个字符 = 8个汉字 = 8个数字 = 8个字母

    public Employee(String name, int age) {
        if (name.length() > LENGTH) {
            name = name.substring(0, LENGTH); // 超八位则截取
        } else {
            while (name.length() < LENGTH) {
                name += "/u0000"; // 不足八位用空格代替
            }
        }

        this.name = name;
        this.age = age;
    }
}

public abstract class InputStream implements Closeable { ... }
public abstract class OutputStream implements Closeable, Flushable { ... }
public abstract class Reader implements Readable, Closeable { ... }
public abstract class Writer implements Appendable, Closeable, Flushable { ... }

File file = new File("C:/Users/bxm09/Desktop/test.txt");

Writer out = new FileWriter(file);
out.write("hello world!");
out.close();

Reader in = new FileReader(file);
char[] accept = new char[1024]; // 此数组用于存放读取到的数据
int len = in.read(accept);
System.out.println(new String(accept, 0, len)); // 将字符数组转化为字符串
in.close();

File file = new File("C:/Users/bxm09/Desktop/test.txt");

// 写文件
OutputStream out = new FileOutputStream(file);
byte[] b = "hello world!".getBytes();
out.write(b);
out.close();

// 读文件
InputStream in = new FileInputStream(file);
byte[] accept = new byte[1024]; // 此数组用于存放读取到的数据
int len = in.read(accept);
System.out.println(new String(accept, 0, len)); // 将字节数组转化为字符串
in.close();

// 文件流初体验
// 使用 FileInputStream 向文件写入数据，然后使用 FileOutputStream 读取文件中的数据

File file = new File("hello.txt");

// 写文件
try {
    OutputStream out = new FileOutputStream(file);
    out.write("HELLO WORLD".getBytes());

    out.flush(); // 记得擦屁股
    out.close();
} catch (IOException e) {
    e.printStackTrace();
}

// 读文件
try {
    InputStream in = new FileInputStream(file);
    byte[] data = new byte[1024]; // 用于存储读取到的数据
    int len = in.read(data);
    System.out.println(new String(data, 0, len));

    in.close();
} catch (IOException e) {
    e.printStackTrace();
}

// 缓冲流初体验，性能对比，复制一首歌曲
public static void main(String[] args) throws IOException {
    InputStream in = new FileInputStream("爱我中华.mp3"); // 指定需要复制的文件路径
    OutputStream out = new FileOutputStream("爱我中华2.mp3"); // 指定文件复制后的输出路径

    // copyOfByte(in, out); // 耗时18599毫秒
    // copyOfByteArray(in, out); // 耗时40毫秒
    copyOfBuffer(in, out); // 耗时14毫秒
}

// 1. 使用字节读写
private static void copyOfByte(InputStream in, OutputStream out) throws IOException {
    long startTime = System.currentTimeMillis();

    int data = 0;
    while (data != -1) {
        data = in.read(); // read 方法返回 -1 表示要读的文件已经到了尽头
        out.write(data);
    }
    in.close();
    out.flush();
    out.close();

    long endTime = System.currentTimeMillis();
    System.out.println("耗时" + (endTime - startTime) + "毫秒");
}

// 2. 使用字节数组读写
private static void copyOfByteArray(InputStream in, OutputStream out) throws IOException {
    long startTime = System.currentTimeMillis();

    byte[] bytes = new byte[1024];
    int data = 0;
    while (data != -1) {
        data = in.read(bytes);
        out.write(bytes);
    }
    in.close();
    out.flush();
    out.close();

    long endTime = System.currentTimeMillis();
    System.out.println("耗时" + (endTime - startTime) + "毫秒");
}

// 3. 使用缓冲流来读写
private static void copyOfBuffer(InputStream in, OutputStream out) throws IOException {
    long startTime = System.currentTimeMillis();

    InputStream buffIn = new BufferedInputStream(in);
    OutputStream buffOut = new BufferedOutputStream(out);
    byte[] bytes = new byte[1024];
    int data;
    while ((data = buffIn.read(bytes)) != -1) {
        buffOut.write(bytes, 0, data);
    }
    in.close();
    out.flush();
    out.close();

    long endTime = System.currentTimeMillis();
    System.out.println("耗时" + (endTime - startTime) + "毫秒");
}

// 读取来自控制台的输入
BufferedReader buffIn = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter buffOut = new BufferedWriter(new OutputStreamWriter(System.out));

String readLine = buffIn.readLine(); // 读取键盘上输入的一整行字符

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

// 管道流
public class Test {
    public static void main(String[] args) throws Exception {
        Sender sender = new Sender();
        Receiver receiver = new Receiver();

        PipedOutputStream out = sender.getPipedOutputStream(); // 返回各自的管道流
        PipedInputStream in = receiver.getPipedInputStream();

        out.connect(in); // 管道连接

        new Thread(sender).start(); // 启动线程
        new Thread(receiver).start();
    }
}

// 消息发送方
class Sender implements Runnable {
    PipedOutputStream out = new PipedOutputStream();

    public PipedOutputStream getPipedOutputStream() {
        return out;
    }

    @Override
    public void run() {
        String str = "hello world!";

        try {
            out.write(str.getBytes());
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 消息接受方
class Receiver implements Runnable {
    PipedInputStream in = new PipedInputStream();

    public PipedInputStream getPipedInputStream() {
        return in;
    }

    @Override
    public void run() {
        byte[] accept = new byte[1024];

        try {
            int len = in.read(accept);
            System.out.println("Receiver：" + new String(accept, 0, len));
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 向屏幕输出信息
PrintWriter out = new PrintWriter(System.out);
out.println("hello");
out.close();

// 向文件输出信息
File f = new File("C:/Users/bxm09/Desktop/test.txt");
PrintWriter out = new PrintWriter(new FileWriter(f));
out.println("hello");
out.close();

System.out.printf("字符串：%s，小数：%.2f", "hello", 20.123); // 字符串：hello，小数：20.12

// 两个文件的合并为一个文件
File f1 = new File("e:/1.txt");
File f2 = new File("e:/2.txt");
File f3 = new File("e:/3.txt");

FileInputStream in1 = new FileInputStream(f1); // 文件输入流
FileInputStream in2 = new FileInputStream(f2); // 文件输入流

SequenceInputStream s = new SequenceInputStream(in1, in2); // 将两个输入流合并为一个输入流

FileOutputStream out = new FileOutputStream(f3); // 文件输出流

int len;
while ((len = s.read()) != -1) {
    out.write(len);
}

in1.close();
in2.close();
out.close();

public class Test {
    public static void main(String[] args) throws Exception {
        File file = new File("./test");
        serializ(file);
        deserializ(file);
    }

    // 对象序列化：存储
    private static void serializ(File file) throws Exception {
        OutputStream out = new FileOutputStream(file);
        ObjectOutputStream cout = new ObjectOutputStream(out);
        cout.writeObject(new Person("白小明")); // 写对象
        cout.close();
    }

    // 对象反序列化：读取
    private static void deserializ(File file) throws Exception {
        InputStream in = new FileInputStream(file);
        ObjectInputStream cin = new ObjectInputStream(in);
        Person p = (Person) cin.readObject(); // 读对象
        System.out.println(p.getName()); // null
        cin.close();
    }
}

@SuppressWarnings("serial")
class Person implements Serializable {
    private transient String name; // 该属性不想被序列化

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}