Java中IO流(Stream)分类介绍和基础使用

超、凢脫俗 2023-03-01 06:28 23阅读 0赞

## Java中IO流(Stream)分类介绍和基础使用 ##

##### 一、Java流的分类 #####

**1. 输入流和输出流**  
**1.1 输入流**  
数据从各种输入设备（包括文件、键盘等）中流向程序的流。所有输入流类都是 InputStream 抽象类（字节输入流）和 Reader 抽象类（字符输入流）的子类。其中 InputStream 类是字节输入流的抽象类，是所有字节输入流的父类。

**1.2输出流**  
数据从程序流向各种输出设备的流。所有输出流类都是 OutputStream 抽象类（字节输出流）和 Writer 抽象类（字符输出流）的子类。其中 OutputStream 类是字节输出流的抽象类，是所有字节输出流的父类。

--------------------

**2.字符流和字节流**  
**2.1字符流**  
Java中的字符流处理的最基本的单元是Unicode码元（大小为2个字节），字符流使用缓冲区。它通常用来处理文本数据，例如文件读取操作等等。

**2.2字节流**  
Java中的字节流处理的最基本单位为1个字节，字节流默认不使用缓冲区。它通常用来处理二进制数据，用于视频，图片读取等等。

--------------------

**3.节点流和处理流**  
按照流是否直接与特定的地方(如磁盘、内存、设备等)相连，分为节点流和处理流两类。  
**3.1结点流**  
可以从或向一个特定的地方(节点)读写数据。

**3.2处理流**  
是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。

--------------------

##### 二、java基本流的使用方法（InputStream、OutputStream 、Reader 、Writer ） #####

我们先来看一下java四个基本流的关系

<table> 
 <thead> 
  <tr> 
   <th>抽象类</th> 
   <th>输入流</th> 
   <th>输出流</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字符流</td> 
   <td>Reader</td> 
   <td>Writer</td> 
  </tr> 
  <tr> 
   <td>字节流</td> 
   <td>InputStream</td> 
   <td>OutputStream</td> 
  </tr> 
 </tbody> 
</table>

--------------------

以上四个流都是抽象类的流，然后我们来依次学习一下这四个流的使用方法

--------------------

**1、Reader流**  
输入流中的基本方法说明:

<table> 
 <thead> 
  <tr> 
   <th align="left"> 
    <div>
      方法名及返回类型 
    </div></th> 
   <th align="left"> 
    <div>
      方法说明 
    </div></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">int read()</td> 
   <td align="left">从输入流中读取一个字符，并把它转换为 0~65535 的整数。如果返回 -1，则表示已经到了输入流的末尾。</td> 
  </tr> 
  <tr> 
   <td align="left">int read(char[] cbuf)</td> 
   <td align="left">从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。 该方法返回读取的字符数，如果返回 -1，则表示已经到了输入流的末尾</td> 
  </tr> 
  <tr> 
   <td align="left">int read(char cbuf[], int offset, int length)</td> 
   <td align="left">从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。offset 指定在字符数组中开始保存数据的起始下标，length指定读取的字符数。该方法返回实际读取的字符数，如果返回 -1，则表示已经到了输入流的末尾</td> 
  </tr> 
 </tbody> 
</table>

***1.1 Reader流之FileReader***  
FileReader类的构造方法有如下两种重载方式：  
1.FileReader(String fileName)： fileName 表示要从中读取数据的文件的名称，表示的是一个文件的完整路径，然后在给定这个文件名的情况下创建一个FileReader对象。  
2.FileReader(File file)：file 表示要从中读取数据的文件，然后在给定要读取数据的文件的情况下创建一个新的 FileReader 对象。

在创建FileReader对象时，可能会触发FileNotFoundException异常，因此可以再方法中用try-catch捕获异常。

我们先来看一下demo1，demo2使用FileReader来读取文件内容

public void demo1()throws Exception{
        
            //创建FileReader对象
            FileReader fr=new FileReader("C:\\Users\\lenovo\\Desktop\\ReaderDemo.txt");
    
            //通过单个字符逐个读取
            int ch=fr.read();
            while(ch!=-1){
        
                System.out.print((char)ch);
                ch=fr.read();
            }
            System.out.println(" ");
    
            fr.close();
        }

