[Java IO]整理

最新推荐文章于 2023-06-06 18:01:13 发布

hyc_2013

最新推荐文章于 2023-06-06 18:01:13 发布

阅读量579

点赞数

分类专栏： Java基础文章标签： io java 流

Java基础专栏收录该内容

22 篇文章 0 订阅

订阅专栏

感谢文章作者整理分享：原文地址

1. 基本

1.1 概述

Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
- 面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
IO常用类的继承关系图如下：

使用系统路径标识来组建路径

@Test
// 使用系统路径标识来组建路径
public void testFileAttr() throws IOException {
    System.out.println(File.separator);
    System.out.println(File.pathSeparator);
    // 这样组成的路径能实现在windows和linux中的通用性
    String fileName = "D:" + File.separator + "hello_testFileAttr.txt";
    File f = new File(fileName);
    f.createNewFile();
}

取得本地的默认编码

@Test
// 取得本地的默认编码
public void testGetLocalEncoding() {
    System.out.println("系统默认编码为：" + System.getProperty("file.encoding"));
}

创建文件夹

@Test
// File.mkdir() 创建文件夹
public void testCreateMkdir() {
    String fileName = "D:" + File.separator + "hello";
    File f = new File(fileName);
    f.mkdir();
}

创建文件

@Test
// 创建文件
public void testCreateFile() {
    File f = new File("D:\\hello_testCreateFile.txt");// 参数为待创建[文件路径+文件名]组成的字符串
    try {
        f.createNewFile();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

判断文件是否存在、删除文件

@Test
// File.exists()、File.delete() 判断文件是否存在、删除文件
public void testDelFile() {
    String fileName = "D:" + File.separator + "hello_testFileAttr.txt";
    File f = new File(fileName);
    if (f.exists()) {
        f.delete();
        System.out.println("文件已经删除");
    } else {
        System.out.println("文件不存在");
    }
}

列出全部文件


@Test
// File.list() 列出指定目录的全部文件（包括隐藏文件）
// File.listFiles() 列出指定目录下全部带完整路径的文件（包括隐藏文件）
public void testListAllFile() {
    String fileName = "D:" + File.separator;
    File f = new File(fileName);
    String[] str = f.list();// 返回的是Sring数组
    for (int i = 0; i < str.length; i++) {
        System.out.println(str[i]);
    }
    System.out.println("--------------");
    File[] files = f.listFiles();// 返回的是File[]
    for (int i = 0; i < files.length; i++) {
        System.out.println(files[i]);
    }
}

判断一个指定的路径是否为目录

@Test
// 使用isDirectory判断一个指定的路径是否为目录，如果目录不存在也是返回NO
public void testIsDirectory() {
    String fileName = "D:" + File.separator + "hello";
    File f = new File(fileName);
    if (f.isDirectory()) {
        System.out.println("YES");
    } else {
        System.out.println("NO");
    }
}

打印出所有文件的路径

// 打印出所有文件的路径
public void print(File f) {
    if (f != null) {
        if (f.isDirectory()) {// 如果f是目录
            File[] fileArray = f.listFiles();// 得到目录下的所有文件
            if (fileArray != null) {
                for (int i = 0; i < fileArray.length; i++) {
                    print(fileArray[i]);// 递归调用
                }
            }
        } else {// 如果f是文件，直接输出文件路径
            System.out.println(f);
        }
    }
}

列出指定目录的全部内容

@Test
public void testListAll() {
    String fileName = "D:" + File.separator;
    File f = new File(fileName);
    print(f);
}

2. 读取写入流、转换流

字节流，向文件中写入字符串，会覆盖原来的内容！

@Test
// 字节流，向文件中写入字符串，会覆盖原来的内容！【FileOutputStream->write()】
public void testWriteString() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    OutputStream out = new FileOutputStream(f);// ★参数文件
    String str = "你好";
    byte[] b = str.getBytes();
    out.write(b);
    out.close();
}

一个字节一个字节的写入字符串，会覆盖原来的内容！

@Test
// 第二种方式：一个字节一个字节的写入字符串，会覆盖原来的内容！
public void testWriteStringOneByOne() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    OutputStream out = new FileOutputStream(f);
    String str = "妹子，我喜欢你！";
    byte[] b = str.getBytes();
    for (int i = 0; i < b.length; i++) {
        out.write(b[i]);
    }
    out.close();
}

