Java 基础之详解 Java IO

时间  2020-05-05
标签 java 基础 详解 栏目 Java 繁體版
原文   原文链接

Java IO 基本概念java

Java IO：即 Java 输入 / 输出系统。web

区分 Java 的输入和输出：把本身当成程序， 当你从外边读数据到本身这里就用输入（InputStream/Reader）， 向外边写数据就用输出（OutputStream/Writer）。面试

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

1，字节流：以 8 位（即 1 byte，8 bit）做为一个数据单元，数据流中最小的数据单元是字节。数组

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

IO 的分类网络

 

Java 基础之详解 Java IO

 

 

流式部分和非流式部分dom

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

1.流式部分：是 IO 的主体部分，也是本文介绍的重点， 流式部分根据流向分为输入流（InputStream/Reader）和输出流（OutputStream/Writer）， 根据数据不一样的操做单元，分为字节流（InputStream/OutputStream）和字符流（Reader/Writer），依据字节流和字符流，Java 定义了用来操做数据的抽象基类InputStream/OutputStream 和 Reader/Writer，再根据不一样应用场景（或功能），在这两种抽象基类上基于数据载体或功能派上出不少子类，用来知足文件，网络，管道等不一样场景的 IO 需求，从而造成了 Java 的基本 IO 体系。ide

下面是 Java IO 体系中经常使用的流类：

Java 基础之详解 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 和 BufferedInput Stream都是处理流，他们的的父类是 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 数组、和本地文件中写入数据。
  3. PipedOutputStream 是向与其它线程共用的管道中写入数据。
  4. 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 基础之详解 Java IO

 

 

Java IO 常见用法

一、读取键盘输入，打印到控制台 在刷题网站刷算法题的时候，在程序开头都须要和键盘进行交互，经常用到行夺取器 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();
 }
}

运行结果：

Java 基础之详解 Java IO

 

 

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

运行结果:

Java 基础之详解 Java IO

 

 

Java 基础之详解 Java IO

三、用字符流进行读写操做

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

运行结果:

Java 基础之详解 Java IO

 

 

Java 基础之详解 Java IO

 

 

（2）StringReader 和 StringWriter

public static void stringNode() throws IOException {
 StringReader sr =null;
 StringWriter sw =null;
 try {
 String str = "学习不刻苦
" + "不如卖红薯;
";
 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("黑夜给了我黑色的眼睛
");
 sw.write("我却用它寻找光明
");
 // toString()返回sw节点内的数据
 System.out.println(sw.toString());
 } catch (Exception e) {
 e.printStackTrace();
 }finally{
 sw.close(); 
 sr.close(); 
 }
}

运行结果：

Java 基础之详解 Java IO

 

 

四、字节流转换为字符流

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

运行结果:

Java 基础之详解 Java IO

 

 

五、随机读写文件 使用 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 + "
" + "pointerEnd:" + pointerEnd + "
" + new String(contents));
 randomAccessFile.seek(20);
 // 获取当前指针
 long begin = randomAccessFile.getFilePointer();
 randomAccessFile.write(contents);
 long end = randomAccessFile.getFilePointer();
 System.out.println("begin:" + begin + "
" + "end:" + end + "
");
 } catch (Exception e) {
 e.printStackTrace();
 }finally{
 randomAccessFile.close();
 }
}

运行结果:

操做前文件内容以下图：

Java 基础之详解 Java IO

 

 

操做后控制台打印信息：

Java 基础之详解 Java IO

 

 

操做后的文件内容：

Java 基础之详解 Java IO

 

 

六、读写管道

管道流要成对使用

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

运行结果:

Java 基础之详解 Java IO

 

 

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

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

运行结果:

Java 基础之详解 Java IO

 

 

Java 基础之详解 Java IO

 

 

八、推回输入流使用实例

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

运行结果:

Java 基础之详解 Java IO

 

 

Java 基础之详解 Java IO

 

 

Java IO 常见面试题

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

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

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

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

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

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

注意：处理流的构造器必需要 传入节点流的子类

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

  • 对象序列化：将对象以二进制的形式保存在硬盘上；
  • 反序列化：将二进制的文件转化为对象读取；
  • 实现 serializable 接口能够实现对象序列化，其中没有须要实现的方法，implements Serializable 只是为了标注该对象是可被序列化的。

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

四、什么是 Filter 流有哪些？

FilterStream 是一种 IO 流，主要做用是用来对存在的流增长一些额外的功能，像给目标文件增长源文件中不存在的行数，或者增长拷贝的性能等。在 java.io 包中主要由 4 个可用的 filter Stream。两个字节 filter stream，两个字符 filter stream.

分别是：FilterInputStream，FilterOutputStream，FilterReader and FilterWriter. 这些类是抽象类，不能被实例化的。

FilterInputStream 流的子类：

  • DataInputStream 能够把包括基本类型在内的数据和字符串按顺序从数据源读入，它有一些特殊的方法如 readInt()，readDouble() 和 readLine() 等能够读取一个 int，double 和一个 string。
  • BufferedInputStream 增长性能。
  • PushbackInputStream 推送要求的字节到系统中。
  • 注：其它子类见 Java io 分类图。

六、说说 RandomAccessFile?

它在 java.io 包中是一个特殊的类，既不是输入流也不是输出流，它二者均可以作到。他是 Object 的直接子类。一般来讲，一个流只有一个功能，要么读，要么写。可是 RandomAccessFile 既能够读文件，也能够写文件。

并且 RandomAccessFile 支持对文件的随机访问，实例可见上文：例 5，随机读写文件。

总结

不少初学者刚刚学习 java 的 IO 时会比较茫然，确实 IO 类不少，不容易记忆，不过咱们能够尝试对其进行总结记忆，把流式部分归纳为：两对应一桥梁一随机。

两个对应指：

  1. 字节流（Byte Stream）和字符流（Char Stream）的对应；
  2. 输入和输出的对应。
  3. 一个桥梁指：从字节流到字符流的桥梁。对应于输入和输出为InputStreamReader和OutputStreamWriter；
  4. 一个随机是：RandomAccessFile。能够随机读取文件。

总结记忆会使 Java io 清晰好记许多，你们也能够尝试按照本身的方式进行总结，印象会更加深

Java 基础之详解 Java IO
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程