Java流知识总结详解

Posted 2020-08-07 GreatAnt

流总结：

 

一、流的分类：

    数据单位：字节流  字符流

    方向：  输出流 输入流

    角色：  节点流 套节流

　 字节流：以Stream结尾。

    字符流：以Reader 和Writer 结尾。

    输入流：所有带有Input或者Reader。

    输出流：所有带有Output或者Writer。

    节点流：构造时传入文件对象或文件路径的类都是字节流类。

    处理流：构造时传入其他流的对象的类都是处理流类。

 

二、InputStream 是所有字节输入流的基类：

     最典型的实现是：FileInputStream

      最重要的三个方法：

　　int read() 从输入流中读取一个字节数据。

　　int read(byte[] b) 从输入流中将最多 b.length 个字节的数据读入 byte 数组 b 中。

　　int read(byte[] b, int off, int len) 从输入流中将最多 len 个字节的数据读入 byte 数组 b 中。

 

三、OutputStream 是所有字节输出流的基类:

     最典型的是：FileOutputStream

      最重要的三个方法：

　　void write(int b) 将指定的字节写入此输出流。

　　void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。

　　void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个 字节写入此输出流。

四、Reader

　　Reader 是所有字符输入流的基类

　　Reader 的典型实现时 FileReader 类     

 　　最重要的方法：

 　　int read() 从输入流中读取一个字符数据。

　　 int read(char[] c) 从输入流中将最多 c.length 个字符的数据读入 char 数组 c 中。

　　 int read(char[] c, int off, int len) 从输入流中将最多 len 个字符的数据读入 char 数组 c 中。

五、Writer

　　Writer 是所有字符输出流的基类。

　　1.Writer 的典型实现就是 FileWriter   最重要的方法：

　　void write(int c) 将指定的字符写入此输出流。

　　void write(char[] c) 将 c.length 个字符从指定的 char 数组写入此输出流。

　　void write(char[] c, int off, int len) 将指定 char 数组中从偏移量 off 开始的 len 个 字符写入此输出流。

　　void write(String s) 将字符串写入此输出流。

　　void write(String s, int off, int len) 将指定字符串中从偏移量 off 开始的 len 个 字符写入此输出流。

 

七、字节缓冲流：

　　BufferedInputStream（FileInputStream）

　　BufferedOutputStream(FileOutputStream)//括号里是举例

八、字符缓冲流：

　　BufferedReader(FileReader)

　　BufferedWriter(FileWriter)//括号里是举例

 

      缓冲流要套接在相应的节点流上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

九、转换流：

　　转换流提供了在字节流和字符流之间的转换。

　　InputStreamReader和OutputStreamWriter。

       InputStreamReader需要套接在InputStream对象上操，

　　 OutputStreamWriter需要套接在OutputStream对象上操作

      构造方法：

　　　　 InputStreamReader(InputStream)

            InputStreamReader(InputStream,String charsetName)

            OutputStreamWriter(OutputStream)

            OutputStreamWriter(OutputStream,String charsetName)

     转换流通常在操作系统非默认的字符（并且明确知道文件的字符编码）编码文件时使用。

十、流的关闭

  　　流的对象是不作为 Java 虚拟机垃圾回收处理的对象的，所以需要手动关闭流。

  　　流的对象在使用完之后必须调用流对象的 close()方法来关闭流，释放堆内存（heap）。

十一、为什么Gc回收不了流对象？

       垃圾回收是Java中自动内存管理的另一种叫法。垃圾回收的目的是为程序保持尽可能多的可用堆（heap）。 JVM会删除堆上不再需要从堆引用的对象。   　　

       Gc是主要清理内存，但close方法还要释放掉一些系统资源，比如硬盘读写所使用的资源。如果没有close，程序还是在运行，Gc不把它当成垃圾，回收不了。

   　  如果一个流不关闭会产生一些额外问题。比如说锁定了某种资源。如果你用流打开了一个文件，没有关闭的话，这个文件就不能再被操作。会提示有程序在操作这个文件。而且也会占         用系统句柄。

　　 缓冲流的关闭 ：关闭缓冲流，那么会自动关闭它所包装的底层节点流。

十二、字节流和字符流的应用

 　　1.在处理视频，音频，图片等二进制数据文件是使用字节流。

 　　2.在处理文本文件等字符文件时使用字符流。

十三、缓冲流通过减少调用本地 API 的次数来优化的输入和输出。

 　　 因为：

     　　使用非缓冲 I/O。这意味着每次读或写请求是由基础 OS 直接处理。这可以使一个程序效率非常低下，因为每个这样的请求通常引发磁盘访问，网络活动，

