Java IO基本概念

Java IO：即Java输入/输出系统，区分Java的输入和输出：把自己当成程序， 当你从外边读数据到自己这里就用输入（InputStream/Reader）, 向外边写数据就用输出（OutputStream/Writer）。

Stream：Java中将数据的输入输出抽象为流，流是一组有顺序的，单向的，有起点和终点的数据集合，就像水流。按照流中的最小数据单元又分为字节流和字符流。

1. 字节流：以8位（即1byte, 8bit)作为一个数据单元，数据流中最小的数据单元是字节
2. 字符流：以16位（即1char, 2byte, 16bit)作为一个数据单元，数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。

IO的分类

流式部分和非流式部分

Java的IO主要包含两个部分：

1. 流式部分：是IO的主体部分，也是本文介绍的重点，
   
   流式部分根据流向分为输入流（InputStream/Reader）和输出流（OutputStream/Writer），
   
   根据数据不同的操作单元，分为字节流（InputStream/OutputStream）和字符流（Reader/Writer），依据字节流和字符流，Java定义了用来操作数据的抽象基类InputStream/OutputStream 和 Reader/Writer，再根据不同应用场景（或功能），在这两种抽象基类上基于数据载体或功能派上出很多子类，用来满足文件，网络，管道等不同场景的IO需求，从而形成了Java的基本IO体系。
   
   下面是Java IO体系中常用的流类：
   
   
2. 非流式部分：主要包含一些辅助流式部分的类，如：SerializablePermission类、File类、RandomAccessFile类和FileDescriptor等；

节点流和处理流

Java io分类方式有很多，根据是否直接处理数据，Java io又分为节点流和处理流，节点流是真正直接处理数据的；处理流是装饰加工节点流的。

节点流

• 文件流：FileInputStream，FileOutputStrean，FileReader，FileWriter，它们都会直接操作文件，直接与OS底层交互。因此他们被称为节点流 ，注意：使用这几个流的对象之后，需要关闭流对象，因为java垃圾回收器不会主动回收。不过在Java7之后，可以在 try() 括号中打开流，最后程序会自动关闭流对象，不再需要显示地close。
• 数组流：ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，CharArrayWriter，对数组进行处理的节点流；
• 字符串流：StringReader，StringWriter，其中StringReader能从String中读取数据并保存到char数组。
• 管道流：PipedInputStream，PipedOutputStream，PipedReader，PipedWrite，对管道进行处理的节点流。

处理流

处理流是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。

常用处理流（通过关闭处理流里面的节点流来关闭处理流）

• 缓冲流 ：BufferedImputStrean，BufferedOutputStream，BufferedReader ，BufferedWriter，需要父类作为参数构造，增加缓冲功能，避免频繁读写硬盘，可以初始化缓冲数据的大小，由于带了缓冲功能，所以就写数据的时候需要使用flush方法，另外，BufferedReader提供一个readLine()方法可以读取一行，而FileInputStream和FileReader只能读取一个字节或者一个字符，因此BufferedReader也被称为行读取器。
• 转换流：InputStreamReader，OutputStreamWriter，要inputStream 或OutputStream作为参数，实现从字节流到字符流的转换，我们经常在读取键盘输入(System.in)或网络通信的时候，需要使用这两个类。
• 数据流：DataInputStream，DataOutputStream，提供将基础数据类型写入到文件中，或者读取出来。

字节流

字节输入流

下面是IO中输入字节流的继承关系。

InputStream

•    ByteArrayInputStream
  
  

•    FileInputStream
  
  

•    FilterInputStream
  
  

•    * PushbackInputStream
  
  

•    * DataInputStream
  
  

•    * BufferedInputStream
  
  

•    LineNumberInputStream
  
  

•    ObjectInputStream
  
  

•    PipedInputStream
  
  

•    SequenceInputStream
  
  

•    StringBufferInputStream
  
  

总结：

1. InputStream是所有的输入字节流的父类，它是一个抽象类。
2. PushbackInputStream、DataInputStream和BufferedInputStream都是处理流，他们的的父类是FilterInputStream。
3. ByteArrayInputStream、StringBufferInputStream、FileInputStream是三种基本的介质流，它们分别从Byte数组、StringBuffer、和本地文件中读取数据。PipedInputStream是从与其它线程共用的管道中读取数据。

InputStream中的三个基本的读方法