字节流:向文件中追加新内容：

@Test
// 字节流:向文件中追加新内容：
public void testAppendString() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    OutputStream out = new FileOutputStream(f, true);
    String str = "亲爱的，嫁给我吧！";// 可以用\r\n换行，如：String str="\r\n你好";
    byte[] b = str.getBytes();
    for (int i = 0; i < b.length; i++) {
        out.write(b[i]);
    }
    out.close();
}

使用RandomAccessFile写入文

@Test
// 使用RandomAccessFile写入文件，打开文件后会发现那是乱码。
public void testRandomAccessFile() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    RandomAccessFile demo = new RandomAccessFile(f, "rw");// 设置文件读写权限
    demo.writeBytes("Hewei I love you!");
    demo.writeInt(12);
    demo.writeBoolean(true);
    demo.writeChar('A');
    demo.writeFloat(1.21f);
    demo.writeDouble(12.123);
    demo.close();
}

字节流：读文件内容

@Test
// ★字节流：读文件内容【FileInputStream->read()】
public void testReadFileString() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    InputStream in = new FileInputStream(f);
    byte[] b = new byte[1024];
    in.read(b);
    in.close();
    System.out.println(new String(b));
}

字节流：读文件内容

@Test
// ★字节流：读文件内容，一个个的读以节省空间
public void testReadFileStringOneByOne() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    InputStream in = new FileInputStream(f);
    byte[] b = new byte[(int) f.length()];
    for (int i = 0; i < b.length; i++) {
        b[i] = (byte) in.read();
    }
    in.close();
    System.out.println(new String(b));
}

不知道文件有多大读取文件内容

@Test
// 在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下用下面这种方法
public void testReadFileStringBySureEnd() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    InputStream in = new FileInputStream(f);
    byte[] b = new byte[1024];
    int count = 0, temp = 0;
    while ((temp = in.read()) != (-1)) {// ★当独到文件末尾的时候会返回-1，用此判断是否独到文件的末尾。
        b[count++] = (byte) temp;
    }
    in.close();
    System.out.println(new String(b));
}

字符流：向文件中写入数据

@Test
//★★字符流：向文件中写入数据【FileWriter->write】
public void testWriteFileStringByCharStream() throws Exception {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    Writer out = new FileWriter(f);
    String str = "妹子，我又来了";// 把以前的内容覆盖了
    out.write(str);
    out.close();
}

字符流:从文件中读出内容

@Test
// ★★字符流:从文件中读出内容
public void testReadFileStringByCharStream() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    Reader read = new FileReader(f);
    read.close();
}

循环读取文件内容

@Test
// ★采用循环读取的方式，因为我们有时候不知道文件到底有多大
public void testReadFileStringBySureEndInCharStream() throws IOException {
    String fileName = "D:" + File.separator + "hello.txt";
    File f = new File(fileName);
    char[] ch = new char[100];
    Reader read = new FileReader(f);
    int temp = 0;
    int count = 0;
    while ((temp = read.read()) != (-1)) {
        ch[count++] = (char) temp;
    }
    read.close();
    System.out.println(new String(ch, 0, count));
}

文件内容拷贝

@Test
// ★★★将hello.txt中的内容拷贝被到world.txt中（覆盖原来有的内容），如果world.txt中不存在，则创建该文件，
public void testCopyFile() throws IOException {
    String file1 = "D:" + File.separator + "hello.txt";
    String file2 = "D:" + File.separator + "world.txt";
    InputStream input = new FileInputStream(file1);
    OutputStream output = new FileOutputStream(file2);
    if ((input != null) && (output != null)) {
        int temp = 0;
        while ((temp = input.read()) != (-1)) {
            output.write(temp);
        }
    }
    input.close();
    output.close();
}

流转换：字节输出流转化为字符输出流

@Test
// ★★将字节输出流转化为字符输出流
public void testByteOutStream2CharOutStream() throws Exception {
    String fileName = "d:" + File.separator + "hello.txt";
    File file = new File(fileName);
    Writer out = new OutputStreamWriter(new FileOutputStream(file));
    out.write("hello");
    out.close();
}

流转换：字节输入流变为字符输入流

@Test
// ★★将字节输入流变为字符输入流
public void testByteInStream2CharInStream() throws Exception {
    String fileName = "d:" + File.separator + "hello.txt";
    File file = new File(fileName);
    Reader read = new InputStreamReader(new FileInputStream(file));
    char[] b = new char[100];
    int len = read.read(b);
    System.out.println(new String(b, 0, len));
    read.close();

}

