javaIO总结

最新推荐文章于 2021-09-05 17:09:28 发布

A coding monkey

最新推荐文章于 2021-09-05 17:09:28 发布

阅读量197

点赞数

分类专栏： javaIO

本文链接：https://blog.csdn.net/qq_36795474/article/details/81152506

版权

javaIO 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

IO是input和output的缩写，主要用来做数据传输的。IO中的类非常多，内容庞大，采用合适的方式对其进行分类，将有助于我们记忆。先贴一张IO总体的结构图，额，内容有点多。。。

IO分类

字节流和字符流（按处理数据的基本单位）：
1. 字节流：处理数据时，以字节为基本单位，每次读入或者读出8位数据，可以操作任何类型的数据。
2. 字符流：处理数据时，以字符为基本单位，每次读入或者读出16位数据，只能处理字符类型的数据。
输入流和输出流（按流的方向）：
1. 输入流：从文件中将数据读取到内存中，用于数据的读取操作。
2. 输出流：从内存中将数据读出到文件中，用于数据的写入操作。
节点流和处理流（按流的功能）：
1. 节点流：直接与数据源直接打交道，用来处理流的读入和读出。
2. 处理流：在节点流的基础上，再向节点流的外层嵌套一层，使节点流的功能更加强大，用来丰富功能的。

下面给一个图，使IO分类变得更加清晰：

preview

字节流

InputStream作为字节输入流的父类，是一个抽象类，其处理数据的基本单位是字节，在处理过程中不存在乱码问题。

其子类中的FileInputStream、StringBufferInputStream、ByteArrayInputStream是3基本的介质流，分别中本地文件中、StringBuffer、Byte数组中读取数据。

PipedInputStream、PipedOutputStream是从管道中读取和读入数据的。

ObjectInputStream用于读入对象，从文件中读取对象的过程，也就是对象的反序列化的过程；ObjectOutputStream将对象读入到文件中，就是将对象序列化的过程，因此对象的类需要实现Serialize接口。

FileInputStream与FileOutputStream实现文件的复制

/**
 * 
 */
