java IO流详解

2016.08.22-2016.08.24

 

上课类容：IO流

 

请别和我说话，小心我一言不和就放图。好吧，如果作为一名初学者，我相信你看到下面这幅图，整个人就不好了。

 

 一看到这幅图，宝宝吓坏了，瞬间整个人就不好了。

请自行看3遍，谢谢！

下面我们再分别叙述一下字节流和字符流。

 

一：字节流

 

1.IO流体系：对数据进行读写操作，所以说IO流不是读就是写咯。

2.IO流相关的类：都在java.io包下。

   有关的io操作都会产生IOException异常。

3.IO:参照物是程序

   i:input.进来，读取数据到程序中。

   o:output:出去，将数据从程序中写出去。

再放一图

 
 

4：io流的分类，相关的类都会有相应的单词。

         4.1：从数据的流向分。个人理解为就是内存和硬盘之间的数据交换，内存上的数据是暂时性的，而硬盘上的数据是永久性的。

                   Input(输入):读取数据，数据往程序中流。或者说：将硬盘上的数据放到内存上

                   Output(输出):写出数据，将数据从程序中写出去。或者说：将内存上的数据放到硬盘上

         4.2：字节流和字符流

                   Stream:字节流，所有的数据都可以用字节流操作。计算机真正能识别的就是010101这些东西，8个0或者1组合成位，8位就是一个字节了。

                   Reader或者Writer:字符流。字符流是在字节流的基础上加了编码机制。只能对文字进行操作，虽说是文字，更贴切的说是文本文件，并不包括.doc等富文本文件，因为这些文件里面可以放图片或者其他的非文字内容。不能够对图片或者音频文件进行操作。

         InputSteam:读取字节流。OutputStream:输出字节流。

         Reader：读取字符流，   Writer:写出字符流。

5：文件字节流

         OutputStream,:抽象类  

                            文件输出字节流：FileOutputStream:节点流，跟目标设备相关联。

　　　　实例一：

 import java.io.FileOutputStream;
 import java.io.IOException;
 
 public class FileOutputStreamDemo1 {
      
     public static void main(String[] args) throws IOException {
        //1.创建文件输出流对象，参数为全路径名
         FileOutputStream fos = new FileOutputStream("e:\\aa.txt");
         //2.写出数据
         //2.1准备数据
         String str = "要写出的数据";
         //2.2将数据转为字节数组的形式
         byte[] b = str.getBytes();
         //3.0将数据按照一个个字节地写出目标文件中
         /*for(int i=0; i<b.length; i++){
             fos.write(b[i]);
         }*/
         //3.1以下是将整个数组输出去，和3.0可到达相同的效果
         fos.write(b);
         //4.释放资源
        fos.close();
     }
 
 }

 BufferedInputStream:处理流，必须先有节点流。为了增加效率。处理的方式是将节点流包装起来