abstract int read() ：读取一个字节数据，并返回读到的数据，如果返回-1，表示读到了输入流的末尾。

int read(byte[] b) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。

int read(byte[] b, int off, int len) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放数据的起始偏移位置；len指定读取的最大字节数。

字节输出流

下面是IO中输出字节流的继承关系。

OutputStream

• ByteArrayOutputStream
• FileOutputStream
• FilterOutputStream
• • BufferedOutputStream
• • DataOutputStream
• • PrintStream
• ObjectOutputStream
• PipedOutputStream
  
  总结：

1. OutputStream是所有的输出字节流的父类，它是一个抽象类。
2. ByteArrayOutputStream、FileOutputStream是两种基本的介质流，它们分别向Byte数组、和本地文件中写入数据。PipedOutputStream是向与其它线程共用的管道中写入数据，
3. BufferedOutputStream、DataOutputStream和PrintStream都是处理流，他们的的父类是FilterOutputStream。

outputStream中的三个基本的写方法

• abstract void write(int b)：往输出流中写入一个字节。
  
  

• void write(byte[] b) ：往输出流中写入数组b中的所有字节。
  
  

• void write(byte[] b, int?off, int?len) ：往输出流中写入数组b中从偏移量off开始的len个字节的数据。
  
  

其它重要方法：

• void flush() ：刷新输出流，强制缓冲区中的输出字节被写出。
• void close() ：关闭输出流，释放和这个流相关的系统资源。

字节流的输入与输出的对应

java io的输入和输出是高度对应的，下图表示字节流的输入与输出的对应关系。



上图中蓝色的为主要的对应部分，红色的部分是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。

我们主要看看这些字节流中不对称的几个类：

1. PushbackInputStream 为另一个输入流添加性能，即“推回 (push back)”或“取消读取 (unread)”一个字节的能力。
2. SequenceInputStream可以认为是一个工具类，将两个或者多个输入流当成一个输入流依次读取。完全可以从IO包中去除，还完全不影响IO包的结构。
3. PrintStream也可以认为是一个辅助工具。主要可以向其他输出流，或者FileInputStream写入数据，本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO包！System.io和System.out就是PrintStream的实例！
4. StringBufferInputStream和StringBufferInputStream已经过时，还允许它存在只是为了保持版本的向下兼容而已。

搭配使用的三对类：

ObjectInputStream/ObjectOutputStream和DataInputStream/DataOutputStream主要是要求写对象/数据和读对象/数据的次序要保持一致，否则可能不能得到正确的数据，甚至抛出异常(一般会如此)；PipedInputStream/PipedOutputStream在创建时一般就一起创建，调用它们的读写方法时会检查对方是否存在，或者关闭！

字符流

字符输入流Reader

下面是IO中输入字符流的继承关系。

Reader

• BufferedReader
• LineNumberReader
• CharArrayReader
• FilterReader
• • PushbackReader
• InputStreamReader
• FileReader
• PipedReader
• StringReader
  
  总结：

1. Reader是所有的输入字符流的父类，它是一个抽象类。
2. CharReader、StringReader是两种基本的介质流，它们分别将Char数组、String中读取数据。PipedReader是从与其它线程共用的管道中读取数据。
3. BufferedReader很明显就是一个装饰器，它和其子类负责装饰其它Reader对象。
4. FilterReader是所有自定义具体装饰流的父类，其子类PushbackReader对Reader对象进行装饰，会增加一个行号。
5. InputStreamReader是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。

Reader基本的三个读方法（和字节流对应）：

(1) public int read() throws IOException; 读取一个字符，返回值为读取的字符

(2) public int read(char cbuf[]) throws IOException; 读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量

(3) public abstract int read(char cbuf[],int off,int len) throws IOException; 读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现

字符输出流Writer

下面是IO中输出字符流的继承关系。

Writer

• BufferedWriter
• CharArrayWriter
• FilterWriter
• OutputStreamWriter
• FileWriter
• PipedWriter
• PrintWriter
• StringWriter
  
  总结（和字节输出流对应）：

1. Writer是所有的输出字符流的父类，它是一个抽象类。
2. CharArrayWriter、StringWriter是两种基本的介质流，它们分别向Char数组、String中写入数据。PipedWriter是向与其它线程共用的管道中写入数据，
3. BufferedWriter是一个装饰器为Writer提供缓冲功能。
4. PrintWriter和PrintStream极其类似，功能和使用也非常相似。
5. OutputStreamWriter是OutputStream到Writer转换的桥梁，它的子类FileWriter其实就是一个实现此功能的具体类。