[内存操作流内]ByteArrayInputStream

@Test
// ★★[内存操作流内]ByteArrayInputStream：内存操作流内一般使用来生成一些临时信息，这样可以避免删除的麻烦
public void testByteArrayInputStream() throws IOException {
    String str = "ILOVEYOU";
    ByteArrayInputStream input = new ByteArrayInputStream(str.getBytes());
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    int temp = 0;
    while ((temp = input.read()) != -1) {
        char ch = (char) temp;
        output.write(Character.toLowerCase(ch));
    }
    String outStr = output.toString();
    input.close();
    output.close();
    System.out.println(outStr);
}

PipedOutputStream 管道输出流

@Test
// PipedOutputStream 管道输出流；PipedInputStream 管道输入流
public void testPipeStreamSend() {
    Send_PipedStreamTest send = new Send_PipedStreamTest();
    Recive_PipedStreamTest recive = new Recive_PipedStreamTest();
    try {// 管道连接
        send.getOut().connect(recive.getInput());
    } catch (Exception e) {
        e.printStackTrace();
    }
    new Thread(send).start();
    new Thread(recive).start();
}

打印流PrintStream进行输出

@Test
// 使用PrintStream进行输出
public void testPrintStreamOut() throws Exception {
    PrintStream print = new PrintStream(new FileOutputStream(new File("d:"
            + File.separator + "hello.txt")));
    print.println(true);// 输入到hello.txt文件中
    print.println("Rollen");
    print.close();
}

PrintStream进行格式化输出

@Test
// 使用PrintStream进行输出，并进行格式化
public void testFormatPrintOut() throws Exception {
    PrintStream print = new PrintStream(new FileOutputStream(new File("d:"
            + File.separator + "hello.txt")));
    String name = "Rollen";
    int age = 20;
    print.printf("姓名：%s. 年龄：%d.", name, age);
    print.close();
}

字符流的缓冲区：BufferedReader

@Test
// BufferedReader:只能接受字符流的缓冲区，为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流
// 采用：BufferedReader buf = new BufferedReader(new
// InputStreamReader(System.in));
// 使用缓冲区从键盘上读入内容
public void testBufferedReader() {
    BufferedReader buf = new BufferedReader(
            new InputStreamReader(System.in));
    String str = null;
    System.out.println("请输入内容:");
    try {
        str = buf.readLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
    System.out.println("你输入的内容是：" + str);
}

Scanner类：可以接受任何的输入流

@Test
// ★★Scanner类：从键盘读数据，可以接受任何的输入流。使用Scanner类从文件中读出内容
public void testScanner() {
    File file = new File("d:" + File.separator + "hello.txt");
    Scanner sca = null;
    try {
        sca = new Scanner(file);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    String str = sca.next();
    System.out.println("从文件中读取的内容是：" + str);
}

数据操作流DataOutputStream、DataInputStream类

@Test
public void testData() throws Exception {
    File file = new File("d:" + File.separator + "hello.txt");
    char[] ch = { 'A', 'B', 'C' };
    DataOutputStream out = null;
    out = new DataOutputStream(new FileOutputStream(file));
    for (char temp : ch) {
        out.writeChar(temp);
    }
    out.close();
}

3. 流合并、文件压缩与解压

合并流 SequenceInputStream

@Test
// 合并流 SequenceInputStream:将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt
// 下面结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。
public void testSequenceInputStream() throws Exception {
    File file1 = new File("d:" + File.separator + "hello1.txt");
    File file2 = new File("d:" + File.separator + "hello2.txt");
    File file3 = new File("d:" + File.separator + "hello.txt");
    InputStream input1 = new FileInputStream(file1);// 如果文件不存在，报系统找不到指定的文件
    InputStream input2 = new FileInputStream(file2);
    OutputStream output = new FileOutputStream(file3);
    // 合并流
    SequenceInputStream sis = new SequenceInputStream(input1, input2);
    int temp = 0;
    while ((temp = sis.read()) != -1) {
        output.write(temp);
    }
    input1.close();
    input2.close();
    output.close();
    sis.close();
}

文件压缩 ZipOutputStream

@Test
public void testZipStream() throws Exception {
    File file = new File("d:" + File.separator + "hello.txt");
    File zipFile = new File("d:" + File.separator + "hello.zip");
    InputStream input = new FileInputStream(file);
    ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
            zipFile));
    zipOut.putNextEntry(new ZipEntry(file.getName()));
    // 设置注释
    zipOut.setComment("hello");
    int temp = 0;
    while ((temp = input.read()) != -1) {
        zipOut.write(temp);
    }
    input.close();
    zipOut.close();
}

