文章目录

1. File类
- 1.1 预备知识
- 1.2 创建文件
- 1.3 文件的常用方法
2. IO流
- 2.1 InputStream
- 2.2 OutputStream
- 2.3 Reader
- 2.4 Writer
- 2.5 缓冲流
- 2.6 转换流
- 2.7 对象流
- 2.8 打印流

1. File类

1.1 预备知识

文件分隔符

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

换行

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

IDEA默认的当前路径

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

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);

1.2 创建文件

public class FileTest {
    public static void main(String[] args) throws IOException {
    
    	// 创建D:\filepath\test\test.txt
        File testFile = new File("D:\filepath\test\test.txt");
        // 获取test.txt文件的上级路径
        File fileParent = testFile.getParentFile();
		// 创建多级目录
        if (!fileParent.exists()) {
            fileParent.mkdirs();
        }
        // 创建文件
        if (!testFile.exists())
            testFile.createNewFile();
 
        System.out.println("path:"+testFile.getPath());
        System.out.println("absolutePath:"+testFile.getAbsolutePath());
        System.out.println("getFileName:"+testFile.getName());
    }
}

path:D:\filepath\test\test.txt
absolutePath:D:\filepath\test\test.txt
getFileName:test.txt

1.3 文件的常用方法

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());
    }
}

2. IO流

2.1 InputStream

构造方法

// 1. 使用File对象创建流对象
FileInputStream fin = new FileInputStream(new File("G:\\b.txt"));
      
// 2. 使用文件名称创建流对象
FileInputStream fin = new FileInputStream("G:\\b.txt");

读取数据
read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾为空，返回-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();
    }
}

从输入流读取一些字节数，并将它们存储到缓冲区b 。实际读取的字节数作为整数返回。
3. 错误读取

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

2.2 OutputStream

构造方法

// 1. 使用File对象创建流对象
FileOutputStream fos = new FileOutputStream(new File("G:\\b.txt"));
      
// 2. 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("G:\\b.txt");

// 3. 使用File对象创建流对象，并开启数据追加功能
FileOutputStream fos = new FileOutputStream(new File("G:\\b.txt"), true);

// 4. 使用文件名创建流对象，并开启数据追加功能
FileOutputStream fos = new FileOutputStream("G:\\b.txt", true)

输出数据

public class IoWrite {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 1. write(int b)
      	fos.write(97);  

		//2. write(byte[] b)
      	byte[] b = "麻麻我想吃烤山药".getBytes();
      	fos.write(b);

		//3. write(byte[] b, int off, int len)
		byte[] b = "abcde".getBytes();
        fos.write(b,2,2);
        
      	fos.close();
    }
}

2.3 Reader

构造器

// 1. 使用File对象创建流对象
FileReader fr = new FileReader(new File("G:\\b.txt"));
      
// 2. 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("G:\\b.txt");

读取字符

public class FRRead {
    public static void main(String[] args) throws IOException {
       	FileReader fr = new FileReader("G:\\b.txt");
        int b;
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
        fr.close();
    }
}

2.4 Writer

构造方法

   	 	// 第一种：使用File对象创建流对象
        FileWriter fw = new FileWriter(new File("G:\\b.txt"));
      
        // 第二种：使用文件名称创建流对象
        FileWriter fw = new FileWriter("G:\\b.txt");

// 1. 使用File对象创建流对象
FileWriter fw = new FileWriter(new File("G:\\b.txt"));
      
// 2. 使用文件名称创建流对象
FileWriter fw = new FileWriter("G:\\b.txt");

// 3. 使用File对象创建流对象，并开启数据追加功能
FileWriter fw = new FileWriter(new File("G:\\b.txt"), true);

// 4. 使用文件名创建流对象，并开启数据追加功能
FileWriter fw = new FileWriter("G:\\b.txt", true)

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

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个字符
      	
        fw.close();
    }
}
输出结果：
abC

2.5 缓冲流

//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"));

2.6 转换流

InputStreamReader字节流到字符流的桥梁，OutputStreamWriter字符流到字节流的桥梁。使用转换流可以在一定程度上避免乱码，还可以指定输入输出所使用的字符集。
在这里插入图片描述

对于OutputStreamWriter字符流到字节流的桥梁，很多人也认为是字节流到字符流的桥梁，其实不难解释。程序猿要看的是字符，计算机要存储的是字节，那我Input进来就是字节转字符，Ouput出去就是字符转字节，没毛病！

2.7 对象流

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

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

2. 序列化和反序列化的两个类
在这里插入图片描述
3. 可序列化的两个条件

该类必须实现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 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();
        } catch(IOException i)   {
            i.printStackTrace();
        }
   	}
}

2.8 打印流

字节打印流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

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();
    }
}