java-IO框架-CSDN博客

本文链接：https://blog.csdn.net/weixin_51313154/article/details/125125262

文章目录

1. File类

File类此类提供了针对文件或者文件夹操作的相关方法

package com.qfedu.test1;

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

/**
 * 	File类  此类提供了针对文件或者文件夹操作的相关方法
 * @author WHD
 *
 */
public class TestFile {
	public static void main(String[] args) throws IOException {
		File file1 = new File("A.txt");
		if(!file1.exists()) {
			System.out.println("文件是否创建成功：" + file1.createNewFile());
		}
		System.out.println("创建完成，文件是否存在：" + file1.exists());
		System.out.println("文件的名称为：" + file1.getName());
		System.out.println("文件的大小是：" + file1.length());
		System.out.println("文件是相对路径是：" + file1.getPath());
		System.out.println("文件的绝对路径是：" + file1.getAbsolutePath());
		System.out.println("是否为文件：" + file1.isFile());
		System.out.println("是否为文件夹：" + file1.isDirectory());
		System.out.println("删除文件:" + file1.delete());
		
		System.out.println("文件是否存在：" + file1.exists());
		
		
	}
}

2. 字节流

2.1 读取InputStream

2.1 FileInputStream读取一个字节

read() 每次读取一个字节返回值为读取的字节的ASCII码如果读取不到内容返回为-1

package com.qfedu.test2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 	InputStream 字节读取流父类 抽象类
 * 	FileInputStream 字节读取流
 * 
 * 	read()  每次读取一个字节 返回值为读取的字节的ASCII码 如果读取不到内容返回为-1
 * 	
 * @author WHD
 *
 */
public class TestFileInputStream1 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = null;
		try {
			
			// 50
			fis = new FileInputStream("A.txt");
			
			int readData = -1;
			
			while((readData = fis.read()) != -1) {
				System.out.println((char)readData);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

2.2 FileInputStream读取一个字节数组

read(byte [] data) 每次读取一个byte数组返回值为读取的个数

读取的内容在数组中如果读取不到内容返回为-1

package com.qfedu.test3;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * 	read(byte [] data) 每次读取一个byte数组 返回值为读取的个数 
 * 	读取的内容在数组中 如果读取不到内容返回为-1
 * @author WHD
 *
 */
public class TestFileInputStream2 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("A.txt");
		
		byte [] data = new byte[2];
		
		int readCount  = -1;
		
		while((readCount = fis.read(data)) != -1) {
			System.out.println(new String(data, 0, readCount));
		}
		// 关闭资源
		fis.close();
		
	}
}

read(byte [] data) 读取中文，如果定义长度为2的数组，可以读取中文，但是如果中文汉字

是在奇数位，那么将出现乱码，解决方案：

1.定义一个比较长的数组

2.使用字节流的available()方法来定义数组长度(推荐使用)

package com.qfedu.test3;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

/**
 * 	read(byte [] data) 读取中文，如果定义长度为2的数组，可以读取中文，但是如果中文汉字
 * 	是在奇数位，那么将出现乱码，解决方案：
 * 	1.定义一个比较长的数组
 * 	2.使用字节流的available()方法来定义数组长度(推荐使用)
 * @author WHD
 *
 */
public class TestFileInputStream3 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("A.txt");
		
		System.out.println(fis.available());
		
		byte [] data = new byte[fis.available()];
		
		int readCount  = -1;
		
		while((readCount = fis.read(data)) != -1) {
			System.out.println(new String(data, 0, readCount));
		}
		
		// 关闭资源
		fis.close();
		
	}
}

2.2 写入OutputStream

2.2.1 FileOutputStream写入字节

OutputStream

FileOutputStream 字节写入流

write(int data) 每次写入一个字节

package com.qfedu.test4;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 	OutputStream
 * 	FileOutputStream  字节写入流
 * 	write(int data) 每次写入一个字节
 * @author WHD
 *
 */
public class TestFileOutputStream1 {
	public static void main(String[] args) {
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("B.txt",true);
			fos.write(66);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			// 关闭资源
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
				
	}
}

2.2.2 FileOutputStream写入字节数组

OutputStream

FileOutputStream 字节写入流

write(byte [] data) 每次写入一个字节数组

我们在创建FileOutputStream对象可以指定是否追加内容如果不指定或者写为false 表示覆盖之前的内容

写为true表示追加

package com.qfedu.test4;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 	OutputStream
 * 	FileOutputStream  字节写入流
 * 	write(byte [] data) 每次写入一个字节数组
 * 
 * 	我们在创建FileOutputStream对象 可以指定是否追加内容 如果不指定 或者 写为false  表示覆盖之前的内容
 * 	写为true表示追加
 * @author WHD
 *
 */
public class TestFileOutputStream2 {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("C.txt",true);
		
		byte [] data = {70,71,72,73,74};
		
		fos.write(data);
		
		fos.close();
	}
}

OutputStream

