Java之IO流总结

编程小6 Java (19) 2024-03-12 10:12

Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说Java之IO流总结,希望能够帮助你!!!。

　　序言-

　　第一次写博客，虽然工作1年了，一直没想起来去分享什么，后来听同事说，没事喜欢去写写博客，我觉得，作为一个程序员，应该具备分享精神，所以觉得从基础开始，给刚接触Java的同学，一点点小小i的帮助，也算给自己温故而知新的机会。

　　下面开始我们的Java学习之旅吧。

IO流
·Java流式输入/输出原理
·Java流类的分类
·输入/输出流类
·常见的节点流和处理流
·文件流
·缓冲流
·转换流
·数据流
·Print流
·Object流

①Java流式输入/输出原理

       00101...-->
   文件 ------------------ 程序

       <-- ...00101
   文件 ------------------ 程序

           00101...-->
   网络连接 ------------------ 程序

00101...-->
程序 ------------------ 程序

00101...--> “Hello”
文件 -----------============== 程序（从0101等转换为字符，一层包一层）

②流的分类
   java.io包中
       ·按数据流的方向不同可以分为输入流、输出流
       ·按处理数据单位不同可以分为字节流、字符流
       ·按照功能不同可以分为节点流、处理流

所有流类型位于包java.io内都分别继承以下四种抽象流类型

           字节流       字符流
   ------------------------------------------
   输入流          InputStream      Reader
   输出流          OutputSteam      Writer

字节流（8bit）

             |----FileInputStream(节点流)
             |
             |----PipedInputStream(节点流)   |---LineNumberInputStream(处理流)
             |                        |
             |----FilterInputStream(处理流)-------|---DataInputStream(处理流)
             |                   |
   InputStream -|----ByteArrayInputStream(节点流)    |---BufferedInputStream(处理流)
             |                   |---PushbackInputStream(处理流)
             |----SequenceInputStream(处理流)
             |
             |----StringBufferInputStream(节点流)
             |
             |----ObjectInputStream(处理流)

InputStream的基本方法
       //读取一个字节并以整数的形式返回（0-255）
       //如果返回-1已到输入流的末尾
   ·int read() throws IOExcetion

       //读取一系列字节并存储到一个数组buffer
       //返回实际读取的字节数，如果读取器前已到输入流的末尾返回-1
   ·int read(byre[] buffer) throws IOExcetion

       //读取length个字节
       //并存储到一个字节数组buffer，从length位置开始
       //返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
       //buffer - 读入数据的缓冲区。
       //offset - 数组 buffer 中将写入数据的初始偏移量。
       //length - 要读取的最大字节数。
   ·int read(byte[] buffer, int offset, int length) throws IOExcetion

//关闭流释放内存资源
·void close() throws IOExcetion

//跳过n个字节不读，返回实际跳过的字节数
·long skip(long n) throws IOExcetion

字节流（8bit）

             |----FileOutputStream(节点流)
             |
             |----PipedOutputStream(节点流)
             |                        |
             |----FilterOutputStream(处理流)-----|---DataOutputStream(处理流)
             |                   |
       OutputStream -|----ByteArrayOutputStream(节点流) |---BufferedOutputStream(处理流)
             |                   |---PrintStream(处理流)
             |
             |----ObjectOutputStream(处理流)

OutputStream的基本方法
       //向输出流中写入一个字节数据，该字节数据为参数b的低8位
   ·void write(int b) throws IOException

       //将一个字节类型的数组中的数据写入输出流
   ·void write(byre[] b) throws IOException

//将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
·void write(byre[] b, int off, int len) throws IOException

//关闭流释放内存资源
·void close() throws IOException

//将输出流中缓冲的数据全部写出到目的地
·void flush() throws IOException

注意：先flush，在close

字符流（16bit）

Reader的基本方法
       //读取一个字符并以整数的形式返回（0-255）
       //如果返回-1已到输入流的末尾
   ·int read() throws IOExcetion

       //读取一系列字符并存储到一个数组buffer
       //返回实际读取的字符数，如果读取器前已到输入流的末尾返回-1
   ·int read(byre[] buffer) throws IOExcetion

       //读取length个字符
       //并存储到一个字符数组buffer，从length位置开始
       //返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
       //buffer - 读入数据的缓冲区。
       //offset - 数组 buffer 中将写入数据的初始偏移量。
       //length - 要读取的最大字符数。
   ·int read(byte[] buffer, int offset, int length) throws IOExcetion