package com.zmh.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
*  <p>Title: Test</p>
*  <p>Description:使用文件输入流和文件输出流实现文件的复制 </p>
*  <p>Company: </p>
*  @author Administrator
*  @date 2018年7月22日 上午11:30:57
*/
public class Test {
	/**
	 * 对于FileInputStream有几个常用的方法：
	 * 		 1、public int read();从数据流中一次读取一个字节,并返回读取到的字节数
	 *       2、public int   read(byte[] buf);从数据流中最多读取buf.length个字节的数据读入到一个byte数组中。
	 *       3、public int   read(byte[] buf,int off,int len);从数据流中读取长度为len个字节到byte数组中。off表示数组中偏移量
	 * 对于FileOutputStream常用的几个方法：
	 * 	     1、 public FileOutputStream (File file);创建一个指定File的输出流
	 *       2、public FileOutputStream(String name);创建一个指定文件路径的输出流
	 *       3、public FileOutputStream(File file,boolean append);这里的append如果为true,则在文件内容末尾追加；如果为false,添加内容直接覆盖文件之前的内容
	 *       4、public void write(byte[] b);将b中的字节数组中内容写入到文件输出流中。
	 *       5、public void write(byte[] b,int off,int len);将数组中从偏移量off开始的len写入输出流中。
	 *      
	 */
	public static void main(String[] args) {
		try{
		FileInputStream is=new FileInputStream("E:\\io.txt");//从输入流中读取数据
		FileOutputStream os=new FileOutputStream("E:\\io1.txt");//从输出流中写入数据
		byte[] buf=new byte[1024];//字节缓冲区，减少io次数，提高效率
		int len;
		while((len=is.read(buf))!=-1){
			os.write(buf, 0, len);//将缓冲区数据写入输出流
		}
		is.close();
		os.close();              
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
}

ObjectInputStream与ObjectOutputStream

class User implements Serializable{//如果要实现对象序列化，必须实现Serializable
	private static final long serialVersionUID=1l;//如果要序列化与反序列化，最好指定serialVersionUID的值，这样JVM就不会再根据类重新计算了
	private int age;
	private String name;
	private transient String sex;//针对不想序列化的字段，需要加上transizent关键字，这样对象在序列化的时候，就不会将字段序列化
	public User(int age, String name, String sex) {
		super();
		this.age = age;
		this.name = name;
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}
	public static void main(String[] args) {
		try{//将对象序列化到文件中
		FileOutputStream fos=new FileOutputStream("E:\\io.txt");
		ObjectOutputStream os=new ObjectOutputStream(fos);
		os.writeObject(new User(11, "sb", "feman"));//在对象输出流中写入一个对象
		os.close();//这里只需要关闭外层的流，内层的FileOutputStream会自动关闭
		}catch (Exception e) {
			e.printStackTrace();
		}
		
		try{//将对象反序列化到内存中
			FileInputStream fis=new FileInputStream("E:\\io.txt");
			ObjectInputStream is=new ObjectInputStream(fis);
		    User user=(User)is.readObject();
		    System.out.println(user);
			is.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
}

运行结果，很显然，transient字段没有被序列化。

字符流

字符流的两个基类分别是Reader和Writer,都是抽象类，处理数据的基本单位是字符，存在字符乱码的情况。

Reader

Reader作为输入流的基类，其常用的API，包括如下：

CharArrayReader从Char数组读取数据。

PipedReader从其他线程管道中读取数据。

BufferedReader是字节缓冲流，用来实现高效的读取的。

InputStreamReader是用来连接字节流和字符流的桥梁，将字节流转化为字节流。

FileReader继承InputStreamReader，关联源文件，实现本地文件的读取。

FileReader

        FileReader reader=new FileReader("E:\\io.txt");
		char[] buf=new char[1024];
		int len;
		while((len=reader.read(buf))!=-1){
			System.out.println(new String(buf,0,len));
		}
		reader.close();

BufferedReader

字节输入缓冲流，主要用来高效读取字符的一种流，继承于Reader，实现文本，字符的高效读取。

FileReader reader=new FileReader("E:\\io.txt");
		BufferedReader buffReader=new BufferedReader(reader);//定义一个缓冲流对象
		String string=null;
		while((string=buffReader.readLine())!=null){
			//readLine()方法在实现上还是调用read()方法，一次读取一个字符，将字符读入到缓冲区中，例如：对于abc\r\n,
			//readLine()方法会依次读a,b,c到缓冲区，在window中一个换行包括两个字符，\r和\n，每到一行结束时都有这两个字符，但是他们不会被
			//读取到缓冲区中，当读到\n后，一行结束。
			System.out.println(string);

InputStreamReader

将字节输入流转化为字符输入流，是字节输入流转化为字符输入流的桥梁。

    //public InputStreamReader(InputStream is);
	//public InputStreamReader(InputStream is,String charset)指定编码的字符集

Writer

字符输出流，是所有字符输出流的基类，其常用的API如下：

FileWriter

文件字符输出流，继承Writer类，提供了文件输出的各个方法。

//构造方法
//public FileWriter(File file);
//public FileWirter(File file,boolean append);append为true时，在文件后追加；为false时，覆盖原文件内容。

FileReader reader=new FileReader("E:\\io.txt");
BufferedReader bufferedReader=new BufferedReader(reader);
FileWriter writer=new FileWriter("E:\\io2.txt");
BufferedWriter bufferedWriter=new BufferedWriter(writer);
String string=null;
while((string=bufferedReader.readLine())!=null){
		bufferedWriter.write(string);
		bufferedWriter.newLine();//插入换行符
		bufferedWriter.flush();//flush()方法可以强迫输出流(或缓冲的流)发送数据，即使此时缓冲区还没有填满，当然缓冲区一般情况下，在满的时候输出
		}
bufferedReader.close();
bufferedWriter.close();

OutputStreamWriter

将字节输出流转化为字符输出流，是字节输出流转化为字符输出流的桥梁。

//public InputStreamWriter(OutputStream is);
//public InputStreamWriter(OutputStream is,String charset)指定编码的字符集

PrintWriter

和PrintStream一样都是打印输出用的。在这里看一下PrintStream和PrintWriter的区别：

PrintStream：对OutputStream进行再次封装，使其可以打印出byte类型的其他数据，功能更加强大，其实System.out就是PrintStream

1、public PrintStream(File file) throws FileNotFoundException 构造方法通过一个File对象实例化PrintStream类

2、public PrintStream(OutputStream out) 构造方法接收OutputStream对象，实例化PrintStream类

3、public PrintStream printf(Locale l, String format, Object ...arg) 普通方法根据指定的Locale进行格式化输出

4、public PrintStream printf(String format,Object ... arg) 普通方法根据本地环境进行格式化输出

5、public void print(boolean b) 普通方法此方法被重载很多次，输出任意数据

6、public void println(boolean b) 普通方法此方法被重载很多次，输出任意数据后换行

PrintWriter:既可以对OutputStream封装，也可以对Writer字符流进行封装。

FileReader reader=new FileReader("E:\\io.txt");
		BufferedReader bufferedReader=new BufferedReader(reader);
		FileWriter writer=new FileWriter("E:\\io2.txt");
		PrintWriter printWriter=new PrintWriter(writer);
		String string=null;
		while((string=bufferedReader.readLine())!=null){
			/*bufferedWriter.write(string);
			bufferedWriter.newLine();//插入换行符*/	
			printWriter.println(string);//相当于注释上面的内容
			
		}
		bufferedReader.close();
		printWriter.close();
	
		
	}

当然io这一块还有很多人内容，慢慢学吧！

A coding monkey

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
javaIO总结

IO是input和output的缩写，主要用来做数据传输的。IO中的类非常多，内容庞大，采用合适的方式对其进行分类，将有助于我们记忆。先贴一张IO总体的结构图，额，内容有点多。。。IO分类字节流和字符流（按处理数据的基本单位）：字节流：处理数据时，以字节为基本单位，每次读入或者读出8位数据，可以操作任何类型的数据。字符流：处理数据时，以字符为基本单位，每次读入或者读出16位数...
复制链接

扫一扫