Java高级：IO

Java高级：IO
笔记来源：尚硅谷Java入门视频教程(在线答疑+Java面试真题)
文章目录
一 File类的使用

 1.1 基本概述
- java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关
- File 能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
- 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
- File对象可以作为参数传递给流的构造器
1.2 File类的常用构造器
- public File(String pathname) ：pathname为文件的绝对路径或是相对路径
- public File(String parent, String child)：parent为上层父目录路径，child为该父目录下的文件或路径
- public File(File parent,String child)：parent为父目录路径的File对象，child为该父目录下的文件或路径
Trick:创建一个File对象时，若：
- pathname是在磁盘中真是存在文件或目录，则会为该File对象的各个属性显式赋值，对应物理磁盘文件的各个属性
- pathname没有真实的文件或目录阈值对应，则会为该File对象的各个属性默认赋值。
1.3 路径分隔符
- 路径中的每一级用一个路径分隔符隔开
- Windows系统中默认的路径分隔符为\
  
  Linux和URL的路径分隔符为/
- 因为Java的跨平台的特性，分隔符要慎用，Windows环境中的分隔符在Linux中会失效
- File类提供了一个常量：public static final String separator。根据操作系统，动态的提供分隔符。
1.4 File类常用方法
- public String getAbsolutePath()：获取绝对路径
- public String getPath() ：获取路径
- public String getName() ：获取名称
- public String getParent()：获取上层文件目录路径。若无，返回null
- public long length() ：获取文件大小（即：字节数）。(不是文件名的长度)
- public long lastModified() ：获取最后一次的修改时间，毫秒值
- public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
- public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
- public boolean renameTo(File dest):把文件重命名为指定的文件路径
- public boolean isDirectory()：判断是否是文件目录
- public boolean isFile() ：判断是否是文件
- public boolean exists() ：判断是否存在
- public boolean canRead() ：判断是否可读
- public boolean canWrite() ：判断是否可写
- public boolean isHidden() ：判断是否隐藏
- public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
- public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
- public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
- public boolean delete()：删除文件或者文件夹
二 IO流原理及流的分类

 2.1 IO原理
- IO是Input/Output的缩写， IO技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
- Java程序中，对于数据的输入/输出操作以流(stream)的方式进行。
- java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
- 程序中打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件IO资源。
2.2 流的分类
- 按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
- 按数据流的流向不同分为：输入流，输出流
- 按流的角色的不同分为：节点流，处理流
- Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
2.3 节点流和处理流
- 节点流：直接从数据源或目的地读写数据
- 处理流：不直接连接到数据源或目的地，而对在已存在的流（节点流或处理流）进行增强，通过对数据的处理为程序提供更为强大的读写功能。
2.4 InputStream & Reader

2.4.1 InputStream
- int read()：从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值-1。
- int read(byte[] b)：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。
- int read(byte[] b, int off,int len)：将读取的第一个字节存储在元素b[off]中，下一个存储在b[off+1]中，依次类推。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。
- public void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。
2.4.2 Reader
- int read()：读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码），如果已到达流的末尾，则返回-1。
- int read(char[] cbuf)：将字符读入数组。如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。
- int read(char[] cbuf,int off,int len)：将读取的第一个字符存储在元素c[off]中，下一个存储在c[off+1]中，依次类推。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数
- public void close() throws IOException：关闭此输入流并释放与该流关联的所有系统资源。
2.5 OutputStream & Writer

2.5.1 OutputStream
- void write(int b)：将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。即写入0~255范围的。
- void write(byte[] b)：将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
- void write(byte[] b,int off,int len)：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
- public void flush()throws IOException：刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
- public void close() throws IOException：关闭此输出流并释放与该流关联的所有系统资源。
2.5.2 Writer
- void write(int c)：写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。即写入0 到 65535 之间的Unicode码。
- void write(char[] cbuf)写入字符数组。
- void write(char[] cbuf,int off,int len)：写入字符数组的某一部分。从off开始，写入len个字符。
- void write(String str)：写入字符串。
- void write(String str,int off,int len)：写入字符串str的子串str.substring(off, len)。
- void flush()：刷新该流的缓冲，则立即将它们写入预期目标。
- public void close() throws IOException：关闭此输出流并释放与该流关联的所有系统资源。
三节点流

 3.1 节点流读取文件