public void demo2()throws Exception{
        
            //创建FileReader对象
            FileReader fr=new FileReader("C:\\Users\\lenovo\\Desktop\\ReaderDemo.txt");
    
            //通过数组读取文件
            char [] buf = new char[1024];
            int len=0;
            while((len=fr.read(buf))!=-1){
        
                System.out.print(new String(buf,0,len));
            }
            System.out.println(" ");
    
            fr.close();
        }

***1.2 Reader流之InputStreamReader***  
InputStreamReader：字节流通向字符流的桥梁,它将字节流转换为字符流.  
我们一起来看一下demo3，InputStreamReader是如何将字节流转化为字符流

public void demo3()throws Exception{
        
            //创建字节输入流FileInputStream
            FileInputStream fis=new FileInputStream ("C:\\Users\\lenovo\\Desktop\\ReaderDemo.txt");
    
            //创建字符输入流InputStreamReader，接收参数为字节流对象
            InputStreamReader isr=new InputStreamReader(fis,"utf-8");
            int ch=0;
            while((ch=isr.read()) != -1){
        
                System.out.print((char)ch);
            }
            System.out.println(" ");
            fis.close();
            isr.close();
    
        }

***1.3 Reader流之BufferedReader***  
BufferedReader：字符缓冲流，可以先把数据放到一个缓存区里，然后在进行处理。  
我们一起来看一下demo4，BufferedReader是如何使用的

public void demo4()throws Exception{
        
            //创建字节输入流FileInputStream
            FileInputStream fis=new FileInputStream ("C:\\Users\\lenovo\\Desktop\\ReaderDemo.txt");
    
            //创建字符输入流InputStreamReader
            InputStreamReader isr=new InputStreamReader(fis,"utf-8");
            //创建字符缓冲流BufferedReader
            BufferedReader br=new BufferedReader(isr);
            String line;
            while((line=br.readLine())!= null){
        
                System.out.println(line);
            }
            System.out.println(" ");
            br.close();
            fis.close();
            isr.close();
    
        }

--------------------

**2、Writer 流**  
输入流中的基本方法说明:

<table> 
 <thead> 
  <tr> 
   <th align="left"> 
    <div>
      方法名及返回类型 
    </div></th> 
   <th align="left"> 
    <div>
      方法说明 
    </div></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">void write(int c)</td> 
   <td align="left">向输出流中写入一个字符</td> 
  </tr> 
  <tr> 
   <td align="left">void write(char[] cbuf)</td> 
   <td align="left">把cbuf 字符数组中的所有字符写到输出流中</td> 
  </tr> 
  <tr> 
   <td align="left">void write(char cbuf[], int off, int len)</td> 
   <td align="left">把cbuf 指定的字符数组中的若干字符写到输出流中。其中，off 指定字符数组中的起始下标，len 表示元素个数</td> 
  </tr> 
  <tr> 
   <td align="left">void write(String str)</td> 
   <td align="left">向输出流中写入一个字符串</td> 
  </tr> 
  <tr> 
   <td align="left">void write(String str, int off, int len)</td> 
   <td align="left">向输出流中写入一个从off 开始，len个字符个数的字符串</td> 
  </tr> 
  <tr> 
   <td align="left">Writer append(CharSequence csq)</td> 
   <td align="left">将csq指定的字符序列添加到输出流中</td> 
  </tr> 
  <tr> 
   <td align="left">Writer append(CharSequence csq, int start, int end)</td> 
   <td align="left">将参数 csq指定的字符序列的子序列添加到输出流中。其中，start 指定子序列的第一个字符的索引，end 指定子序列中最后一个字符后面的字符的索引，包含start索引，不包含end索引</td> 
  </tr> 
  <tr> 
   <td align="left">Writer append(char c)</td> 
   <td align="left">将参数 c 的字符添加到输出流中</td> 
  </tr> 
  <tr> 
   <td align="left">void flush()</td> 
   <td align="left">刷新输出流，把数据马上写到输出流中</td> 
  </tr> 
 </tbody> 
</table>

***2.1 Writer流之FileWriter***  
FileWriter：文件字符输出流，该类对象调用write()方法将数据写入流中  
FileWriter在写入流时，如果文件不存在，则会自动创建对应的文件  
下面看一下demo1，学习一下FileWriter的使用

public void demo1()throws Exception{
        
            //创建FileWriter
            FileWriter fw=new FileWriter("C:\\Users\\lenovo\\Desktop\\WriterDemo.txt");
            //调用write()方法
            fw.write("Hellow world");
    
            char[] arr = {
        'J','a','v','a'};
            fw.write(arr);
    
            fw.write(arr,1,2);
    
            //关闭流
            fw.close();
        }