writer的主要写方法：

(1) public void write(int c) throws IOException； //写单个字符

(2) public void write(char cbuf[]) throws IOException； //将字符数组cbuf[]写到输出流

(3) public abstract void write(char cbuf[],int off,int len) throws IOException； //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流

(4) public void write(String str) throws IOException； //将字符串str中的字符写入输出流

(5) public void write(String str,int off,int len) throws IOException； //将字符串str 中从索引off开始处的len个字符写入输出流

字符流的输入与输出的对应

可参照（字节流的输入与输出的对应）记忆

Java IO常见用法

1、读取键盘输入，打印到控制台

在刷题网站刷算法题的时候，在程序开头都需要和键盘进行交互，用到的就是行夺取器BufferedReader和转换流InputStreamReader。

public static void keyInAndPrintConsole() throws IOException {

		PrintWriter out = null;

		BufferedReader br = null;

		try{

			System.out.println("请输入:");

			out = new PrintWriter(System.out, true);

			br = new BufferedReader(new InputStreamReader(System.in));

			String line = null;

			while ((line = br.readLine()) != null) {

				if (line.equals("exit")) {

				    System.exit(1);

				}

				out.println(line);

			}

		} catch (IOException e) {

			e.printStackTrace();

		}finally{

			out.close();

			br.close();

		}

}

运行结果：



2 、用字节流读写文件

因为是用字节流来读媒介，所以对应的是InputStream和OutputStream而且媒介对象是文件，所以用到子类是FileInputStream和FileOutputStream，这里还可以通过BufferedInputStream用缓冲流来读取文件。

	public static void readAndWriteByteToFile() throws IOException {

        InputStream is =null;

        OutputStream os = null;

        try {

        	// 在try()中打开文件会在结尾自动关闭

			is = new FileInputStream("D:/FileInputStreamTest.txt");

			os = new FileOutputStream("D:/FileOutputStreamTest.txt");

			byte[] buf = new byte[4];

			int hasRead = 0;

			while ((hasRead = is.read(buf)) > 0) {

				os.write(buf, 0, hasRead);

			}

			System.out.println("write success");

        } catch (Exception e) {

            e.printStackTrace();

        }finally{

            os.close();

            is.close();

        }

    }

运行结果:

3、用字符流进行读写操作

（1）FileReader和FileWriter

	// 在try() 中打开的文件， JVM会自动关闭

	public static void readAndWriteCharToFile() throws IOException{

		Reader reader = null;

		Writer writer =null;

		try {

			File readFile = new File("d:/FileInputStreamTest.txt");

			reader = new FileReader(readFile);

			File writeFile = new File("d:/FileOutputStreamTest.txt");

			writer = new FileWriter(writeFile);

			char[] byteArray = new char[(int) readFile.length()];

			int size = reader.read(byteArray);

			System.out.println("大小:" + size + "个字符;内容:" + new String(byteArray));

			writer.write(byteArray);

		} catch (Exception e) {

			e.printStackTrace();

		}finally{

			reader.close();

			writer.close();

		}

	}

运行结果:

（2）StringReader和StringWriter

public static void stringNode() throws IOException {

	StringReader sr =null;

	StringWriter sw =null;

	try {

		String str = "学习不刻苦\n" + "不如卖红薯;\n";

		char[] buf = new char[32];

		int hasRead = 0;

		// StringReader将以String字符串为节点读取数据

		sr = new StringReader(str);

		while ((hasRead = sr.read(buf)) > 0) {

			System.out.print(new String(buf, 0, hasRead));

		}

		// 由于String是一个不可变类，因此创建StringWriter时，实际上是以一个StringBuffer作为输出节点

		sw = new StringWriter();

		sw.write("黑夜给了我黑色的眼睛\n");

		sw.write("我却用它寻找光明\n");

		// toString()返回sw节点内的数据

		System.out.println(sw.toString());

    } catch (Exception e) {

        e.printStackTrace();

    }finally{

		sw.close();

		sr.close();

    }

}

运行结果：



4、字节流转换为字符流

在5.3中用字符流读文件时，打印到控制台的中文会乱码，使用转换流可以解决这一问题