1. 建立一个流对象，将已存在的一个文件加载进流。
```
FileReader fr = new FileReader(new File(“Test.txt”));
```
1. 创建一个临时存放数据的数组。
```
char[] ch = new char[1024];
```
1. 调用流对象的读取方法将流中的数据读入到数组中。
```
fr.read(ch);
```
1. 关闭资源。
```
fr.close();
```
代码演示
```
FileReader fr = null;
try {
    fr = new FileReader(new File("c:\\test.txt"));
    char[] buf = new char[1024];
    int len;
    while ((len = fr.read(buf)) != -1) {
        System.out.print(new String(buf, 0, len));
    }
} catch (IOException e) {
    System.out.println("read-Exception :" + e.getMessage());
} finally {
    if (fr != null) {
        try {
            fr.close();
        } catch (IOException e) {
            System.out.println("close-Exception :" + e.getMessage());
        } 
    } 
}
```
3.2 节点流写入文件
1. 创建流对象，建立数据存放文件
```
FileWriter fw = new FileWriter(new File(“Test.txt”));
```
1. 调用流对象的写入方法，将数据写入流
```
fw.write("atguigu-songhongkang");
```
1. 关闭流资源，并将流中的数据清空到文件中。
```
fw.close();
```
代码演示
```
FileWriter fw = null;
try {
    fw = new FileWriter(new File("Test.txt"));
    fw.write("atguigu-songhongkang");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fw != null){
        try {
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
}
```
3.3 注意点
- 定义文件路径时，注意：可以用“/”或者“\”。
- 在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。
- 如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
- 在读取文件时，必须保证该文件已存在，否则报异常。
- 字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt
- 字符流操作字符，只能操作普通文本文件。最常见的文本文件：.txt，.java，.c，.cpp 等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件
四缓冲流
- 为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
- 缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：
  - BufferedInputStream 和 BufferedOutputStream
  - BufferedReader 和 BufferedWriter
- 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。
- 当写入数据时，数据会先写入缓冲区，将缓冲区写满之后，会一次性的将缓冲区数据写到文件里。使用方法flush()可以手动的强制将缓冲区的内容全部写入输出流。
- 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
- 关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流。
- 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出。
代码演示
```
BufferedReader br = null;
BufferedWriter bw = null;
try {
    // 创建缓冲流对象：它是处理流，是对节点流的包装
    br = new BufferedReader(new FileReader("d:\\IOTest\\source.txt"));
    bw = new BufferedWriter(new FileWriter("d:\\IOTest\\dest.txt"));
    String str;
    while ((str = br.readLine()) != null) { // 一次读取字符文本文件的一行字符
        bw.write(str); // 一次写入一行字符串
        bw.newLine(); // 写入行分隔符
    }
    bw.flush(); // 刷新缓冲区
} catch (IOException e) {
    e.printStackTrace();
} finally {
    // 关闭IO流对象
    try {
        if (bw != null) {
            bw.close(); // 关闭过滤流时,会自动关闭它所包装的底层节点流
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        if (br != null) {
            br.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } 
}
```
五转换流

 5.1 转换流概述
- 转换流提供了在字节流和字符流之间的转换
- Java API提供了两个转换流：
  - InputStreamReader：将InputStream转换为Reader
  - OutputStreamWriter：将Writer转换为OutputStream