//关闭流释放内存资源
·void close() throws IOExcetion

//跳过n个字符不读，返回实际跳过的字节数
·long skip(long n) throws IOExcetion

字符流（16bit）

Writer的基本方法
       //向输出流中写入一个字符数据，该字节数据为参数b的低8位
   ·void write(int b) throws IOException

       //将一个字符类型的数组中的数据写入输出流
   ·void write(char[] cbuf) throws IOException

//将一个字符类型的数组中的从指定位置（off）开始的len个字符写入到输出流
·void write(char[] cbuf, int off, int len) throws IOException

//将一个字符串中的字符写入到输出流
·void write(String string) throws IOException

//将一个字符串从offset开始的length个字符写入到输出流
·coid write(String string, int offset, int length) throws IOException

//关闭流释放内存资源
·void close() throws IOException

//将输出流中缓冲的数据全部写出到目的地
·void flush() throws IOException

③输入/输出流
   1、输出流跟输入流
   一切以程序为中心
       ·从文件到程序为输入流
       ·从程序到文件为输出流
   2、字节流和字符流
       ·字节（8bit）
       ·字符（16bit）
       ·一个字符等于2个字节
   3、节点流和处理流
       ·处理流是包在节点流的一层“管道”

④常见的节点流和处理流
   ·节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）
           节点流
       数据源 -------------------- 程序

   ·处理流是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能

           -->
       数据源 -------======== 程序

           <--
       程序 ============-------- 数据源

⑤节点流----文件流
   字符流            字节流
---------------------------------------
输入流   FileReader   FileInputStream
输出流   FileWriter   FileOutputStream

访问文件
从文件到程序，输入流
·使用FileInputStream

       public class Login{
   public static void main(String[] args){
       int b = 0;
       FileInputStream fis = null;
       try {
           //连接管道
           fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
       } catch (FileNotFoundException e) {
           System.out.println("error");
       }
       //读取数据
           try {
               while((b = fis.read())!= -1){
                   System.out.print((char)(b));

               }
               fis.close();
           } catch (IOException e) {
               System.out.println("error");
           }

   }
}
   显示结果
   package Demo01;

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

public class Login{
   public static void main(String[] args){
       int b = 0;
       FileInputStream fis = null;
       try {
           //????????
           fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
       } catch (FileNotFoundException e) {
           System.out.println("error");
       }
       //????????
           try {
               int num = 0;
               while((b = fis.read())!= -1){
                   System.out.print((char)(b));
               }
               fis.close();
           } catch (IOException e) {
               System.out.println("error");
           }

   }
}

   发现出现？？？？？，问题是汉字是一个字符（两个字节），用的是字节流，一个字节一个字节读取，
所有中文翻译不出来，改为Reader可以

   从程序到文件
   ·使用FileOutputStream
   package Demo01;

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

public class Login{
   public static void main(String[] args){
       int b = 0;
       FileInputStream fis = null;
       FileOutputStream fot = null;
       try {
           //连接管道
           fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
           fot = new FileOutputStream("C://Users//woshishabi//Desktop//test.txt");
       } catch (FileNotFoundException e) {
           System.out.println("error");
       }
       //读取数据
           try {
               while((b = fis.read())!= -1){
                   fot.write(b);
               }
               fis.close();
               fot.close();
           } catch (IOException e) {
               System.out.println("error");
           }

   }
}

桌面上多了一个Test.txt文本，

   ·使用FileReader：字符输入流，从文件到程序
       ......
   ·使用FileWriter：字符输出流，从程序到文件
       ......

⑥处理流----缓冲流
   ·缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，