public static void convertByteToChar() throws IOException {

    InputStream is =null;

    Reader reader = null;

    try {

    	File file = new File("d:/FileInputStreamTest.txt");

		is = new FileInputStream(file);

		reader = new InputStreamReader(is,"gbk");

		char[] byteArray = new char[(int) file.length()];

		int size = reader.read(byteArray);

		System.out.println("大小:" + size + ";内容:" + new String(byteArray));

    } catch (Exception e) {

        e.printStackTrace();

    }finally{

    	reader.close();

        is.close();

    }

}

运行结果:



5、随机读写文件

使用RandomAccessFile可以实现对文件的随机读取，主要是通过seek（）方法实现指针偏移。

public static void randomAccessFileReadAndWrite() throws IOException {

	RandomAccessFile randomAccessFile =null;

    try {

    	// 创建一个RandomAccessFile对象

    	randomAccessFile = new RandomAccessFile("d:/File.txt", "rw");

		// 通过seek方法来移动指针

    	randomAccessFile.seek(10);

		// 获取当前指针

		long pointerBegin = randomAccessFile.getFilePointer();

		// 从当前指针开始读

		byte[] contents = new byte[10];

		randomAccessFile.read(contents);

		long pointerEnd = randomAccessFile.getFilePointer();

		System.out.println("pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" + new String(contents));

		randomAccessFile.seek(20);

		// 获取当前指针

		long begin = randomAccessFile.getFilePointer();

		randomAccessFile.write(contents);

		long end = randomAccessFile.getFilePointer();

		System.out.println("begin:" + begin + "\n" + "end:" + end + "\n");

    } catch (Exception e) {

        e.printStackTrace();

    }finally{

    	randomAccessFile.close();

    }

}

运行结果:

操作前文件内容如下图：



操作后控制台打印信息：



操作后的文件内容：



6、读写管道

管道流要成对使用

public static void piped() throws IOException {

	final PipedOutputStream output = new PipedOutputStream();

	final PipedInputStream input = new PipedInputStream(output);

	Thread thread1 = new Thread(new Runnable() {

		@Override

		public void run() {

			try {

				output.write("Hello world, pipe!".getBytes());

			} catch (IOException e) {

			}

		}

	});

	Thread thread2 = new Thread(new Runnable() {

		@Override

		public void run() {

			try {

				int data = input.read();

				while (data != -1) {

					System.out.print((char) data);

					data = input.read();

				}

			} catch (IOException e) {

			} finally {

				try {

					input.close();

				} catch (IOException e) {

					e.printStackTrace();

				}

			}

		}

	});

	thread1.start();

	thread2.start();

}

运行结果:



7、将多个输入流当成一个输入流依次读取

public static void sequeue() throws IOException {

	FileInputStream fistream1 =null;

	FileInputStream fistream2 =null;

	SequenceInputStream sistream =null;

	FileOutputStream fostream =null;

    try {

		 fistream1 = new FileInputStream("d:/A.txt");

	   	 fistream2 = new FileInputStream("d:/B.txt");

	   	 sistream = new SequenceInputStream(fistream1, fistream2);

	   	 fostream = new FileOutputStream("d:/C.txt");

	   	 int temp;

	   	 while( ( temp = sistream.read() ) != -1) {

	   		System.out.print( (char) temp );

	   	 	fostream.write(temp);

	   	 }

    } catch (Exception e) {

        e.printStackTrace();

    }finally{

		fostream.close();

		sistream.close();

		fistream1.close();

		fistream2.close();

    }

}

运行结果:

8、推回输入流使用实例

public static void pushback() throws FileNotFoundException, IOException {

	try (PushbackReader pr = new PushbackReader(new FileReader("D:/A.txt"), 64)) {

		char[] buf = new char[32];

		String lastContent = "";

		int hasRead = 0;

		while ((hasRead = pr.read(buf)) > 0) {

			String content = new String(buf, 0, hasRead);

			int targetIndex = 0;

			if ((targetIndex = (lastContent + content).indexOf("A")) > 0) {

				System.out.println(targetIndex);

				pr.unread((lastContent + content).toCharArray());

				if (targetIndex > 32) {

					buf = new char[targetIndex];

				}

				pr.read(buf, 0, targetIndex);

				System.out.println(new String(buf, 0, targetIndex));

				System.out.println(new String(buf, targetIndex, buf.length-targetIndex));

				System.exit(0);

			} else {

				System.out.println(lastContent);

				lastContent = content;

			}

		}

	} catch (IOException e) {

		e.printStackTrace();

	}

}