- 字节流中的数据都是字符时，转成字符流操作更高效。
- 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。
- 转换流是一种处理流
5.2 InputStreamReader
- 实现将字节的输入流按指定字符集转换为字符的输入流。
- 构造器
  - public InputStreamReader(InputStream in)
  - public InputSreamReader(InputStream in,String charsetName)
    
    例如：Reader isr = new InputStreamReader(System.in,”gbk”)
5.3 OutputStreamWriter
- 实现将字符的输出流按指定字符集转换为字节的输出流。
- 构造器
  - public OutputStreamWriter(OutputStream out)
  - public OutputStreamWriter(OutputStream out,String charsetName)
代码演示
```
public void testMyInput() throws Exception {
    FileInputStream fis = new FileInputStream("dbcp.txt");
    FileOutputStream fos = new FileOutputStream("dbcp5.txt");
    InputStreamReader isr = new InputStreamReader(fis, "GBK");
    OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
    BufferedReader br = new BufferedReader(isr);
    BufferedWriter bw = new BufferedWriter(osw);
    String str = null;
    while ((str = br.readLine()) != null) {
        bw.write(str);
        bw.newLine();
        bw.flush();
    }
    bw.close();
    br.close();
}
```
六标准输入流、输出流
- System.in和System.out分别代表了系统标准的输入和输出设备
- 默认输入设备是：键盘；输出设备是：显示器
- System.in的类型是InputStream
- System.out的类型是PrintStream，其是OutputStream的子类，FilterOutputStream 的子类
- 重定向：通过System类的setIn，setOut方法对默认设备进行改变。
  - public static void setIn(InputStream in)
  - public static void setOut(PrintStream out)
代码演示
```
System.out.println("请输入信息(退出输入e或exit):");
// 把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {
    while ((s = br.readLine()) != null) { // 读取用户输入的一行数据 --> 阻塞程序
        if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
            System.out.println("安全退出!!");
            break; }
        // 将读取到的整行字符串转成大写输出
        System.out.println("-->:" + s.toUpperCase());
        System.out.println("继续输入信息");
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (br != null) {
            br.close(); // 关闭过滤流时,会自动关闭它包装的底层节点流
        }
    } catch (IOException e) {
        e.printStackTrace();
    } 
}
```
七打印流
- 实现将基本数据类型的数据格式转化为字符串输出
- 打印流：PrintStream和PrintWriter
- 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
- PrintStream和PrintWriter的输出不会抛出IOException异常
- PrintStream和PrintWriter有自动flush功能
- PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。
  - 在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
- System.out返回的是PrintStream的实例
代码实例
```
PrintStream ps = null;
try {
    FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
    // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
    ps = new PrintStream(fos, true);
    if (ps != null) {// 把标准输出流(控制台输出)改成文件
        System.setOut(ps);
    }
    for (int i = 0; i <= 255; i++) { // 输出ASCII字符
        System.out.print((char) i);
        if (i % 50 == 0) { // 每50个数据一行
            System.out.println(); // 换行
        } }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    if (ps != null) {
        ps.close();
    } 
}
```
八数据流
- 为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。
- 数据流有两个类：(用于读取和写出基本数据类型、String类的数据）：DataInputStream和 DataOutputStream，分别包装了InputStream和OutputStream子类的流
代码演示
```
DataOutputStream dos = null;
try { // 创建连接到指定文件的数据输出流对象
    dos = new DataOutputStream(new FileOutputStream("destData.dat"));
    dos.writeUTF("我爱北京天安门"); // 写UTF字符串
    dos.writeBoolean(false); // 写入布尔值
    dos.writeLong(1234567890L); // 写入长整数
    System.out.println("写文件成功!");
} catch (IOException e) {
    e.printStackTrace();
} finally { // 关闭流对象
    try {
        if (dos != null) {
            // 关闭过滤流时,会自动关闭它包装的底层节点流
            dos.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } 
}
```
```
DataInputStream dis = null;
try {
    dis = new DataInputStream(new FileInputStream("destData.dat"));
    String info = dis.readUTF();
    boolean flag = dis.readBoolean();
    long time = dis.readLong();
    System.out.println(info);
    System.out.println(flag);
    System.out.println(time);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if (dis != null) {
        try {
            dis.close();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    } 
}
```
九对象流

 9.1 对象流概述
- ObjectInputStream和ObjectOutputStream
- 用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可
- 以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
- 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
- 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
- ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
9.2 序列化
- 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
- 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
- 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是JavaEE 平台的基础
- 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常
  - Serializable
  - Externalizable
- 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID;
  - serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
  - 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议显式声明。
  - 简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)