public static void testBufferedOutputStream() throws IOException{
         //在使用带缓冲区的字节流的时候先要有一个节点流作为参数,或者说先指定一个目标文件
         FileOutputStream fos = new FileOutputStream("d:\\test.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
         
         //将以下文字写到目标文件中去
         String str = "这几个文字即将通过带缓冲区的字节流写到一个文本文件中";
         bos.write(str.getBytes());
         //写完之后记得要刷新才能真正写入到文件中，不然还会保存在缓冲区里，直到释放资源
         bos.flush();
         //释放资源（关闭流）
         bos.close();
         
     }

 InputStream：抽象类。

                            文件输入字节流：FileInputStream：节点流，和要读取那个文件关联起来

import java.io.FileInputStream;
import java.io.IOException;
 
 public class FileInputStreamDemo1 {
     public static void main(String[] args) throws IOException {
         //1.创建字节输入流对象
        FileInputStream fis = new FileInputStream("e:\\bb.txt");
        //2.开始读取数据
 //        System.out.println((char)fis.read());
         int b;
         while((b=fis.read())!=-1){
             System.out.print((char)b);
         }
         fis.close();
     }
 }

  BufferedOutputStream：带缓冲区的。也是为了增加效率，处理的方式是将节点流包装起来

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

/*
 * 将一个文件的文字输出到控制台
 */
public class BufferedInputStreamDemo1 {
    
    public static void main(String[] args) {
        
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        try {
            fis = new FileInputStream("d:\\aa.txt");
            bis = new BufferedInputStream(fis);
            //byte数组用来装读取到的数据
            byte[] b = new byte[1024];
            int len = -1;
            while((len = bis.read(b))!=-1){
                System.out.println(new String(b, 0, len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }

}

 

6：字节流：在文件系统中，任何文件都是以二进制形式存储的，二进制用位体现（8位为一个二进制单元），8位=1字节，所以字节流可以处理任何文件。

         6.1字节流常用的一些类：

                   6.1.1输入流read(), 读到末尾返回-1

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

                            FileInputStream：文件输入流

                            BufferedInputStream：带缓冲区的输入流，先要传入一个节点流（输入流）作为参数

                   6.1.2输出流write()

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

                            FileOutputStream：文件输入流

                            BufferedOutputStream：带缓冲区的输入流，先要传入一个节点流（输入流）作为参数

  结合输入输出流写一个文件复制的工具

public static boolean copyFile( String filePath,String target){
    
        boolean flag = false;
        //输出流,将数据写入到目标文件中
        FileOutputStream fos = null;
        //输入流，将要用的文本拿到程序中
        FileInputStream fis = null;
        //读取文本
        byte[] b = new byte[1024];
        //每次读取字符数据的有效长度
        int length = -1;
        
        try {
            fis = new FileInputStream(filePath);
            fos = new FileOutputStream(target);
            /*
             * fis.read(b):从fis关联的文件中每次读取 1024 个字节，
             * 并把读取到的字节数据保存这个数组里面，
             * 但是这个文件并不是只有1024 这个么大，有可能要读多次，所以要用循环
             * 寻到的条件是读到文件没有得读了，就是读到最后了就不读了，
             * 读到末尾的返回值是-1，如果返回值是-1则停止循环
             * 
             */
            while((length=fis.read(b)) != -1){//读到文件末尾就返回-1，不在往下读取
                //将读到的数据写入目标文件中
                fos.write(b, 0, length);
                fos.flush();//将数据刷到目标文件
            }
            System.out.println("文件复制成功！");
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            //关闭释放资源
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        flag = true;
        return flag;
    }

 

二.字符流

 

1.字符流：在字节流的基础上添加了编码机制。很大程度上和字节流操作一样的，字符流只能操作文本类文件，准确的说应该是纯文本类文件。例如.txt，.java，.cpp，.html等

                   编码：每一个国家都有自己的编码，编码不一致往往导致的结果就是！！乱码！！。中国编码的编码：gbk

                            gbk:英文字母：1个字节，中文：2个字节，系统的默认编码。

                            unicode:统一编码。中文还是英文字母都是占2个字节。

                            utf-8: 国际编码。英文占1个字节，中文占3个字节。

                            文件是用什么编码来写的，那么就用什么编码来读取。最常用的编码是gbk和utf-8.一般的情况下，都设置为utf-8.（还有其他的很多编码：例如GB2312,big5等等）。如果想测试是否像上面所说那么多个字节的话，建议使用Notepad2文本软件，体积小功能强！（似乎再买广告了。。。）

                   Reader:读取数据

                            FileReader:文件读取字符流

                            BufferedReader://带缓冲区的字符输入流

                                     readLine() ;读取一行数据

                                     LineNumberReader;带行号.通过getLineNumber()方法获取行号

 

带行号功能的字符输入流

 

 import java.io.FileReader;
 import java.io.IOException;
 import java.io.LineNumberReader;
 
 /*LineNumberReader是BufferedReader的子类，
  * 比BufferedReader多了设置行号和获取行号的功能。
  * 使用LineNumberReader流读取文本文件，并打印在控制台上。
  * 在每行的前面添加行号。
  */

 public class LineNumberReaderDemo1 {
     public static void main(String[] args) throws IOException {
         String str = null;
           while((str = lnr.readLine()) != null){
//            lnr.setLineNumber(90);//设置行号
             System.out.print(lnr.getLineNumber()+" : ");
            System.out.println(str);
        }
        lnr.clo

 

Writer:写入数据

                            FileWrite:写入数据，记得刷新。

                            BufferedWriter://带缓冲区的字符输出流

                                     newLine():写入换行字符。

 

                                     write(String str):写入字符串。

 

/*
     * 2:用字符流复制文本文件。
     */
    public static boolean copyText(String textPath, String targetPath){
        boolean flag = false;
        if(textPath==null || textPath.trim().equals("")){
            return flag;
        }
        if(targetPath == null || targetPath.trim().equals("")){
            int end = textPath.lastIndexOf(".");
            String endStr = textPath.substring(end);//后缀名
            int index = textPath.lastIndexOf("\\");
            if(index == 0){
                index = textPath.lastIndexOf("/");
            }
            targetPath = textPath.substring(0,end)+"2"+endStr;//新文件名
        }
        
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //字符输入流
            FileReader fr = new FileReader(textPath);
            br = new BufferedReader(fr);
            //字符输出流
            FileWriter fw = new FileWriter(targetPath);
            bw = new BufferedWriter(fw);
            
            String str = "";
            while((str=br.readLine()) != null){
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
            flag = true;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try{
                bw.close();
                br.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        return flag;
    }

  转换流：可带编码格式的流

 

                            InputStreamReader;字节转换为字符流

转换流示例

public class SystemReadDemo1 {
    
    public static void main(String[] args) throws IOException {
        //获取键盘输入
        InputStream is = System.in;
        //将字节流转换为字符流,用到InputStreamReader(InputStream in)---转换流
        InputStreamReader isr = new InputStreamReader(is,"utf-8");
        //将字符流再转为带缓冲区的字符流
        BufferedReader br = new BufferedReader(isr);
        
        String str = null;
        while(true){
            str = br.readLine();
            if("886".equals(str)){
                break;
            }
            System.out.println(str);
        }
        br.close();
    }

}

OutputStreamWriter ;字符流转换为字节流。

转换流示例二

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

/*
 * 1:获取键盘录入的数据，将数据写到文件中，但是以utf-8编码的形式写到文件中去。
 */
public class HomeWork1 {
    
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("e:\\aa.txt"), "utf-8"));
            
            String str = "";
            while(true){
                str = br.readLine();
                if("exit".equals(str)){
                    //可以尝试不同的编码
                    OutputStreamWriter osw = new OutputStreamWriter(System.out, "GBK");
                    BufferedWriter bw2 = new BufferedWriter(osw);
                    bw2.write("输入结束！");
                    bw2.flush();
                    break;
                }
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
            
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

这一段代码的作用是：因为BufferedInputStream为别的输入流添加缓冲功能，在创建BufferedInputStream时会创建一个内部缓冲数组，
用于缓冲数据，提高性能。默认的缓冲大小是8192KB，如果你要读取的文件大于这个默认的大小时，缓冲区没有读满是不会被写入文件的。
所以要关闭输入流，释放这个流的资源。或者用flush（）这个命令强制写入。

            try {
                bw.close();
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

 

三.练习

 

1.使用字节流读取500MB~1G的文件，然后再使用缓冲流读取500MB~1G的文件，测试两者的区别