运行结果:

JavaIO常见面试题

1、字节流和字符流的区别？

（1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

（2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

（3）字节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。

2、什么是节点流,什么是处理流,它们各有什么用处,处理流的创建有什么特征？

见上文：节点流和处理流；

处理流的构造器必须要 传入节点流的子类

3、把包括基本类型在内的数据和字符串按顺序输出到数据源，或者按照顺序从数据源读入，一般用哪两个流？

DataInputStream DataOutputStream

4、什么叫对象序列化，什么是反序列化，实现对象序列化需要做哪些工作？

对象序列化：将对象以二进制的形式保存在硬盘上；

反序列化：将二进制的文件转化为对象读取；

实现serializable接口可以实现对象序列化，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。

例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输，被传输的对象就必须实现Serializable接口。

5、什么是Filter流 有哪些？

FilterStream是一种IO流，主要作用是用来对存在的流增加一些额外的功能，像给目标文件增加源文件中不存在的行数，或者增加拷贝的性能等。在java.io包中主要由4个可用的filter Stream。两个字节filter stream，两个字符filter stream. 分别是FilterInputStream, FilterOutputStream, FilterReader and FilterWriter.这些类是抽象类，不能被实例化的。

Filter流的子类：

• DataInputStream 有些特殊的方法如readInt(), readDouble()和readLine() 等可以读取一个 int, double和一个string。
• BufferedInputStream 增加性能
• PushbackInputStream 推送要求的字节到系统中

6、说说RandomAccessFile?

它在java.io包中是一个特殊的类，既不是输入流也不是输出流，它两者都可以做到。他是Object的直接子类。通常来说，一个流只有一个功能，要么读，要么写。但是RandomAccessFile既可以读文件，也可以写文件。 而且RandomAccessFile支持对文件的随机访问，实例可见上文：5.5随机读写文件。

总结

很多初学者刚刚学习java的IO时会比较茫然，确实IO类很多，不容易记忆，我们可以尝试对其进行总结记忆，把流式部分概括为：两个对应一个桥梁一个随机。

两个对应指：

1.字节流（Byte Stream）和字符流（Char Stream）的对应；

2.输入和输出的对应。

一个桥梁指：从字节流到字符流的桥梁。对应于输入和输出为InputStreamReader和OutputStreamWriter；

一个随机是：RandomAccessFile。可以随机读取文件。

参考

http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

https://blog.csdn.net/lgzaaron/article/details/52202443

https://blog.csdn.net/qq_25184739/article/details/51205186#

https://www.2cto.com/kf/201704/524652.html

https://blog.csdn.net/baobeisimple/article/details/1713797#t4

https://blog.csdn.net/lihuapiao/article/details/50731405

https://blog.csdn.net/zhuojiuyihu/article/details/7307567

最新文章

1. 当 IDENTITY_INSERT 设置为 OFF 时，不能向表 '#TT' 中的标识列插入显式值。 sql server 临时表
2. 前端技巧：禁止浏览器static files缓存篇（转）
3. React Native学习-measure测量view的宽高值
4. H.264的一些资料整理
5. S_OK与S_FALSE，E_FAIL
6. lucene索引合并与增量索引
7. java选择排序详解
8. 【Git】时光机命令—Git命令
9. 1、Nginx集群tomcat
10. h5内容初探
11. 如何判断一个请求为ajax请求？
12. PHP常亮
13. 关闭mac自带apache的启动。
14. Spring Boot（二）Application events and listeners
15. Android中的MVC，MVP和MVVM
16. 二 Istio设计的核心原则
17. 「LuoguP1429」 平面最近点对（加强版）
18. Python基础——类
19. MySQL高可用之——keepalived+互为主从
20. ATan2与ATan的区别

热门文章

1. 第 k 小的数
2. 新手必学linux文本文件编辑命令 vi vim.....
3. reuire代码优化之：r.js
4. Qt实现学生学籍管理系统（文件存储）
5. javascript入门 之 zTree（十三 移动/复制事件）
6. 8.1 api概述及使用
7. 好消息，vue3.0 进入 beta 阶段！
8. go中的error小结
9. AJ学IOS 之微博项目实战(2)微博主框架-自定义导航控制器NavigationController
10. Android UIAutomator自动化测试