FileOutputStream 字节写入流

write(byte [] data) 每次写入一个字节数组

我们可以直接调用String类的 getBytes()方法将字符串转换为byte数组

package com.qfedu.test4;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 	OutputStream
 * 	FileOutputStream  字节写入流
 * 	write(byte [] data) 每次写入一个字节数组
 * 	
 * 	我们可以直接调用String类的 getBytes()方法 将字符串转换为byte数组
 * @author WHD
 *
 */
public class TestFileOutputStream3 {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("C.txt",true);
		
		String str = "hello world 世界你好999";
		
		byte [] data = str.getBytes();
		
		fos.write(str.getBytes());
		
		fos.close();
	}
}

3. 字符流

3.1 读取Reader

3.1.1 InputStreamReader

Reader 字符读取流父类抽象类

InputStreamReader 子类

read() 每次读取一个字符

package com.qfedu.test5;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 	Reader 字符读取流父类 抽象类
 * 	InputStreamReader 子类
 * 	read()  每次读取一个字符
 * @author WHD
 *
 */
public class TestInputStreamReader1 {
	public static void main(String[] args) {
		// 局部变量必须先赋值 才能使用
		FileInputStream fis = null;
		InputStreamReader reader = null;
		try {
			fis = new FileInputStream("A.txt");
			reader = new InputStreamReader(fis);
			
			int readData = -1;
			
			while((readData = reader.read()) != -1) {
				System.out.println((char)readData);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			// 关闭资源  先用后关
			try {
				if(reader != null) {
					reader.close();
				}
				if(fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Reader 字符读取流父类抽象类

InputStreamReader 子类

read(char [] data) 每次读取一个字符数组

package com.qfedu.test5;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 	
 * 	Reader 字符读取流父类 抽象类
 * 	InputStreamReader 子类
 * 	read(char [] data)  每次读取一个字符数组
 * @author WHD
 *
 */
public class TestInputStreamReader2 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("A.txt");
		
		InputStreamReader reader = new InputStreamReader(fis);
		
		char [] data = new char[5];
		
		int readCount = -1;
		
		while((readCount = reader.read(data)) != -1) {
			System.out.println(new String(data,0,readCount));
		}
		
	}
}

读取位于桌面的hello.txt文件

读取文件如果编码格式不一致会导致乱码

解决方案：将编码格式统一

1.使用两个参数的InputStreamReader构造方法第二个参数指定编码格式

2.将源文件编码格式改为和JDK编码格式一直 ANSI—GBK

package com.qfedu.test5;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 	读取位于桌面的hello.txt文件
 * 	读取文件如果编码格式不一致会导致乱码
 * 	解决方案：将编码格式统一
 * 	1.使用两个参数的InputStreamReader构造方法 第二个参数指定编码格式
 * 	2.将源文件编码格式改为和JDK编码格式一直   ANSI---GBK
 * @author WHD
 *
 */
public class TestInputStreamReader3 {
	public static void main(String[] args) throws IOException {
		System.getProperties().list(System.out);
		
		
		FileInputStream fis = new FileInputStream("C:/Users/WHD/Desktop/hello.txt");
		
		InputStreamReader reader = new InputStreamReader(fis);
		
		char [] data = new char[6];
		
		int readCount = -1;
		
		while(( readCount = reader.read(data)) != -1){
			System.out.println(new String(data,0,readCount));
		}
		reader.close();
		fis.close();
		
	}
}

3.1.2 FileReader

Reader

InputStreamReader

FileReader 只能按照本地平台默认的编码格式来读取文件

package com.qfedu.test6;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 	Reader
 * 	InputStreamReader
 * 	FileReader 只能按照本地平台默认的编码格式来读取文件
 * @author WHD
 *
 */
public class TestFileReader {
	public static void main(String[] args) throws IOException {
		FileReader reader = new FileReader("A.txt");
		
		char [] data = new char[100];
		
		reader.read(data);
		
		System.out.println(new String(data,0,data.length));
		
		reader.close();
	}
}

3.1.3 BufferedReader

Reader

BufferedReader InputStreamReader

BufferedReader 带有缓冲区的字符读取流可以提高字符读取的效率

独有 readLine()方法每次读取一行

package com.qfedu.test6;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 	Reader
 * 	BufferedReader  InputStreamReader
 * 
 * 	BufferedReader 带有缓冲区的字符读取流 可以提高字符读取的效率
 * 	独有 readLine()方法 每次读取一行
 * @author WHD
 *
 */
public class TestBufferedReader {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("A.txt")));

		String line = null;

		while((line = br.readLine() ) != null) {
			System.out.println(line);
		}

		br.close();

	}
}

3.2 写入Writer

3.2.1 OutputStreamWriter

Writer

OutputStreamWriter 可以指定写入文件的编码格式如果不指定将按照本地平台默认的编码格式写入 GBK

write()

package com.qfedu.test7;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 	Writer
 * 	OutputStreamWriter 可以指定写入文件的编码格式 如果不指定 将按照本地平台默认的编码格式写入 GBK
 * 	
 * 	write()
 * @author WHD
 *
 */
public class TestOutputStreamWriter {
	public static void main(String[] args) {
		try {
			OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D.txt",true),"utf-8");
		
			osw.write("hello world世界你好6666");
		
			osw.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
}

3.2.2 FileWriter

Writer

OutputStreamWriter

FileWriter 只能按照本地平台默认的编码格式写入文件

package com.qfedu.test7;

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

/**
 * 	Writer
 * 	OutputStreamWriter
 * 	FileWriter  只能按照本地平台默认的编码格式写入文件
 * @author WHD
 *
 */
public class TestFileWriter {
	public static void main(String[] args) {
		FileWriter fw = null;
		try {
			fw = new FileWriter("E.txt");
			
			fw.write("hello world 世界好2356.0");
			
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(fw != null) {
					fw.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3.2.3 BufferedWriter

Writer

BufferedWriter 带有缓冲区的字符写入流可以提高写入的效率

package com.qfedu.test7;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 	Writer
 * 	BufferedWriter 带有缓冲区的字符写入流 可以提高写入的效率 
 * @author WHD
 *
 */
public class TestBufferedWriter {
	public static void main(String[] args) throws IOException {
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F.txt")));
		
		bw.write("abc\ndefg");
		
		bw.newLine();
		
		bw.write("世界\n你好");
		
		bw.close();
		
	}
}

4.数据流(字节流)

DataInputStream负责读取二进制文件 read()

DataOutputStream负责写入二进制文件 write()

以上两个类均属于字节流

package com.qfedu.test1;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 	DataInputStream负责读取二进制文件  read()
 * 	DataOutputStream负责写入二进制文件  write()
 * 
 * 	
 * @author WHD
 *
 */
public class TestDataStream {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("D:\\beautyGirls\\GOGO全球高清大胆美女花苑制服诱惑丝袜美腿丝袜亚洲综合\\3ad2b7e86f.jpg");
		
		DataInputStream dis = new DataInputStream(fis);
		
		byte [] data = new byte[ fis.available()];
		
		dis.read(data); // 读取完毕 然后写入
		
//		System.out.println(new String(data,0,data.length));
		
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("C:\\Users\\WHD\\Desktop\\hello.jpg"));	
		
		dos.write(data);
		
		// 关闭资源  先用后关 
		
		dos.close();
		dis.close();
		fis.close();
	}
}

5.对象流(字节流)

序列化：将对象以流的形式保存在二进制文件中，称之为序列化

反序列化：将保存有对象的二进制文件读取为对象，称之为反序列化

ObjectInputStream负责读取对象 readObject()

ObjectOutputStream负责写入对象 writeObject()

需要序列化的类必须实现Serializable接口

package com.qfedu.test2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 	序列化：将对象以流的形式保存在二进制文件中，称之为序列化
 * 	反序列化：将保存有对象的二进制文件读取为对象，称之为反序列化
 * 	
 * 	ObjectInputStream负责读取对象  readObject() 
 * 	ObjectOutputStream负责写入对象 writeObject() 
 * 	
 * 	需要序列化的类必须实现Serializable接口
 * @author WHD
 *
 */
public class TestObjectStream {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		Student stu1 = new Student("赵四", 20, "象牙山");
		Student stu2 = new Student("大拿", 21, "象牙山");
		Student stu3 = new Student("广坤", 22, "象牙山");
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("stu.txt"));
		
		oos.writeObject(stu1);
		oos.writeObject(stu2);
		oos.writeObject(stu3);
		
		// 以上代码实现对象写入 接下来继续读取对象
		FileInputStream fis = new FileInputStream("stu.txt");
		
		ObjectInputStream ois = new ObjectInputStream(fis);
		
//		Object obj1 = ois.readObject();
//		
//		if(obj1 instanceof Student) {
//			Student s1 = (Student) obj1;
//			System.out.println(s1);
//		}
//		
//		Object obj2 = ois.readObject();
//		
//		if(obj2 instanceof Student) {
//			Student s1 = (Student) obj2;
//			System.out.println(s1);
//		}
//		
//		Object obj3 = ois.readObject();
//		
//		if(obj3 instanceof Student) {
//			Student s1 = (Student) obj3;
//			System.out.println(s1);
//		}
		
		while(fis.available() > 0) { // 判断流中的可读字节数 可读字节数会随着读取 指针的移动  不断减少
			Object obj = ois.readObject();
			if(obj instanceof Student) {
				Student s = (Student) obj;
				System.out.println(s);
			}
		}

	}
}

package com.qfedu.test2;

import java.io.Serializable;

public class Student implements Serializable{
	private String name;
	private int age;
	private transient String address;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public Student() {
	}
	public Student(String name, int age, String address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", address=" + address + "]";
	}
	
}