Java流的体系结构（一）

文章目录

一、文件读写操作FileReader和FileWriter
- 1.main()
- 2.FileReader
- - 1.说明：
  - 2.代码案例
- 3.对read()操作升级：使用read的重载方法
- 4.FileWriter的使用
- - 1.说明
  - 2.代码
- 4.FileReader和FileWriter综合使用
二、使用步骤
- 1.引入库
二、测试FileInputStream和FileOutputStream的使用
- 1.结论
- 2.使用字节流FileInputStream处理文本文件，可能出现乱码
- 3.实现对图片的复制操作
- 3.指定路径下的文件的复制
三、处理流之一：缓冲流的使用
- 1.缓冲流
- 2.作用
- 3.处理流，就是“套接”在已有的流的基础上
- 4.实现非文本文件的复制BufferedInputStream和BufferedOutputStream
- 5.实现文件复制的方法BufferedInputStream和BufferedOutputStream
- 6.使用BufferedReader和BufferedWriter实现文本文件的复制
四、处理流之二：转换流的使用
- 1.概念：
- 2.作用
- 3.InputStreamReader
- 4.InputStreamReader和OutputStreamWriter
五、流的分类以及流的体系结构
六、输入、输出的标准化过程
- 1.输入
- 2.输出

提示：以下是本篇文章正文内容，下面案例可供参考

一、文件读写操作FileReader和FileWriter

1.main()

public static void main(String[] args) {
        File file = new File("hello.txt");  //相较于当前工程
        System.out.println(file.getAbsolutePath());

        File file1 = new File("day04\\hello.txt");
        System.out.println(file.getAbsolutePath());
    }

2.FileReader

1.说明：

1.将hello.txt文件内容读入到程序中，并输出到控制台4
2…read()的处理，返回读入的一个字符，如果达到文件末尾，返回-1
3.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理
4.读入的文件一定要存在，否则就会报FileNotFoundException.

2.代码案例

public void testFileReader()  {
        FileReader fr = null;
        try{
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt"); //相较于当前Module
            //System.out.println(file.getAbsolutePath());

            //2.提供具体的流
            fr = new FileReader(file);

            //3.数据的读入
            //read():返回读入的一个字符。如果到达文件末尾，返回-1.
//        方式一：
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char)data);
//            data = fr.read();
//        }

            //方式二： 语法上针对于方式一的修改
            int data;
            while((data = fr.read())!=-1){
                System.out.println((char)data);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            //4.流的关闭操作
            try{
                if(fr!=null)
                    fr.close();
            }catch(IOException e){
                e.printStackTrace();
            }

        }
    }

3.对read()操作升级：使用read的重载方法

public void testFileReader1() {
        FileReader fr = null;
       try{
           //1.File类的实例化
           File file = new File("hello.txt");

           //2.FileReader流的实例化
            fr = new FileReader(file);

           //3.读入的操作
           //read(char[] cbuf) :返回每次读入到cbuf数组中的字符的个数。
           //如果达到文件末尾，返回-1。
           char[] cbuf = new char[5];
           int len;
           while((len = fr.read(cbuf))!=-1){
               //错误的写法
//               for(int i = 0;i < cbuf.length;i++){
//                   System.out.print(cbuf[i]);
//               }
                //方式一：
//               for (int i = 0; i < len; i++) {
//                   System.out.print(cbuf[i]);
//
//               }

               //方式二：错误！
//               String str = new String(cbuf);
//               System.out.println(str);

               //正确
               String str = new String(cbuf,0,len);
               System.out.print(str);

           }
       }catch(IOException e){
           e.printStackTrace();
       }finally {
           //4.流的关闭操作
           try{
               if(fr!=null)
                   fr.close();
           }catch(IOException e){
               e.printStackTrace();
           }
       }
    }

4.FileWriter的使用

1.说明

1.从内存中写出数据到硬盘的文件里。
2.输出操作，对应的File可以不存在的，并不会报异常
3.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
4.File对应的硬盘中的文件如果存在，
//如果流使用的构造器是： FileWriter(file,false)/(FileWriter(file))：对原有文件的覆盖
//如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是追加。

2.代码

public void testFileWriter()  {
        FileWriter fw = null;

        try{
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file,true);

            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("you need to have a dream!");
        }catch(IOException e){
            e.printStackTrace();
        }
        finally {
            //4.流的关闭操作
            try{
                if(fw!=null)
                    fw.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }

    }

4.FileReader和FileWriter综合使用