同时增加了一些新的方法
   ·J2SDK提供了四种缓存流，其常用的构造方法为：
           //字符输入缓冲流
       BufferedReader(Reader in)
       BufferedReader(Reader in, int sz) //sz为自定义缓存区的大小

           //字符输出缓冲流
       BufferedWriter(Writer out)
       BufferedWriter(Writer out,int sz)

           //字节输入缓冲流
       BufferedInputStream(InputStream in)
       BufferedInputStream(InputStream in, int size)

           //字节输出缓冲流
       BufferedOutputStream(OutputStream out)
       BufferedOutputStream(OutputStream out, int size)

   ·缓冲输入流支持其父类的mark和reset方法    mark：直接从多少个字符开始读取 reset：回到刚才标记的点
   ·bufferedReader提供了readline方法用于读取一行字符串（以\r或\n分隔）
   ·bufferedWriter提供了newLine用于写入一个行分隔符
   ·对于输出的缓冲流，写出的数据会现在内存中缓存，使用flush方法将会使内存中的数据立刻写出

bufferedReader和bufferedWriter使用

package Demo01;

import java.io.BufferedInputStream;
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;

public class Login{
   public static void main(String[] args){
       try {
           //从文件写入数据
           BufferedReader br = new BufferedReader(new FileReader("G://Java2014Project//JavaDemo1//src//Demo01//Login.java"));
           BufferedWriter bw = new BufferedWriter(new FileWriter("C://Users//woshishabi//Desktop//Test.txt"));
           //从文件读取数据
           String s = null;
           while((s = br.readLine()) != null){
               System.out.println(s);
               bw.write(s);
               bw.newLine();
           }
           bw.flush();
           br.close();
           bw.close();
       }
           catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }

   }
}

⑦处理流----转换流
   ·InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
   ·InputStreamReader需要和InputStream“套接”
   ·OutputStream需要和OutputStream“套接”
   ·转换流在构造时可以指定其编码集合，例如
       InputStream isr = new InputStreamReader(System.in, "ISO8859_1");

范例：OutputStreamWriter

package Demo01;

public class Login{
   public static void main(String[] args){
       try {
           //将输出字节流转换为字符流
           OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt"));
           //向文件中输入字符串
           osw.write("sdfjaksldjflskdjflaskdjfsakjdf");
           //读取字符编码
           System.out.println(osw.getEncoding());
           osw.close();
           //在文本后面添加字符串，不覆盖，则true，否则写false，后面可以自定义编码
           osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt", true), "UTF-8");
           osw.write("qwqeqweqweqeq");
           System.out.println(osw.getEncoding());
           osw.close();
       }
           catch (IOException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }

       }
   }

范例：InputStreamReader

package Demo01;

public class Login{
   public static void main(String[] args){
       //从键盘读取数据
       InputStreamReader isr = new InputStreamReader(System.in);
       //字符输入缓冲流
       BufferedReader br = new BufferedReader(isr);
       String s = null;
       try {
           //读取一行字符
           s = br.readLine();
           while(s != null){
           if(s.equalsIgnoreCase("exit")){    //将一个字符串与另一个字符串比较，不考虑大小写
               break;
           }
           //将小写转换为大写
               System.out.println(s.toUpperCase());
               s = br.readLine();
           }
           br.close();

           }
       catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }

   }
}

⑧数据流----DataInputStream...
   ·DataInputStream 和 DataOutputStream 分别继承了InputStream 和 OutputStream，属于处理流，
需要分别套接在InputStream 和 OutputStream类型的节点流觞
   ·DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的Java原始数据类型（int、double等）
的方法
   ·DataInputStream 和 DataOutputStream 的构造方法为：
       ·DataInputStream（InputStream in）
       ·DataOutputStream（OutputStream out）

范例：使用DataInputStream 和 DataOutputStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
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;

public class Login{
   public static void main(String[] args){
       //一个字节数组输出流
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       //在字节数组输出流上套接一个数据流，能传递基本数据类型
       DataOutputStream dos = new DataOutputStream(baos);
       try {
           //向字节数组写入一个随机数
           dos.writeDouble(Math.random());
           dos.writeBoolean(true);
           //创建一个字节数组输入流
           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
           //输出字节数组中有多少个字节
           System.out.println(bais.available());
           //将处理流包在字节数组输入流上，输出基本数据
           DataInputStream dis = new DataInputStream(bais);
           //输出double，先输入的先输出
           System.out.println(dis.readDouble());
           //输出boolean
           System.out.println(dis.readBoolean());
           dos.close();
           dis.close();
       } catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }
}

