文章目录

一、补充
二、File类
- File类的含义
- 创建多级文件
- File类的常见方法
三、IO流
- IO流分类
- 输入输出流
- - FileOutputStream
  - InputStream
  - InputStream与OutputStream的实例
  - Reader
  - Writer
  - FileReader和FileWriter的实例
- 缓冲流
- 转换流
- 序列化与ObjectInputStream、ObjectOutputStream
- 打印流
Properties

参考文章：Java IO流（超详细）
参考文章：文件操作
参考文章：最全最详细的IO流教程

一、补充

1. 文件分隔符小知识

Windows：D:\Soft\QQ\Plugin
Linux：D:/Soft/QQ/Plugin

2. 换行

Windows：换行 = 回车+换行，即\r\n
Linux：换行 = 换行，即\n

3. IDEA默认的当前路径

工程Project的根就是IDEA的默认当前路径

4. IDEA文件分隔符格式

Windows： File file = new File(D:\test\test.txt);
Linux：File file = new File(D://test//test.txt);
统一：File testFile = new File(“D:” + File.separator + “test” + File.separator + fileName);

二、File类

File类的含义

File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。

创建多级文件

例如：D:\filepath\test\test.txt，先创建多级目录D:\filepath\test，在创建文件test.txt

package com.zte.FileTest;
 
import sun.net.ftp.FtpClient;
//import com.zte.ums.cnms.pm.load.enums.MppFileDirEnum;
import java.io.File;
import java.io.IOException;
 
public class FileTest {
    public static void main(String[] args) throws IOException {
    
        File testFile = new File("D:" + File.separator + "filepath" + File.separator + "test" + File.separator + "test.txt");
        
        File fileParent = testFile.getParentFile();//返回的是File类型,可以调用exsit()等方法 
        System.out.println("fileParent:" + fileParent);

        if (!fileParent.exists()) {
            fileParent.mkdirs();// 能创建多级目录
        }
        
        if (!testFile.exists())
            testFile.createNewFile();//有路径才能创建文件
        System.out.println(testFile);
 
        String path = testFile.getPath();
        String absolutePath = testFile.getAbsolutePath();
        String getFileName = testFile.getName();
        System.out.println("path:"+path);
        System.out.println("absolutePath:"+absolutePath);
        System.out.println("getFileName:"+getFileName);
    }
}
 
输出结果：
fileParent:D:\filepath\test
D:\filepath\test\test.txt
path:D:\filepath\test\test.txt
absolutePath:D:\filepath\test\test.txt
getFileName:test.txt

File类的常见方法

public class FileGet {
    public static void main(String[] args) {
        File f = new File("d:/aaa/bbb.java");    
        //文件绝对路径:d:\aaa\bbb.java 
        System.out.println("文件绝对路径:"+f.getAbsolutePath());
        //文件构造路径:d:\aaa\bbb.java
        System.out.println("文件构造路径:"+f.getPath());
        //文件名称：bbb.java
        System.out.println("文件名称:"+f.getName());
        //文件长度：2116字节
        System.out.println("文件长度:"+f.length()+"字节");
        //是否存在：true
        System.out.println(f.exists());
    }
}

三、IO流

IO流分类

1. 字节流
按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。

这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件等

eg.
假设文件file1.txt，采用字节流的话是这样读的：
a中国bc张三fe
第一次读：一个字节，正好读到’a’
第二次读：一个字节，正好读到’中’字符的一半。
第三次读：一个字节，正好读到’中’字符的另外一半。

2. 字符流
按照字符的方式读取数据的，一次读取一个字符.

这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。

注意：
纯文本文件，不单单是.txt文件，还包括 .java、.ini、.py 。总之只要能用记事本打开的文件都是普通文本文件。

3. 字符流和字节流的爱恨情仇

字符流 = 字节流 + 编码表

输入输出流

FileOutputStream

1. 构造方法

public FileOutputStream(File file)：以File对象为参数创建对象
public FileOutputStream(String name)：根据文件名称创建对象

// 使用File对象创建流对象
File file = new File("G:\\自动创建的文件夹\\a.txt");
FileOutputStream fos = new FileOutputStream(file);
      
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("G:\\b.txt");

2. 实现数据追加
每次程序运行，每次创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续追加新数据呢？并且实现换行呢？其实很简单，这个时候我们又要再学习FileOutputStream的另外两个构造方法

public FileOutputStream(File file, boolean append)
public FileOutputStream(String name, boolean append)

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

3. 输出数据
写出指定字节

public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)  //从`off`索引开始，`len`个字节
写出字节：write(int b) 方法，每次可以写出一个字节数据，代码如下：
public class IoWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源
        fos.close();
    }
}
输出结果：
abc

