JavaIO流的使用(笔记详解)

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/weixin_43691058/article/details/102689066

一、IO流概述及体系

• IO流用来处理设备之间的数据传输。
• Java对数据的操作是通过流(系统资源)的方式。
• Java用于操作流的对象都在Java.io包中。
• 流按照操作数据分为两种：字节流，字符流。
• 流按照流向分为：输入流，输出流。
  

二、Java字符流的使用

关于缓冲区:

• 缓冲区，提高了对数据的读写效率。
• 对应类：BufferedWriter和BufferedReader。
• 缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 使用带缓冲区的字符流实现文件copy
 *
 */
public class Demo {
	public static void main(String[] args) {
		BufferedReader source = null;
		BufferedWriter target = null;
		try {
			// new用读取流缓冲(new建立读取流对象(new建立源文件对象))
			source = new BufferedReader(new FileReader(new File("D:\\Demo1\\a.txt")));
			// new用写入流缓冲(new建立写入流对象(new建立目标文件对象)
			target = new BufferedWriter(new FileWriter(new File("D:\\Demo2\\b.txt")));
			String line = null;
			while ((line = source.readLine()) != null) {
				target.write(line);
				target.newLine();
				target.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (source != null) {
					source.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("读取流关闭出问题了.");
			}

			try {
				if (target != null) {
					target.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("写入流关闭出问题了.");
			}
		}
	}
}

三、Java字节流的使用

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 使用带缓冲区的字节流实现文件copy
 *
 */
public class Demo {

	public static void main(String[] args) throws IOException {
		BufferedInputStream souce = null;
		BufferedOutputStream target = null;
		try {
			souce = new BufferedInputStream(new FileInputStream("D:\\Demo1\\a.txt"));
			target = new BufferedOutputStream(new FileOutputStream("D:\\Demo2\\b.txt"));

			byte[] b = new byte[1024];
			int len = 0;
			while ((len = souce.read(b)) != -1) {
				target.write(b, 0, len);
				target.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (souce != null) {
				souce.close();
			}
			if (target != null) {
				target.close();
			}
		}
	}
}

四、Java转换流的使用

为什么要有转换流?

• InputStreamReader和OutputStreamWriter，方便字符流与字节流之间的操作，是字符流与字节流之间的桥梁。
• 应用：当字节流中的数据都是字符时，转换成字符流操作更高效。
  

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * 使用带缓冲区的转换流实现文件copy
 *
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		BufferedReader source = null;
		BufferedWriter target = null;
		try {
//			source = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\Demo1\\a.txt")));
			source = new BufferedReader(new FileReader("D:\\Demo1\\a.txt"));
//			target = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\Demo2\\b.txt"), "utf-8"));
			target = new BufferedWriter(new FileWriter("D:\\Demo2\\b.txt"));

			String line = null;
			while ((line = source.readLine()) != null) {
				target.write(line);
				target.newLine();
				target.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (source != null) {
				source.close();
			}
			if (target != null) {
				target.close();
			}
		}
	}
}

五、标准输入输出流的使用

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

/**
 * 使用标准输入输出流进行输入输出
 *
 */
public class 标准输入输入流 {
	public static void main(String[] args) throws IOException {
		// InputStream in = System.in;
		// PrintStream out = System.out;
		BufferedReader source = null;
		BufferedWriter target = null;

		try {
			source = new BufferedReader(new InputStreamReader(System.in));
			target = new BufferedWriter(new OutputStreamWriter(System.out));
			String line = null;
			while ((line = source.readLine()) != null) {
				if ("over".equals(line)) {
					break;
				}
				target.write(line.toUpperCase());// 读取的同时将小写字母转换为大写
				target.newLine();
				target.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (source != null) {
				source.close();
			}
			if (target != null) {
				target.close();
			}
		}
	}
}

六、打印流的使用

• printWriter和printStream分别是字符打印流和字节打印流，可以直接操作输入流和文件。
• printStream为其它输出流添加了功能，使它们能够方便的打印各种数据值表示形式。

	/**
	 * 字节打印流测试
	 */
	@Test
	public void test1() throws IOException {
		PrintStream ps = new PrintStream("a.txt");
		ps.write(97);// write方法自动转化为a
		ps.print(97);// print方法原样输出
		ps.flush();
		ps.close();
	}

	/**
	 * 字符打印流测试
	 * 
	 */
	@Test
	public void test2() throws IOException {
		PrintStream out = System.out;
		PrintWriter pw = new PrintWriter(out);
		pw.print('a');
		pw.flush();
		pw.close();
	}

七、对象流的使用

如何使用对象流？

• 被操作的对象需要实现Serializable(标记接口)，尽量显示生成序列号(版本号)。
• 将内存汇总的对象写入磁盘，从而进行持久化操作。(即序列化过程)

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import org.junit.Test;

public class 对象流 {

	/**
	 * 序列化过程 将内存中的对象写入磁盘
	 * 
	 * @throws IOException
	 */
	@Test
	public void test1() throws IOException {
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("c.txt"));
		out.writeObject(new Person("zs", 20));
		out.flush();
		out.close();
	}

	/**
	 * 反序列化过程 将磁盘中的对象读出到内存
	 * 
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	@Test
	public void test2() throws IOException, ClassNotFoundException {
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("c.txt"));
		Object readObject = in.readObject();
		Person p = (Person) readObject;
		System.out.println(p.getName());
		in.close();
	}

}

// Person类实现Serializable接口
class Person implements Serializable {
	String name;
	int age;

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

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

}