⑨print流   PrintStream主要操作byte流，而PrintWriter用来操作字符流
   ·PrintWriter 和 PrintStream都属于输出流，分别针对与字符和字节
   ·PrintWriter 和 PrintStream提供了重载的print
   ·Println方法用于多种数据类型的输出
   ·PrintWriter 和 PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息
   ·PrintWriter 和 PrintStream有自动flush功能
构造方法：
   ·PrintWriter(Writer out)
   ·PrintWriter(Writer out，boolean autoFlush)
   ·PrintWriter(OutputStream out， boolean autoFlush)
   ·PrintStream(OutputStream out)
   ·PrintStream(OutputStream out， boolean autoFlush)

范例：PrintStream
package Demo01;

public class Login{
   public static void main(String[] args){
       PrintStream ps = null;
       try {
           //文件字节输出流
           FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
           //输出流
           ps = new PrintStream(fos);
           if(ps != null){
               //使system.out指向了文件Test.txt
               System.setOut(ps);
           }
           for (int i = 0; i < 100; i++) {
               System.out.print(i + ",");
           }

       } catch (FileNotFoundException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }
}

范例：PrintWriter

package Demo01;

public class Login{
   public static void main(String[] args){
       String s = null;
       //从键盘输入，字节转字符的转换流上套接缓冲流
       BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
       try {
           //输出流，输出到文件，不覆盖
           FileWriter fw = new FileWriter("C://Users//woshishabi//Desktop//Test.txt",true);
           //输出流，套接在文件输出流上
           PrintWriter pw = new PrintWriter(fw);
           //接收键盘输入的一行数据，
           while((s = bis.readLine()) != null){
               //判断是否为exit，是则结束while
               if(s.equalsIgnoreCase("exit"))break;
               //小写转大写，在dos中输出
               System.out.println(s.toUpperCase());
               //在目标文件里面输出数据
               pw.println("------");
               pw.println(s.toLowerCase());
               pw.flush();
           }
           //在目标文件中输出日期
           pw.println("-----"+ new Date() + "------");
           pw.flush();
           pw.close();
       } catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }
}

⑩Object流
   ·直接将Object写入或读出
       ·transient关键字（透明的）：修饰属性， transient int k = 15;   输出结果k = 0；在序列化的时候不考虑，不写入硬盘
       ·serializable接口：（标记性接口，里面什么都没有）
       ·extemalizable接口：
   注意：如果需要使用对象流，必须实现serializable接口

范例：
package Demo01;

public class Login{
   public static void main(String[] args){
       T t = new T();
       t.k = 40;
       try {
           //文件输出流，
           FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
           //在文件输出流上套接一个对象输出流，从程序传递一个对象到目标文件中
           ObjectOutputStream oos = new ObjectOutputStream(fos);
           //写入对象
           oos.writeObject(t);
           //文件输入流，锁定目标文件
           FileInputStream fis = new FileInputStream("C://Users//woshishabi//Desktop//Test.txt");
           //在文件输入流上套接一个对象输入流，从目标文件中取出对象的通道
           ObjectInputStream ois = new ObjectInputStream(fis);

           //取出对象
           T t1 = (T) ois.readObject();
           //打印到屏幕上
           System.out.println(t1.i + " " + t1.j + " " + t1.k + " " + t1.z);
       } catch (ClassNotFoundException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }

}
}

class T implements Serializable{
   int i = 1;
   int j = 2;
   double z = 9.0;
   int k = 14;

}

总结：
·InputStream/OutputStream

·Reader/Writer

·FileInputStream/FileoutputStream

·FileReader/FileWriter

·BufferedInputStream/BufferedOutoutStream

·BufferedTeader/BufferedWriter

·ByteArrayInputStream/ByteArrayOutputStream

·InputStreamReader/OutputStreamWriter

·DataInputStream/DataOutputStream