写出数组

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "麻麻我想吃烤山药".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
麻麻我想吃烤山药

写出数组指定部分

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
cd

InputStream

1. 构造方法

public FileInputStream(File file)：以File对象为参数创建对象
public FileInputStream(String name)：根据文件名称创建对象

// 使用File对象创建流对象
File file = new File("G:\\自动创建的文件夹\\a.txt");
FileInputStream fos = new FileInputStream(file);
      
// 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("G:\\b.txt");

2. 读取字节数据
read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1。

代码测试如下【read.txt文件中内容为abcde】

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");//read.txt文件中内容为abcde
      	// 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
      	// 读取到末尾,返回-1
       	read = fis.read();
        System.out.println( read);
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e
-1

循环读取

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e

3. 错误读取
read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // read.txt文件中内容为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

由于read.txt文件中内容为abcde，而错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换【注意是替换，看下图】，所以要通过len ，获取有效的字节
在这里插入图片描述

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

InputStream与OutputStream的实例

public class Copy {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 指定数据源
        FileInputStream fis = new FileInputStream("D:\\test.jpg");
        // 1.2 指定目的地
        FileOutputStream fos = new FileOutputStream("test_copy.jpg");

        // 2.读写数据
        // 2.1 定义数组
        byte[] b = new byte[1024];
        // 2.2 定义长度
        int len;
        // 2.3 循环读取
        while ((len = fis.read(b))!=-1) {
            // 2.4 写出数据
            fos.write(b, 0 , len);
        }

        // 3.关闭资源
        fos.close();
        fis.close();
    }
}

Reader

1. 构造方法

public FileReader(File file)：以File对象为参数创建对象
public FileReader(String name)：根据文件名称创建对象

// 使用File对象创建流对象
File file = new File("G:\\自动创建的文件夹\\a.txt");
FileReader fr = new FileReader(file);
      
// 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("G:\\b.txt");

2. 读取字符
read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1

public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("a.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fr.close();
    }
}

Writer

1. 构造方法

public FileWriter(File file)：以File对象为参数创建对象
public FileWriter(String name)：根据文件名称创建对象

public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
   	 	// 第一种：使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 第二种：使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

2. 续写和换行

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
      	// 写出字符串
        fw.write("哥敢");
      	// 写出换行
      	fw.write("\r\n");
      	// 写出字符串
  		fw.write("摸屎");
      	// 关闭资源
        fw.close();
    }
}
输出结果:
哥敢
摸屎

3. 写出数据

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 写出数据
      	fw.write(97); // 写出第1个字符
      	fw.write('b'); // 写出第2个字符
      	fw.write('C'); // 写出第3个字符
      	
        //关闭资源时,与FileOutputStream不同。 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        // fw.close();
    }
}
输出结果：
abC

4. 关闭close与刷新flush

flush ：刷新缓冲区，流对象可以继续使用。
close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
 
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();
      
      	// 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

FileReader和FileWriter的实例

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile {
    public static void main(String[] args) throws IOException {
        //创建输入流对象
        FileReader fr=new FileReader("F:\\新建文件夹\\aa.txt");//文件不存在会抛出java.io.FileNotFoundException
        //创建输出流对象
        FileWriter fw=new FileWriter("C:\\copyaa.txt");
        /*创建输出流做的工作：
         *      1、调用系统资源创建了一个文件
         *      2、创建输出流对象
         *      3、把输出流对象指向文件        
         * */
        //文本文件复制，一次读一个字符
        copyMethod1(fr, fw);
        //文本文件复制，一次读一个字符数组
        copyMethod2(fr, fw);
        
        fr.close();
        fw.close();
    }

    public static void copyMethod1(FileReader fr, FileWriter fw) throws IOException {
        int ch;
        while((ch=fr.read())!=-1) {//读数据
            fw.write(ch);//写数据
        }
        fw.flush();
    }

    public static void copyMethod2(FileReader fr, FileWriter fw) throws IOException {
        char chs[]=new char[1024];
        int len=0;
        while((len=fr.read(chs))!=-1) {//读数据
            fw.write(chs,0,len);//写数据
        }
        fw.flush();
    }
}

