• java IO流【常用流对象一】

    文章目录

    常用流对象

    1 文件字节流

    • Filelnputstream通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文本文件等）。
      • Java也提供了FileReader专门读取文本文件。
    • FileOutputstream通过字节的方式写数据到文件中，适合所有类型的文件。
      • Java也提供了Filewriter专门写入文本文件。

    1.1 文件字节输入、输出流

    package IO流;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author 缘友一世
 * date 2022/10/19-21:12
 */
public class FileStreamDemo {
    public static void main(String[] args) {
        //读取 写入
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("basic grammar/src/IO流/girl.jpg");
            fos=new FileOutputStream("basic grammar/src/IO流/CopyGirl.jpg");
            int temp=0;
            while((temp=fis.read())!=-1) {
                System.out.print(temp);//0-255之间的
                fos.write(temp);
            }
            //将数据从内存中写入到磁盘中
            fos.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if (fis!=null) {
                    fis.close();
                }
                if(fos!=null) {
                    fos.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    在这里插入图片描述
    在这里插入图片描述

    1.2 通过缓冲区提高读写效率

    • 1.1中一个一个字节读取和写入的方法，在使用时比较耗时，效率不高。
    • 打个比方，如果你要运送200袋大米回家。方式一是采用每次运两袋。方式二采用一次性扛200袋回家。

    1.2.1 方式一

    • 通过创建一个指定长度的字节数组作为缓冲区，以此来提高10流的读写效率。该方式适用于读取较大图片时的缓冲区定义。

    注意：缓冲区的长度一定是2的整数。一般情况下1024长度较为合适。

    package IO流;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author 缘友一世
 * date 2022/10/19-22:27
 */
public class FileStreamBufferDemo {
    public static void main(String[] args) {
        //读取 写入
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("basic grammar/src/IO流/beauty.jpg");
            fos=new FileOutputStream("basic grammar/src/IO流/CopyBeauty.jpg");
            //使用byte创建数据缓冲区，提高读写效率
            byte[] buff=new byte[1024];
            int temp=0;
            //fis.read(buff)返回的时数组的长度；如果装满了返回的是1024；如果没装满返回的是-1
            while((temp=fis.read(buff))!=-1) {
                //System.out.print(temp);//0-255之间的
                fos.write(buff,0,temp);//将一整包数据拿走
            }
            //将数据从内存中写入到磁盘中
            fos.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if (fis!=null) {
                    fis.close();
                }
                if(fos!=null) {
                    fos.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    在这里插入图片描述

    1.2.2 方式二

    • 通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的available(）。
    • 返回当前文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的。

    注意如果文件过大那么对内存的占用也是比较大的。所以大文件不建议使用该方法。
    用空间换效率的方法。

    package IO流;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author 缘友一世
 * date 2022/10/19-22:27
 */
public class FileStreamBuffer2Demo {
    public static void main(String[] args) {
        //读取 写入
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //创建文件字节输入流对象
            fis=new FileInputStream("basic grammar/src/IO流/girl.jpg");
            fos=new FileOutputStream("basic grammar/src/IO流/CopyGirl2.jpg");
            //使用byte创建数据缓冲区，提高读写效率
            byte[] buff=new byte[fis.available()];
            //fis.read(buff)返回的时数组的长度；如果装满了返回的是1024；如果没装满返回的是-1
                fos.write(buff);//将一整包数据拿走
            //将数据从内存中写入到磁盘中
            fos.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if (fis!=null) {
                    fis.close();
                }
                if(fos!=null) {
                    fos.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    1.3 通过字节缓冲流提高读写速率

    • Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流（节点流或其他处理流）上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流（包装流）。
    • 当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。
    • 因此，缓冲流还是很重要的，我们在IO操作时记得加上缓冲流来提升性能。
    • BufferedlnputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。
    package IO流;

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

/**
 * @author 缘友一世
 * date 2022/10/19-23:16
 */
public class FileStreamBuffer3Demo {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try {
            fis=new FileInputStream("basic grammar/src/IO流/girl.jpg");
            bis=new BufferedInputStream(fis);
            fos=new FileOutputStream("basic grammar/src/IO流/CopyGirl3.jpg");
            bos=new BufferedOutputStream(fos);
            //缓冲流中的byte数组长度默认是8192【2^13】
            int temp=0;
            //使用包装bis进行读取
            while ((temp=bis.read())!=-1) {
                bos.write(temp);
            }
            bos.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                //注意:关闭流的顺序：“后开的先关闭”
                if(bis!=null) {
                    bis.close();
                }
                if (fis!=null) {
                    fis.close();
                }
                if(bos!=null) {
                    bos.close();
                }
                if(fos!=null) {
                    fos.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 执行成功
      在这里插入图片描述

    1.4 定义文件拷贝工具类

    package IO流;

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

/**
 * @author 缘友一世
 * date 2022/10/20-22:39
 */
public class FileCopyTools {
    public static void main(String[] args) {
        long begin=System.currentTimeMillis();
        copyFile("basic grammar/src/IO流/girl.jpg","basic grammar/src/IO流/CopyGirl4.jpg");
        long end=System.currentTimeMillis();
        System.out.println("执行程序用了"+(end-begin)/1000+"秒");
    }
    /**
     * 文件拷贝方法
     */
    public static void copyFile(String src,String des) {
        FileInputStream fis=null;//文件的字节输入流
        BufferedInputStream bis=null;//文件字节读取时的字节缓冲流
        FileOutputStream  fos=null;//文件的字节输出流
        BufferedOutputStream bos=null;//文件字节输出时的字节缓冲流
        try {
            bis=new BufferedInputStream(new FileInputStream(src));
            bos=new BufferedOutputStream(new FileOutputStream(des));
            int temp;
            while((temp=bis.read())!=-1) {
                bos.write(temp);
            }
            bos.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(bis!=null) {
                    bis.close();
                }
                if(fis!=null) {
                    fis.close();
                }
                if(bos!=null) {
                    bos.close();
                }if(fos!=null) {
                    fos.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 执行效率不错。
      在这里插入图片描述

    2 文件字符流

    2.1 文件字符输入流

    • 文件字节流可以处理所有的文件，如果我们处理的是文本文件，也可以使用文件字符流，它以字符为单位进行操作。
    • 演示
    package IO流;

import java.io.FileReader;

/**
 * @author 缘友一世
 * date 2022/10/20-23:13
 */
public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader fileReader=null;
        try {
            //创建文件字符输入流
            fileReader = new FileReader("basic grammar/src/IO流/demo.txt");
            int temp=0;//默认一次读取一个字符
            while ((temp=fileReader.read())!=-1) {
                System.out.println(temp+" "+(char)temp);//unicode值
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fileReader!=null) {
                    fileReader.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    在这里插入图片描述

    2.2 文件字符输出流

    package IO流;

import java.io.FileWriter;

/**
 * @author 缘友一世
 * date 2022/10/20-23:23
 */
public class FileWriteDemo {
    public static void main(String[] args) {
        //如果文件不存在，会默认创建文件
        FileWriter fileWriter=null;
        FileWriter fileWriter2=null;
        try {
            //创建字符输出流对象。
            fileWriter=new FileWriter("basic grammar/src/IO流/write.txt");
            fileWriter.write("我爱你中国！\r\n");//回车换行
            fileWriter.write("我爱你中国！\r\n");
            fileWriter.flush();
            //不同对象对同一个文件进行操作，默认情况下是覆盖，所以我们需要手动设置是否追加
            fileWriter2=new FileWriter("basic grammar/src/IO流/write.txt",true);
            fileWriter2.write("祝福祖国繁荣昌盛！\r\n");
            fileWriter2.write("早日实现伟大复兴！\r\n");
            fileWriter2.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fileWriter!=null) {
                    fileWriter.close();
                }
                if(fileWriter2!=null) {
                    fileWriter.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    在这里插入图片描述

    2.3 使用字符流实现文本文件的拷贝处理

    package IO流;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * @author 缘友一世
 * date 2022/10/20-23:41
 */
public class FileCopyTools2 {
    public static void main(String[] args) {
        FileReader fileReader=null;
        FileWriter fileWriter=null;
        try {
            fileReader=new FileReader("basic grammar/src/IO流/write.txt");
            fileWriter=new FileWriter("basic grammar/src/IO流/CopyWrite.txt");
            char[] buffer=new char[1024];//老办法使用字符数组，提高读写的效率
            int temp;
            while((temp=fileReader.read(buffer))!=-1) {
                fileWriter.write(buffer,0,temp);
            }
            fileWriter.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileReader!=null) {
                    fileReader.close();
                }
                if(fileWriter!=null) {
                    fileWriter.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    在这里插入图片描述

    2.4 通过字符缓冲流为文件的内容添加行号

    package IO流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * @author 缘友一世
 * date 2022/10/21-16:02
 */
public class LineNumberDemo {
    public static void main(String[] args) {
        BufferedReader bufferedReader=null;
        BufferedWriter bufferedWriter=null;
        try {
            bufferedReader=new BufferedReader(new FileReader("basic grammar/src/IO流/write.txt"));
            bufferedWriter=new BufferedWriter(new FileWriter("basic grammar/src/IO流/LineNumberWrite.txt"));
            String temp="";
            int i=1;
            while ((temp=bufferedReader.readLine())!=null) {
                bufferedWriter.write(i+":"+temp);//添加行号
                bufferedWriter.newLine();//换行
                i++;
            }
            bufferedWriter.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader!=null) {
                    bufferedReader.close();
                }
                if(bufferedWriter!=null) {
                    bufferedWriter.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    在这里插入图片描述

  • 相关阅读:
    Axure RP仿QQ音乐app高保真原型图交互模板源文件
    开源模型应用落地-安全合规篇（一）
    答粉丝问）【问题记录&解决】Python & MySQL：备份和恢复、灾难恢复方法（附代码） | 如何实现前端连python 后端传数据，生成前端折线图，echarts？
    23. 深度学习 - 多维向量自动求导
    SpringBoot RestControllerAdvice异常处理适配原理
    什么是SpringBoot自动配置
    页面分布引导新手指引（driver.js）
    Clickhouse上用Order By保证绝对正确结果但代价是性能
    jvm调优 和实际案例
    C语言表达式求值、隐式类型转换、算数转换
  • 原文地址：https://blog.csdn.net/yang2330648064/article/details/127361287