- 强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field的类也不能序列化
9.3 使用流程
- 序列化：
  - 创建一个 ObjectOutputStream
  - 调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
  - 注意写出一次，操作flush()一次
- 反序列化：
  - 创建一个 ObjectInputStream
  - 调用 readObject() 方法读取流中的对象
代码演示
```
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“data.txt"));
Person p = new Person("韩梅梅", 18, "中华大街", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();
```
```
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“data.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();
```
十随机存取文件流
- RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。
- RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件
  - 支持只访问文件的部分内容
  - 可以向已存在的文件后追加内容
- RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。
  
  RandomAccessFile 类对象可以自由移动记录指针：
  - long getFilePointer()：获取文件记录指针的当前位置
  - void seek(long pos)：将文件记录指针定位到 pos 位置
- 构造器
  - public RandomAccessFile(File file, String mode)
  - public RandomAccessFile(String name, String mode)
- mode用于参数指定 RandomAccessFile 的访问模式：
  - r: 以只读方式打开
  - rw：打开以便读取和写入
  - rwd:打开以便读取和写入；同步文件内容的更新
  - rws:打开以便读取和写入；同步文件内容和元数据的更新
- RandomAccessFile可用于实现一个多线程断点下载的功能。
  - 断点下载：下载前都会建立两个临时文件，一个是与被下载文件大小相同的空文件，另一个是记录文件指针的位置文件，每次暂停的时候，都会保存上一次的指针，然后断点下载的时候，会继续从上一次的地方下载。
小结
- 流是用来处理数据的。
- 处理数据时，一定要先明确数据源，与数据目的地
  - 数据源可以是文件，可以是键盘。
  - 数据目的地可以是文件、显示器或者其他设备。
- 流只是在帮助数据进行传输,同时对传输的数据进行处理，比如过滤处理、转换处理等
相关阅读:
C语言超好看的爱心代码！一定不要错过！
mysql5.7的安装
 Golang defer
十四天学会C++之第二天（函数和库）
实现8086汇编编译器（三）——jmp指令的翻译
 微信CRM系统致力于帮助金融保险行业
 博流RISC-V芯片BL616开发环境搭建
 程序员专属情人节表白网站(html+css+js邀请函网站制作)
Nacos下载与安装详解
 程序猿成长之路之密码学篇-RSA非对称分组加密算法介绍
原文地址：https://blog.csdn.net/sd_960614/article/details/126964898

文章目录

一 File类的使用

1.1 基本概述

1.2 File类的常用构造器

1.3 路径分隔符

1.4 File类常用方法

二 IO流原理及流的分类

2.1 IO原理

2.2 流的分类

2.3 节点流和处理流

2.4 InputStream & Reader

2.4.1 InputStream

2.4.2 Reader

2.5 OutputStream & Writer

2.5.1 OutputStream

2.5.2 Writer

三 节点流

3.1 节点流读取文件

3.2 节点流写入文件

3.3 注意点

四 缓冲流

五 转换流

5.1 转换流概述

5.2 InputStreamReader

5.3 OutputStreamWriter

六 标准输入流、输出流

七 打印流

八 数据流

九 对象流

9.1 对象流概述

9.2 序列化

9.3 使用流程

十 随机存取文件流

小结

三节点流

四缓冲流

五转换流

六标准输入流、输出流

七打印流

八数据流

九对象流

十随机存取文件流