　　　  或一些其它的操作，而这些是相对昂贵的。

十四、flush()方法：

　　1.在调用缓冲输出流的 write 方法时并没有把数据写入文件，而是从内存缓冲进入了输出流中，通过调用缓冲输出流的 flush 方法可以强制把输出流中的数据输出到文件中。

　　2.缓冲输出流调用 close 方法时会先进行 flush 操作再关闭流。 

举例：

  例一：输入流

package com.hpe.test2;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class TestInputStream {

    public static void main(String[] args) {
    File file = new File("src/abc.txt");
    FileInputStream  fis =null;
    try {
        fis=new FileInputStream(file);
        int b=0;
            while((b=fis.read())!=-1){
                System.out.print((char)b);
            }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        try {
            fis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
  }
}

 例二：输出流

 

package com.hpe.test2;

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

public class TestOutputStream {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String src = "src/aaa.txt";
        String target = "src/bbb.txt";
        fileCopyByStream(src,target);
        fileCopyByStreamArray(src,target);
    }
    public static void fileCopyByStream(String srcFile,String targetFile){
        File file=new File(srcFile);
        File file1 = new File(targetFile);
        FileInputStream fis =null;
        FileOutputStream fos=null;
        try {
            int b;
            fis = new FileInputStream(file);
            fos=new FileOutputStream(file1);
            while((b=fis.read())!=-1){
                fos.write(b);
            }
            fos.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }    
        }
    }
    public static void fileCopyByStreamArray(String srcFile,String targetFile){    
        File file=new File(srcFile);
        File file1 = new File(targetFile);
        FileInputStream fis =null;
        FileOutputStream fos=null;
        try {        
           int length;
            byte[] b=new byte[10];
            fis = new FileInputStream(file);
            fos=new FileOutputStream(file1);
            while((length=fis.read(b))!=-1){
                fos.write(b,0,length);
            }
            fos.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                fis.close();//关闭流
                fos.close();//关闭流

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

 

 

 

例三：文件复制四种方法效率比较

package com.hpe.test2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestFileCopy {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String src = "D:/aaa/abc.rar";
        String target1 = "D:/bbb/cba1.rar";
        String target2 = "D:/bbb/cba2.rar";
        String target3 = "D:/bbb/cba3.rar";
        String target4 = "D:/bbb/cba4.rar";
        
        long start = System.currentTimeMillis();
        fileCopyByStream(src,target1);
        long end = System.currentTimeMillis();
        System.out.println("执行时间为" + (end - start) + "毫秒");
        
        start = System.currentTimeMillis();
        fileCopyByStreamArray(src,target2);
        end = System.currentTimeMillis();
        System.out.println("执行时间为" + (end - start) + "毫秒");

        start = System.currentTimeMillis();
        fileCopyByBufferStream(src,target3);
        end = System.currentTimeMillis();
        System.out.println("执行时间为" + (end - start) + "毫秒");

        start = System.currentTimeMillis();
        fileCopyByBufferStreamArray(src,target4);
        end = System.currentTimeMillis();
        System.out.println("执行时间为" + (end - start) + "毫秒");
    }

    public static void fileCopyByStream(String srcFile, String targetFile){
        
        File file = new File(srcFile);
        File file1 = new File(targetFile);
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file);
            fos = new FileOutputStream(file1);
            int b = 0;
            while((b = fis.read()) != -1){
//                System.out.print((char)b);
                fos.write(b);
            }
            fos.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    public static void fileCopyByStreamArray(String srcFile, String targetFile){
        
        File file = new File(srcFile);
        File file1 = new File(targetFile);
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file);
            fos = new FileOutputStream(file1);
            int len = 0;
            byte[] b = new byte[1024];
            while((len = fis.read(b)) != -1){
//                System.out.print((char)b);
                fos.write(b,0,len);
            }
            fos.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    public static void fileCopyByBufferStream(String srcFile, String targetFile){
        
        File file = new File(srcFile);
        File file1 = new File(targetFile);
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(file);
            fos = new FileOutputStream(file1);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            int b = 0;
            while((b = bis.read()) != -1){
//                System.out.print((char)b);
                bos.write(b);
            }
            bos.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fos.close();
                bis.close();
                bos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    public static void fileCopyByBufferStreamArray(String srcFile, String targetFile){
        
        File file = new File(srcFile);
        File file1 = new File(targetFile);
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(file);
            fos = new FileOutputStream(file1);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            int len = 0;
            byte[] b = new byte[1024];
            while((len = bis.read(b)) != -1){
//                System.out.print((char)b);
                bos.write(b,0,len);
            }
            bos.flush();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fis.close();
                fos.close();
                bis.close();
                bos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}