压缩多个文件

@Test

public void testZipMutilFile() throws Exception {
    // 要被压缩的文件夹
    File file = new File("d:" + File.separator + "temp");
    File zipFile = new File("d:" + File.separator + "zipFile.zip");// 压缩后的文件名
    InputStream input = null;
    ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
            zipFile));
    zipOut.setComment("hello");
    if (file.isDirectory()) {// 压缩temp问文件夹下的所有文件
        File[] files = file.listFiles();
        for (int i = 0; i < files.length; ++i) {
            input = new FileInputStream(files[i]);
            zipOut.putNextEntry(new ZipEntry(file.getName()
                    + File.separator + files[i].getName()));
            int temp = 0;
            while ((temp = input.read()) != -1) {
                zipOut.write(temp);
            }
            input.close();
        }
    }
    zipOut.close();
}

ZipFile类getName()

@Test
public void testUnderStandZipFile() throws Exception {
    File file = new File("d:" + File.separator + "zipFile.zip");
    ZipFile zipFile = new ZipFile(file);
    System.out.println("压缩文件的名称为：" + zipFile.getName());
}

解压缩文件：ZipEntry（压缩文件中只有一个文件的情况）

@Test
public void testZipFile() throws Exception {
    File file = new File("d:" + File.separator + "hello.zip");
    File outFile = new File("d:" + File.separator + "unZipFile.txt");
    ZipFile zipFile = new ZipFile(file);
    ZipEntry entry = zipFile.getEntry("hello.txt");
    InputStream input = zipFile.getInputStream(entry);
    OutputStream output = new FileOutputStream(outFile);
    int temp = 0;
    while ((temp = input.read()) != -1) {
        output.write(temp);
    }
    input.close();
    output.close();
}

解压缩多个文件

@Test
// 解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类
public void testUnZipMutilFile() throws Exception {
    File file = new File("d:" + File.separator + "zipFile.zip");
    File outFile = null;
    ZipFile zipFile = new ZipFile(file);
    ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));
    ZipEntry entry = null;
    InputStream input = null;
    OutputStream output = null;
    while ((entry = zipInput.getNextEntry()) != null) {
        System.out.println("解压缩" + entry.getName() + "文件");
        outFile = new File("d:" + File.separator + entry.getName());
        if (!outFile.getParentFile().exists()) {
            outFile.getParentFile().mkdir();
        }
        if (!outFile.exists()) {
            outFile.createNewFile();
        }
        input = zipFile.getInputStream(entry);
        output = new FileOutputStream(outFile);
        int temp = 0;
        while ((temp = input.read()) != -1) {
            output.write(temp);
        }
        input.close();
        output.close();
    }
}

4. 其它

PushBackInputStream回退流

@Test
public void testPushBackInputStream() throws IOException {
    String str = "hello,rollenholt";
    PushbackInputStream push = null;
    ByteArrayInputStream bat = null;
    bat = new ByteArrayInputStream(str.getBytes());
    push = new PushbackInputStream(bat);
    int temp = 0;
    while ((temp = push.read()) != -1) {
        if (temp == ',') {
            push.unread(temp);
            temp = push.read();
            System.out.print("(回退" + (char) temp + ") ");
        } else {
            System.out.print((char) temp);
        }
    }
}

ObjectInputStream

@Test
// 示范：查看hello.txt二进制文件里面的内容
public void testObjectInputStream() throws Exception {
    File file = new File("d:" + File.separator + "hello.txt");
    ObjectInputStream input = new ObjectInputStream(new FileInputStream(file));
    Object obj = input.readObject();
    input.close();
    System.out.println(obj);
}

序列化

@Test
//被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口
public void test() throws Exception {
    File file = new File("d:" + File.separator + "hello.txt");
    ObjectInputStream input = new ObjectInputStream(new FileInputStream(file));
    Object obj = input.readObject();
    input.close();
    System.out.println(obj);
}