***2.2 Writer流之OutputStreamWriter***  
OutputStreamWriter：将字节流转换为字符流，是字节流通向字符流的桥梁。  
我们一起来看一下demo2，学习一下OutputStreamWriter是如何将字节流转化为字符流

public void demo2()throws Exception{
        
            //创建FileOutputStream字节流
            FileOutputStream fos=new FileOutputStream("C:\\Users\\lenovo\\Desktop\\WriterDemo.txt");
            //创建OutputStreamWriter字符输出流，将字节输出流转化为字符输出流
            OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
    
            //写入数据
            osw.write("Hellow world");
    
            //关闭流
            osw.close();
            fos.close();
    
        }

***2.3 Writer流之BufferedWriter***  
BufferedWriter：字符缓冲流，它利用了缓冲区来提高写的效率  
我们一起来看一下demo3，BufferedReader是如何使用的

public void demo3()throws Exception{
        
            //创建FileOutputStream字节流
            FileOutputStream fos=new FileOutputStream("C:\\Users\\lenovo\\Desktop\\WriterDemo.txt");
            //创建OutputStreamWriter字符输出流，将字节输出流转化为字符输出流
            OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
            //创建字符缓冲输出流
            BufferedWriter bw=new BufferedWriter(osw);
    
            //写入数据
            bw.write("Hellow world");
            bw.newLine();
            bw.write("Hellow");
    
            //关闭流
            bw.close();
            osw.close();
            fos.close();
    
        }

--------------------

**3、InputStream流**

***3.1 InputStream流之FileInputStream***  
FileInputStream：文件字节输入流，它除了可以使用基类定义的函数外,它还实现了基类的read()函数。  
下面我们看一下demo1，学习一下FileInputStream的使用

public void demo1()throws Exception{
        
            //创建字节输入流FileInputStream
            FileInputStream fis=new FileInputStream ("C:\\Users\\lenovo\\Desktop\\ReaderDemo.txt");
    
            byte[] bytes=new byte[1024];
            int len;
            while ((len=fis.read(bytes))!=-1)
                System.out.println(new String(bytes,0,len));
    		
    		fis.close();
        }

***3.2 InputStream流之BufferedInputStream***  
BufferedInputStream ：BufferedInputStream已经提前将数据封装到内存中，内存中操作数据要快，所以它的效率要要非缓冲的要高  
下面我们看一下demo2，学习一下BufferedInputStream的使用

public void demo2()throws Exception{
        
            //创建字节输入流FileInputStream
            FileInputStream fis=new FileInputStream ("C:\\Users\\lenovo\\Desktop\\ReaderDemo.txt");
    
            //创建字节输入缓冲流BufferedInputStream
            BufferedInputStream bis=new BufferedInputStream(fis);
            byte[] bytes=new byte[1024];
            int len;
            while ((len=bis.read(bytes))!=-1)
                System.out.println(new String(bytes,0,len));
    
            bis.close();
            fis.close();
        }

--------------------

**4、OutputStream流**

***4.1 OutputStream流之FileOutputStream***  
FileOutputStream：是用于写文件的输出流，它需要一个文件作为实例化参数，如果文件不存在则自动创建  
下面我们看一下demo1，学习一下FileOutputStream的使用

public void demo1()throws Exception{
        
            //创建字节输出流FileOutputStream
            FileOutputStream fos=new FileOutputStream("C:\\Users\\lenovo\\Desktop\\WriterDemo.txt");
            //写入数据
            fos.write("Hellow world".getBytes());
    
            //关闭流
            fos.close();
        }

***4.2 OutputStream流之BufferedOutputStream***  
BufferedOutputStream：也是从缓存中操作数据，所以效率非常高  
下面我们看一下demo2，学习一下BufferedOutputStream的使用

public void demo2()throws Exception{
        
            //创建字节输出流FileOutputStream
            FileOutputStream fos=new FileOutputStream("C:\\Users\\lenovo\\Desktop\\WriterDemo.txt");
    
            //创建字节输出缓冲流BufferedOutputStream
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            //写入数据
            bos.write("Hellow world".getBytes());
            
            //关闭流
            bos.close();
            fos.close();
        }

--------------------

以上就是java中各种流的介绍及使用了，这里基本包含了java常用的所有流，希望大家看了能有收获^\_^