public void testFileReaderFileWriter(){
        FileReader fr = null;
        FileWriter fw = null;
        try{
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("111.jpg");
//            File destFile = new File("2.jpg");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf))!= -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.关闭数据流
            try{
                if(fw!=null)
                    fw.close();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try{
                    if(fr!=null)
                        fr.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

二、使用步骤

1.引入库

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

二、测试FileInputStream和FileOutputStream的使用

1.结论

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

2.使用字节流FileInputStream处理文本文件，可能出现乱码

public void testFileInputStream(){
        FileInputStream fis = null;
        try{
            //1.造文件
            File file = new File("hello.txt");
            //2.造流
             fis = new FileInputStream(file);

            //3.读数据
            byte[] buffer = new byte[5];
            int len; //记录每次读取的字节的个数
            while((len = fis.read(buffer)) != -1){
                String str = new String(buffer,0,len);
                System.out.println(str);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(fis != null){
                    fis.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }

3.实现对图片的复制操作

public void testFileInputOutputStream(){
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
            File srcFile = new File("111.jpg");
            File destFile = new File("2.jpg");

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[5];
            int len;
            while((len = fis.read(buffer))!= -1){
                fos.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fos != null){
                try{
                    fos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }


    }

3.指定路径下的文件的复制

public void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[1024];
            int len;
            while((len = fis.read(buffer))!= -1){
                fos.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fos != null){
                try{
                    fos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }


    @Test
    public void testCopyFile(){
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\asus\\Desktop\\1.mp4";
        String destPath = "C:\\Users\\asus\\Desktop\\2.mp4";

        copyFile(srcPath,destPath);

        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));

    }

三、处理流之一：缓冲流的使用

1.缓冲流

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

2.作用

提供流的读取、写入的速度
提高读写速度的原因，内部提供了一个缓冲区

3.处理流，就是“套接”在已有的流的基础上

4.实现非文本文件的复制BufferedInputStream和BufferedOutputStream

public void BufferedStreamTest(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            //1.造文件
            File srcFile = new File("111.jpg");
            File destFile = new File("222.jpg");

            //2.造流
            //2.1  造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2造缓冲流
             bis  = new BufferedInputStream(fis);
             bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[10];
            int len;
            while((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。
            //关于内层流的关闭，我们可以省略
            if(bos!= null){
                try{
                    bos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try{
                    bis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

5.实现文件复制的方法BufferedInputStream和BufferedOutputStream

public void copyFileWithBufferd(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            //2.造流
            //2.1  造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2造缓冲流
            bis  = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer))!=-1){
                bos.write(buffer,0,len);

//                bos.flush();//刷新缓冲流
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。
            //关于内层流的关闭，我们可以省略
            if(bos!= null){
                try{
                    bos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try{
                    bis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
public void testCopyFileWithBuffered(){
        long start = System.currentTimeMillis();
        String srcPath = "C:\\Users\\asus\\Desktop\\1.mp4";
        String destPath = "C:\\Users\\asus\\Desktop\\3.mp4";

        copyFileWithBufferd(srcPath,destPath);

        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));
    }

6.使用BufferedReader和BufferedWriter实现文本文件的复制

public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;
       try{
           //1.创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello3.txt")));

           //2.读写操作
           //方式一：
//           char[] cbuf = new char[1024];
//           int len;
//           while((len = br.read(cbuf))!=-1){
//               bw.write(cbuf,0,len);
            bw.flush();
//           }

           //方式二：
           String data;
           while((data = br.readLine())!=null){
               //方法一：
//               bw.write(data+"\n");  //data不包含换行符
               //方法二：
               bw.write(data);
               bw.newLine();  //提供换行的操作

           }


       }catch(IOException e){
           e.printStackTrace();
       }finally {
           //3.关闭资源
           try{
               if(bw!=null)
                   bw.close();
           }catch (IOException e){
               e.printStackTrace();
           }
           try{
               if(br!=null)
                   br.close();
           }catch (IOException e){
               e.printStackTrace();
           }
       }
    }

四、处理流之二：转换流的使用

1.概念：

转换流:属于字符流
InputstreamReader: 将一个字节的输入流转换为字符的输入流Outputstreamwriter: 将一个字符的输出流转换为字节的输出流

2.作用

提供字节流与字符流之间的转换

3.InputStreamReader

//此时处理异常的话，仍然应该使用try-catch-finally
    //InputStreamReader的使用，实现字节的输入流到字符的输入流的转换

    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("hello.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
    //参数2指明了字符集，具体使用哪个字符集，取决于文件hello.txt保存时使用的字符集
    InputStreamReader isr = new InputStreamReader(fis,"UTF-8");

    char [] cbuf = new char[20];
    int len;
    while((len = isr.read(cbuf))!=-1){
        String str = new String(cbuf,0,len);
        System.out.print(str);
    }

    isr.close();
    }

4.InputStreamReader和OutputStreamWriter

 //此时处理异常的话，仍然应该使用try-catch-finally
    //综合使用InputStreamReader和OutputStreamWriter
    @Test
    public void test2() throws IOException {
        //1.造文件  造流
        File file1 = new File("hello.txt");
        File file2 = new File("hello_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //读写过程
        char [] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf))!=-1){
            osw.write(cbuf,0,len);
        }

        //3.关闭资源
        isr.close();
        osw.close();


    }