java IO数据流使用

---

前言

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中

一、IO流分类

1.根据操作数据单位不同：字节流和字符流
2.根据数据流的流向不同：输入流和输出流
3.根据流的角色不同：节点流和处理流

二、IO流体系

1.具体分类表

2.常用IO类（熟练使用）

三、具体使用

1.FileReader

将dbcp.txt文件内容读到程序中，并输出到控制台

public class testFileReader {
    @Test
    public void testFileReader(){
        FileReader fileReader  = null;
        try {
            //1.实例化File类对象，指明要操作的文件
            File file = new File("dbcp.txt");
            //2.提供具体的流
            fileReader = new FileReader(file);
            //3.数据的读入
            //方式一
            //int data = fileReader.read();
           // while(data != -1){
             //   System.out.println((char) data);
            //    data = fileReader.read();
           // }
           //方式二
           int data;
           while((data = fileReader.read()) != -1){
				System.out.println((char) data);
			}
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.关闭文件流
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

知识点

1. read() 的理解：返回读入的一个字符，如果读到文件末尾，返回 -1
2. 异常处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理异常
3. 读入的文件一定要存在，否则报文件找不到异常

对使用read()方法的有参构造实现

 @Test
    public void testFileReader2(){
        FileReader fileReader = null;
        try {
            //1.实例化File对象
            File file = new File("dbcp.txt");
            //2.创建流对象
            fileReader = new FileReader(file);
            //3.读入数据
            char[] cuf = new char[1024];
            int len;
            while ((len = fileReader.read(cuf)) != -1){
                for (int i = 0; i < len; i++) {
                    System.out.println(cuf[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.流关闭
            if (fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

2.FileWriter使用

 @Test
    public void testFileWriter(){
        FileWriter fileWriter = null;
        try {
            //1.提供File类的对象，同时指明写出到的文件
            File file = new File("testFileWriter.txt");
            //2.提供FileWriter的对象，用于数据的写出
            fileWriter = new FileWriter(file,false);
            //3.写出的操作
            fileWriter.write("愿程序无bug");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.流的关闭
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

知识点

1. 输出操作，对应的File可以不存在的，并不会报异常
2. File对应的硬盘中文件不存在，在输出的过程中，会自动创建此文件
   如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有的文件
   进行覆盖操作
   如果流使用的构造器是：FileWriter(file,true):对原有的文件不会进行覆盖操 作，而是在原有文件基础上追加内容

3.FileReader和FileWriter综合使用

 @Test
    public void testFileReaderAndFileWriter(){
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            //1.提供File类对象，指明读写文件
            File reFile = new File("dbcp.txt");
            File wrFile = new File("FileReaderAndFileWriter.txt");
            //2.创建输入流和输出流
            fileReader = new FileReader(reFile);
            fileWriter = new FileWriter(wrFile);
            //3.数据的读入和写出
            char[] cbuf  = new char[1024];
            int len;
            while ((len = fileReader.read(cbuf)) != -1 ){
                fileWriter.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

4.FileInputStream和FileOutputStream使用

处理图片视频等非文本文件

 @Test
    public void testFileInputStreamAndFileOutputStream(){
        FileInputStream ism = null;
        FileOutputStream osm = null;
        try {
            //1.提供File类的对象，指定相应的文件
            File reFile = new File("23.jpg");
            File weFile = new File("123.jpg");
            //2.提供InputStream和OutputStream对象
            ism = new FileInputStream(reFile);
            osm = new FileOutputStream(weFile);
            //3.输入和输出操作
            byte[] butf = new byte[1024];
            int len;
            while((len = ism.read(butf)) != -1){ 
                osm.write(butf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭
            if (osm != null) {
                try {
                    osm.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ism != null) {
                try {
                    ism.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

知识点

1. 对于文本文件（.txt ,.java,.c,.cpp等），使用字符流处理
2. 对于非文本文件（.jpg,.mp3,.mp4,.avi,.doc,.ppt等），使用字节流处理

5、缓冲流

知识点

1. 缓冲流
   BufferedInputStream
   BufferedOutputStream
   BufferedReader
   BufferedWriter
2. 作用：提高流的读取、写入速度

5.1、BufferedInputStream和BufferedOutputStream使用

 @Test
    public void testBufferedStream(){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            //1.造文件
            File reFile = new File("23.jpg");
            File weFile = new File("33.jpg");
            //2.造流
            //2.1.造节点流
            fileInputStream = new FileInputStream(reFile);
            fileOutputStream = new FileOutputStream(weFile);
            //2.2.造缓冲流
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            //3.处理
            byte[] buft = new byte[1024];
            int len;
            while((len = bufferedInputStream.read(buft)) != -1){
                bufferedOutputStream.write(buft,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.流关闭
            if (bufferedOutputStream != null) {
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedInputStream != null) {
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream != null) {

                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

5.2、BufferedReader和BufferedWriter使用

@Test
    public void  testBufferedReaderAndWriter(){
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            //1.造文件
            File reFile = new File("dbcp.txt");
            File weFile = new File("dbcp_BufferedReaderAndWriter");
            //2.造流
            //2.1、造字节流
            fileReader = new FileReader(reFile);
            fileWriter = new FileWriter(weFile);
            //2.2、早缓冲流
            bufferedReader = new BufferedReader(fileReader);
            bufferedWriter = new BufferedWriter(fileWriter);
            //3.处理
            char[] cubf = new char[1024];
            int len;
            while((len = bufferedReader.read(cubf)) != -1){
                bufferedWriter.write(cubf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.流关闭
            if (bufferedWriter != null) {
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (bufferedReader != null) {

                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }
    }

总结

主要掌握这几种类的使用基本可以解决大多数的小问题，其实看起来繁琐，只要记住主要使用步骤就基本掌握了