JavaSE_19_IO流（一）

《IO流（一）》

目录

• 文件操作（熟练）

• IO流体系（掌握）

• 字节流（熟练）

• 字符流（熟练）

一、文件操作

File类（通过File对象实现对文件或者文件夹的操作）

• 常用构造

File file = new File(String pathname);

//绝对路径：带盘符的路径
File file1 = new File("D:\\dir\\a.txt");

//相对路径：相对当前项目路径
File file2 = new File("./src/a.txt");

• 常用变量

File.separator						//目录分隔符（/）

• 常用方法

String getName()					//获取当前文件对象的名字

long length()						//获取文件对象的大小 单位：字节

boolean isFile()/isDirectory()		//判断是否文件/文件夹

boolean canRead()/canWrite()		//判断文件可读/可写

boolean isHidden()					//判断是否隐藏文件

long lastModified()					//获取文件最后修改时间

boolean exists()					//判断文件是否存在

void createNewFile()				//创建新文件

void mkdir()/mkdirs()				//创建新文件夹

boolean delete()					//删除文件或者文件夹

File[] listFiles()					//获取当前文件夹下所有的子项，如果当前文件下为空则返回null值

案例一

• 文件目录创建

package com.hpr.test;

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        //相对路径
        File rootDir = new File("./rootDir");

        //创建一级目录
        if (!rootDir.exists()) {
            rootDir.mkdir();
        }

        //创建多级目录
        File manyDir = new File("./rootDir/aaa/bbb/ccc");
        if (!manyDir.exists()) {
            manyDir.mkdirs();
        }

        //创建文件
        File f1 = new File("./rootDir/aaa/aaa.txt");
        File f2 = new File("./rootDir/aaa/bbb/bbb.mp3");
        File f3 = new File("./rootDir/aaa/bbb/ccc/ccc.mp4");
        try {
            if (!f1.exists()) {
                f1.createNewFile();
            }
            if (!f2.exists()) {
                f2.createNewFile();
            }
            if (!f3.exists()) {
                f3.createNewFile();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

执行结果

• 文件遍历

...
public class Test {
    //递归遍历
    private static void recursionDir(File rootDir) {
        System.out.println("开始遍历文件夹：" + rootDir.getPath() + "-----------------");
        File[] files = rootDir.listFiles();
        if (files != null) {
            for (File file : files) {
                System.out.println(file.getPath());
                if (file.isDirectory()) {
                    recursionDir(file);
                }
            }
        }
    }

    public static void main(String[] args) {
    	File rootDir = new File("./rootDir");
        ...
        //遍历文件夹
        recursionDir(rootDir);
    }
}

执行结果

二、IO流体系

输入流与输出流

字节流与字符流

• 字节流：以字节（byte）为单位，多用于二进制文件操作；
• 字符流：以字符（char）为单位，多用于文本类文件操作。

三、字节流

核心方法

输入流（InputStream）：

• int read()：每次读取一个字节并返回该字节，读到末尾返回-1；

• int read(byte[] b)：每次固定长度字节，并将读取到的数据保存到数组b中，返回读取到的字节数；

• int read(byte[] b, int off, int len)：b-存储数据的字节数组，off-下标偏移量，len-读取最大数，返回读取到的字节数。

输出流（OutputStream）：

• write(int b)：写入单个字节；
• write(byte[] b)：写入字节数组；
• write(byte[] b, int off, int len)：b-要写入的字节数组，off-下标偏移量，len-写入个数。

写入测试

//1.根目录创建
File rootDir = new File("./rootDir");
if (!rootDir.exists()) {
    rootDir.mkdir();
}
OutputStream os;
//2.写入内容
try {
    //FileOutputStream(文件路径，是否追加形式)
    os = new FileOutputStream("./rootDir/a.txt", false);
    String str = "aaabbbccc,dddeeefff；\r\n欲穷千里目，更上一层楼。";
    os.write(str.getBytes());
    //强制写出缓冲区数据
    os.flush();
    //关闭流
    os.close();
} catch (IOException e) {
    e.printStackTrace();
}
System.out.println("程序执行结束！");

执行结果

读取测试

InputStream is;
try {
    is = new FileInputStream("./rootDir/a.txt");
    //每次读取1个字节
    int x = is.read();
    while (x > 0) {
        System.out.print((char) x);
        x = is.read();
    }
    //关闭流
    is.close();
} catch (IOException e) {
    e.printStackTrace();
}

执行结果

四、字符流

核心方法

输入流（Reader）：

• int read()：每次读取一个字符并返回该字符，读到末尾返回-1；

• int read(char[] cbuf)：每次读取固定长度字符，并将读取到的数据保存到数组cbuf中，返回读取到的字符数；

• int read(char[] cbuf, int off, int len)：cbuf-存储数据的字符数组，off-下标偏移量，len-读取最大数，返回读取到的字符数。

输出流（Writer）：

• write(int c)：写入单个字节；
• write(char[] cbuf)：写入字节数组；
• write(char[] cbuf, int off, int len)：b-要写入的字节数组，off-下标偏移量，len-写入个数；
• write(String str)：写入字符串；
• write(String str, int off, int len)：str-要写入的字符串，off-下标便宜量，len-写入长度。

写入测试

Writer w;
try {
    w = new FileWriter("./rootDir/c.txt", false);
    w.write("离离原上草，一岁一枯荣；\r\n野火烧不尽，春风吹又生。");
    //强制写出缓冲区数据
    w.flush();
    //关闭流
    w.close();
} catch (IOException e) {
    e.printStackTrace();
}
System.out.println("程序运行结束！");

执行结果

读取测试

Reader r;
try {
    r = new FileReader("./rootDir/c.txt");
    //每次读取10个字符
    char[] cbuf = new char[10];
    int count = r.read(cbuf);
    while (count > 0) {
        System.out.print(new String(cbuf, 0, count));
        count = r.read(cbuf);
    }
    r.close();
} catch (IOException e) {
    e.printStackTrace();
}

执行结果

总结

重点

1. 文件操作；
2. 字节流与字符流。

难点

1. 文件夹递归遍历；
2. 字节流与字符流。