CopyFile

缓冲流

1. 缓冲流的基本原理

1. 使用了底层流对象从具体设备上获取数据，并将数据存储到缓冲区的数组内。
1. 通过缓冲区的read()方法从缓冲区获取具体的字符数据，这样就提高了效率。
1. 如果用read方法读取字符数据，并存储到另一个容器中，直到读取到了换行符时，将另一个容器临时存储的数据转成字符串返回，就形成了readLine()功能。

也就是说在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

2. 缓冲流的分类

字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter

3. 示例

//1. 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("b.txt"));

//2. 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));

//3. 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("b.txt"));

//4. 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

转换流

1. InputStreamReader类-----(字节流到字符流的桥梁)
转换流java.io.InputStreamReader，是Reader的子类，从字面意思可以看出它是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。

构造方法

InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

2. OutputStreamWriter类-----(字符流到字节流的桥梁)
字面看容易混淆会误以为是转为字符流，其实不然，OutputStreamWriter为从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

序列化与ObjectInputStream、ObjectOutputStream

1. 何谓序列化
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化
在这里插入图片描述
2. 序列化和反序列化的两个类

ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
ObjectInputStream类，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

创建可序列化对象，必须满足两个条件：

该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
      	System.out.println("Address  check : " + name + " -- " + address);
    }
}

序列化对象

public final void writeObject (Object obj) : 将指定的对象写出。

public class SerializeDemo{
   	public static void main(String [] args)   {
    	Employee e = new Employee();
    	e.name = "zhangsan";
    	e.address = "beiqinglu";
    	e.age = 20; 
    	try {
      		// 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
        	// 写出对象
        	out.writeObject(e);
        	// 释放资源
        	out.close();
        	fileOut.close();
        	System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
   	}
}
输出结果：
Serialized data is saved

反序列化创建对象

public final Object readObject () : 读取一个对象。
public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {		
             // 创建反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 读取一个对象
             e = (Employee) in.readObject();
             // 释放资源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕获其他异常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
        	// 捕获类找不到异常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 无异常,直接打印输出
        System.out.println("Name: " + e.name);	// zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

打印流

1. 分类

字节打印流PrintStream，字符打印流PrintWriter

2. 示例
PrintStream复制文本文件

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("copy.txt"));
        PrintStream ps=new PrintStream("printcopy.txt");
        String line;
        while((line=br.readLine())!=null) {
            ps.println(line);
        }
        br.close();
        ps.close();
    }
}

PrintWriter复制文本文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 使用打印流复制文本文件
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("aa.txt"));
        PrintWriter pw=new PrintWriter("printcopyaa.txt");
        String line;
        while((line=br.readLine())!=null) {
            pw.println(line);
        }
        br.close();
        pw.close();
    }
}

Properties

我想各位对这个Properties类多多少少也接触过了，首先Properties类并不在IO包下，那为啥要和IO流一起讲呢？原因很简单因为properties类经常和io流的联合一起使用。

1. 特有功能

public Object setProperty(String key,String value)
public String getProperty(String key)
public Set stringPropertyNames()

public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties properties = new Properties();
        // 添加键值对元素
        properties.setProperty("filename", "a.txt");
        properties.setProperty("length", "209385038");
        properties.setProperty("location", "D:\\a.txt");
        // 打印属性集对象
        System.out.println(properties);
        // 通过键,获取属性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));

        // 遍历属性集,获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        // 打印键值对
        for (String key : strings ) {
          	System.out.println(key+" -- "+properties.getProperty(key));
        }
    }
}
输出结果：
{filename=a.txt, length=209385038, location=D:\a.txt}
a.txt
209385038
D:\a.txt
filename -- a.txt
length -- 209385038
location -- D:\a.txt

2. IO流结合
把键值对形式的文本文件内容加载到集合中
public void load(Reader reader)
public void load(InputStream inStream)

3. 把集合中的数据存储到文本文件中
public void store(Writer writer,String comments)
public void store(OutputStream out,String comments)

public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties pro = new Properties();
        // 加载文本中信息到属性集
        pro.load(new FileInputStream("Properties.txt"));
        // 遍历集合并打印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
          	System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
输出结果：
filename -- Properties.txt
length -- 123
location -- C:\Properties.txt