File-io流 - 悦读

File

创建file的对象

创建一个file对象，指代某个具体文件
File file = new File("C:\\Users\\刘翀羽\\Pictures\\Screenshots");

//文件大小
System.out.println(file.length());

路径分隔符用 File.separator 代表
File f2 = new File("C:" + File.separator + "Users" + File.separator + "刘翀羽Pictures" + File.separator + "Screenshots");

注意；file对象可以指向一个不存在的文件路径
File f3 = new File("D:/reave/aaa.text");
System.out.println(f3.length());//因为不存在所以文件字节数为0
System.out.println(f3.exists());//false 用于判断文件是否存在

现在进行定位文件是在模块中，是怎么定位的
//绝对路径：带盘符的只用于自己电脑若是想复制到别人的电脑中打开就不行了
File f4 = new File("D:\\code\\javaserpro\\file-io-app\\src\\itheima.txt");
//相对路径（重点）不带盘符默认去工程里面寻找文件的
File f5 = new File("code\\javaserpro\\file-io-app\\src\\itheima.txt");
System.out.println(f5);

File的常用方法

1.创建一个文件对象，指代某个文件
File f1 = new File("D:\\cxdownload\\aaa");

2.exists() 判断当前文件对象，对应的文件路径是否存在，存在返回true
System.out.println(f1.exists());//true

3.isFile() 判断当前文件对象指代的是不是文件，是文件放会true
System.out.println(f1.isFile());//false

4.isDirectory() 判断当前文件对象是不是文件夹，是文件夹就返回true
System.out.println(f1.isDirectory());//true

5.getName() 获取文件名（包含后缀）
System.out.println(f1.getName());//aaa

6.ength() 获取文件大小，返回字节数
System.out.println(f1.length());

7. lastModified() 获取文件的最后修改时间
long time = f1.lastModified();
SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
System.out.println(sdf.format(time));

8. getPath() 获取文件对象时使用的路径
File f2 = new File("D:\\code\\javaserpro\\file-io-app\\src\\itheima.txt");;
//创建时为相对路径
File f3 = new File("file-io-app\\src\\itheima.txt");
System.out.println(f2.getPath());
System.out.println(f3.getPath());

9. getAbsoluteFile() 获取绝对路径
System.out.println(f2.getAbsoluteFile());
//打印时转成绝对路径
System.out.println(f3.getAbsoluteFile());

创建文件夹，删除文件夹

注：删除后的文件会被粉碎了，找不回来了

createNewFile() 创建一个新的文件（文件内容为空）创建成功返回true 第二次运行程序就返回false
File f1 = new File("D:\\cxdownload\\itheima2.txt");
System.out.println(f1.createNewFile());

mkdir() 创建文件夹注意：只能创建一级文件夹
File f2 = new File("D:/cxdownload/ccc");
System.out.println(f2.mkdir());

mkdirs() 创建文件夹，注意：可以创建多级文件夹
File f3 = new File("D:/cxdownload/ddd/eee/ggg");

delete() 删除文件，或者空文件。注意：不能删除非空文件夹
System.out.println(f2.delete());
System.out.println(f1.delete());
File f5 = new File("D:/download");
非空文件夹不能删除
System.out.println(f5.delete());

遍历文件夹

listFile() 获取当前目录下的所有”一级文件对象“到一个文件对象数组中返回（重点）
File[] files = f1.listFiles();
for (File file : files) {
System.out.println(file.getAbsoluteFile());
}

    //掌握file提供的遍历文件夹的方法
          //1. list()  截取当前目录下的所有的   一级文件 到一个字符串数组中去返回
        File f1 = new File("D:\\BaiduNetdiskDownload");
        String[] names = f1.list();
        for (String name : names) {
            System.out.println(name);
        }
        // listFile()  获取当前目录下的所有”一级文件对象“到一个文件对象数组中返回（重点）
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file.getAbsoluteFile());
        }

方法递归

 public static void main(String[] args) {
        test1();
    }

    //直接方法递归(用的比较多)
    public static void test1() {
        System.out.println("--------test1()-----");
        test1();
    }

    //间接递归方法
    public static void test2()
    {
        System.out.println("------test2-----");
        test3();

    }
     public  static void  test3()
     {
         test2();
     }

1.案例：计算阶乘

  //计算阶乘
        System.out.println("5的阶乘是"+f(5));
    }

    public  static  int f(int n)
    {
        //终结的
          if(n==1)
          {
              return 1;
          }
          else {
              return f(n-1)*n;
          }

2.案例：计算求和

   //计算求和
        System.out.println("1到5的和为"+f(5));
    }

    public  static  int f(int n)
    {
        //终结的
          if(n==1)
          {
              return 1;
          }
          else {
              return f(n-1)+n;
          }

3.案例：猴子吃桃问题

//猴子吃桃问题
        //f(10)=1
        //公式：  f(x) -f(x)/2-1=f(x+1)
        //公式变型： f(x)=2*f(x+1)+2
        System.out.println(f(1));
        System.out.println(f(2));
    }
    public  static int  f(int x)
    {
       if(x==10)
       {
           return 1;
       }
       else {
           return  2*f(x+1)+2;
       }

文件搜索

案例：在D盘中找到QQ并打开

  public static void main(String[] args) throws Exception {
        searchFile(new File("D:/"),"QQScLauncher.exe");
        int  [] result =new int[2];
    }
    /**
     * @param  dir 目录
     * @param   fileName  要搜索的文件名称
     */
    public static  void  searchFile(File dir ,String fileName) throws IOException {
        if (dir == null || !dir.exists() || dir.isFile()) {
            return;
        }

        File[] files = dir.listFiles();
        if (  files != null&&files.length>0) {
            for (File f : files) {
                if (f.isFile()) {
                    if (f.getName().contains(fileName)) {
                        System.out.println("已经找到" + f.getAbsoluteFile());
                        Runtime runtime =Runtime.getRuntime();
                        runtime.exec(f.getAbsolutePath());
                    }

                } else {
                    searchFile(f, fileName);
                }
            }
        }

案例：删除文件夹

    //删除非空文件夹
        File file = new File("C:\\Users\\刘翀羽\\Pictures\\Saved Pictures");
        deleteFile(file);

    }
    public  static void  deleteFile(File dir)
    {
        if(dir==null||!dir.exists())
        {
            return;
        }
        if(dir.isFile())
        {
            dir.delete();
            return;

        }
        //dir存在文件夹，拿里面的一级文件对象
        File[] files = dir.listFiles();
        if(files==null)
        {
            return;
        }
        if(files.length==0)
        {
            dir.delete();
            return;
        }
        //2.这是一个有内容的文件夹，干调里面的内容，再干掉自己
        for (File file : files) {
                if(file.isFile()){
                    file.delete();
                }
                //说明为文件夹
                else {
                    deleteFile(file);
                }
        }
        dir.delete();

啤酒问题

啤酒问题：啤酒2元一瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，请问10元可以换多少瓶

public  static  int  totalNumber;
    public  static  int lastBottleNumber;
    public  static  int  lastCoverNumber;
    public static void main(String[] args) {
            //啤酒问题：啤酒2元一瓶，4个盖子可以换一瓶，
2个空瓶可以换一瓶，请问10元可以换多少瓶
                                buy(10);
        System.out.println("总数"+totalNumber);
        System.out.println("剩余盖子数"+lastCoverNumber);
        System.out.println("剩余瓶子数"+lastBottleNumber);
    }
    public static  void  buy(int money) {
        //1.先买再说
        int buyNumber = money / 2;
        totalNumber += buyNumber;
        //2.把盖子和瓶数换算成钱继续买
        //计算本轮总的盖子数和瓶子数
        int allBottleNumber = buyNumber + lastBottleNumber;
        int allCoverNumber = buyNumber + lastCoverNumber;
        int allMoney = 0;
        if (allBottleNumber >= 2)
        {
            allMoney +=(allBottleNumber/2)*2;

        }
        lastBottleNumber=allBottleNumber%2;

        if(allCoverNumber>=4)
        {
            allMoney+=(allCoverNumber/4)*2;

        }
        lastCoverNumber =allCoverNumber%4;

        if (allMoney>=2)
        {
            buy(allMoney);
        }

字符集

字符的解码与编码

   //1.编码
        String data="a我b";
        byte[] bytes = data.getBytes();
        System.out.println(Arrays.toString(bytes));
        //按照指定字符集进行编码
        byte[] gbks = data.getBytes("GBK");
        System.out.println(Arrays.toString(gbks));
        //2.解码
        String s1 =new String(bytes);
        System.out.println(s1);
        //按照平台默认编码（UTF-8）解码
        String s2 =new String(gbks);
        System.out.println(s2);

io流

字节流

1.FileInputStream（字节输入流）

使用FileIoputStream每次读取一个字节，读取性能较差，并且读取汉字会乱码

1.每次读取一个字节

 //1.创建文件字节输入流管道，与源文件接通
        //使用多态InputStream继承父类
      // InputStream is = new FileInputStream(new File("file-io-app\\src\\itheima.txt"));
        //简化写法：推荐使用
        InputStream is = new FileInputStream(("file-io-app\\src\\itheima.txt"));
        //2.开始读取文件的字节数据
        //  read() 每次读取一个字节返回，如果没有数据了就返回-1
//         int b1 =  is.read();
//        System.out.println((char)b1);// a---97
//          int b2 =is.read();
//        System.out.println((char)b2);
        //3.使用循环改造上述代码  读取数据性能差  读取汉字输出会乱码！！ 无法避免原因：汉字为三字节 该方法实现是单独读取一字节
        //使用完毕后，必须关闭！释放系统资源    is.close();
        int b;//用于记住读取的字节
        while ((b=is.read())!=-1)
        {
            System.out.print((char) b);
        }
        is.close();

2.每次读取多个字节

 //1.创建文件字节输入流对象代表字节输入流管道与源文件接通
        InputStream is = new FileInputStream("file-io-app\\src\\ithheima02.txt");

        //开始读取多个字节
        byte[] buffer = new byte[3];
        int len1 = is.read(buffer);
        String rs = new String(buffer);
        System.out.println(rs);
        System.out.println("当前读取的字节数量为 "+len1);

//        //注意：读取多少，倒出多少
//        int len2 = is.read(buffer);
//        String rs2 = new String(buffer);
//        System.out.println(rs2);
//        System.out.println("当前读取的字节数量为 "+len2);//66c  多倒

        //注意：读取多少，倒出多少
        int len2 = is.read(buffer);
        String rs2 = new String(buffer,0,len2);
        System.out.println(rs2);
        System.out.println("当前读取的字节数量为 "+len2);

性能得到了明显提升，这种方法也不能避免读取汉字输出乱码的问题

 //3.使用循环改造
        byte[] buffer = new byte[3];
           int len;  //记住每次读取多少字节
        while ((len=is.read(buffer))!=-1)
        {
            //注意：读取多少，倒去多少
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }

3.一次读取完整个字节

方式一：

  FileInputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");
        //2.准备一个字节数组，大小与文件的大小正好一样大
        File  f =new File("file-io-app\\src\\itheima03.txt");
        long size = f.length();
        byte[] buffer = new byte[(int) size];
          int len =is.read(buffer);
        System.out.print(new String(buffer));
        System.out.println(" ");
        System.out.println(size);
        System.out.println(len);

方式二：

   byte[] buffer = is.readAllBytes();
        System.out.println(new String(buffer));

2.FileOutputStream（字节输出流）

将字符串编码为字节数组
byte[] bytes = "我爱你中国abc".getBytes();

1.覆盖管道，覆盖之前的数据

//创建一个字节输出流管道与目标文件接通
        //1.覆盖管道，覆盖之前的数据
       FileOutputStream os =
               new FileOutputStream("file-io-app/src/itheima04.txt");

2.追加数据的管道(实现每次运行代码，在文本中添加数据)

//2.追加数据的管道(实现每次运行代码，在文本中添加数据)
        FileOutputStream os =
                new FileOutputStream("file-io-app/src/itheima04.txt",true);

添加文本内容write（）

  
        os.write(97);//97代表是一个字节，代表a
        os.write('b');//‘b’代表也是一个字节
        //将字符串转换为字符数组
        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes,0,15);
        //换行符(实现运行代码将文本数据进行换行)
        os.write("\r\n".getBytes());
        os.close();//关闭流

换行符(实现运行代码将文本数据进行换行)

 //换行符(实现运行代码将文本数据进行换行)
        os.write("\r\n".getBytes());

案例：文件复制

此方法适合一切文件，包括文本文件，视频文件

 //1.创建一个字节输入管道与源文件接通
        FileInputStream is =
 new FileInputStream("C:\\Users\\刘翀羽\\Pictures\\
Camera Roll\\微信图片_20240912151440.jpg");

        //2.创建一个字节输出流管道与目标文件接通
        FileOutputStream os = 
new FileOutputStream("D:\\360Downloads\\Software\\
微信图片_20240912151440.jpg");
        //3.创建一个字节数组，负责转移字节数据。
        byte[] buffer = new byte[1024];//1kb
        //4.从字节输入流中读取字节数据，写出去到字节输出流中，读多少出去多少
        int len;//记住每次读取了多少字节
        while ((len=is.read(buffer))!=-1)
        {
            os.write(buffer,0,len);
        }
            os.close();
        is.close();
        System.out.println("复制完成");

释放资源的两种方式

1.try-catch-finally

 public static void main(String[] args) {
        try {
            System.out.println(10/2);
        }catch (Exception e)
        {
            e.printStackTrace();
        }
        finally {
            System.out.println("=======finally执行了一次===");
        }
        System.out.println(chu(10, 5));
    }

    public  static  int chu(int a,int b)
    {
        try {
            return a/b;
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return -1;//代表的是出现异常
        }
        finally {
            //有返回值时，千万不要使用finally返回值会代替原本数值
           return 111;
        }
    }

结果

5
=======finally执行了一次===
111

案例

public static void main(String[] args) {
        FileInputStream is=null;
        FileOutputStream os =null;
        try {
            //1.创建一个字节输入管道与源文件接通
             is = new FileInputStream("C:\\Users\\刘翀羽\\Pictures\\Camera Roll\\微信图片_20240912151440.jpg");

            //2.创建一个字节输出流管道与目标文件接通
             os = new FileOutputStream("D:\\360Downloads\\Software\\微信图片_20240912151440.jpg");
            //3.创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024];//1kb
            //4.从字节输入流中读取字节数据，写出去到字节输出流中，读多少出去多少
            int len;//记住每次读取了多少字节
            while ((len=is.read(buffer))!=-1)
            {
                os.write(buffer,0,len);
            }

            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源的操作，防止报空指针异常
            try {
                if(os!=null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is!=null)is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.try-with-resource

注意：这里只能放置资源对象（流对象）
int age =10；就不行
什么是资源：资源就是会实现AutoCloseable接口，资源都会有一个close方法，并且资源放到这里后（可以自己创建对象去实现接口也可以使用该对象）
用完之后，会被自动调用其close方法完成资源的是释放操作

 try (//1.创建一个字节输入管道与源文件接通
            FileInputStream     is = new FileInputStream("C:\\Users\\刘翀羽\\Pictures\\Camera Roll\\微信图片_20240912151440.jpg");

        //2.创建一个字节输出流管道与目标文件接通
                FileOutputStream  os = new FileOutputStream("D:\\360Downloads\\Software\\微信图片_20240912151440.jpg");
                )
                //注意：这里只能放置资源对象（流对象）
                // int  age =10； 就不行
                //什么是资源：资源就是会实现AutoCloseable接口，资源都会有一个close方法，并且资源放到这里后
                //用完之后，会被自动调用其close方法完成资源的是释放操作
        {

            //3.创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024];//1kb
            //4.从字节输入流中读取字节数据，写出去到字节输出流中，读多少出去多少
            int len;//记住每次读取了多少字节
            while ((len=is.read(buffer))!=-1)
            {
                os.write(buffer,0,len);
            }

            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }

        }

字符流

字节流：适合复制文件等，不适合读写文本文件

字符流：适合读写文本文件内容

1.FileReader（文件字符输入流）

1.每次读取一个字符，性能肯定比较差

  //1.每次读取一个字符，性能肯定比较差
        try(  FileReader fr = new FileReader("file-io-app\\src\\itheima.txt");){
          int c;//记住每次读取的字符编号
          while ((c=fr.read())!=-1)
          {
              System.out.print((char) c);
          }
        } catch (Exception e) {
            e.printStackTrace();
        }

2.每次读取多个字符，性能比较好

  //2.每次读取多个字符，性能比较好
        try(  FileReader fr = new FileReader("file-io-app\\src\\itheima.txt");){
            //都多少，倒多少
            char[]buffer= new char[3];
                int len;
                    while ((len=fr.read(buffer))!=-1)
                    {
                        System.out.print(new String(buffer, 0, len));
                    }
        } catch (Exception e) {
            e.printStackTrace();
        }

2.FileWrite（文件字符输出流）

2 write（int c）写一个字符出去

注意：当你在write（）中输入97会根据ascii转成a，当你想输入数字可以使用"97"就可以了

   //2  write（int c）  写一个字符出去
                fw.write(97);
            fw.write('a');
            fw.write("刘");
            fw.write('就');

//换行
fw.write("\r\s");

3 write（Sting c）写一个字符出去

 // 3 write（Sting c） 写一个字符出去
            fw.write("我爱你中国abc");
            fw.write("\r\s");

4.write（String c， int pos ，int len）写字符串的一部分出去

 //4.write（String c， int pos ，int len）写字符串的一部分出去
            fw.write("我爱你中国abc",0,5);
            fw.write("\r\s");

5.write（char[] buffer）写一个字符数组出去

 //5.write（char[] buffer）写一个字符数组出去
            char[]buffer={'黑','马','a','b','c','d'};
            fw.write(buffer);
            fw.write("\r\s");

6.write(char[] buffer, int pos ,int len) 写字符数组的一部分出去

 //6.write(char[] buffer, int pos ,int len) 写字符数组的一部分出去
                fw.write(buffer,0,5);

   try ( //1.创建一个文件字符输入流管道与目标文件接通

              //覆盖管道
//              FileWriter fw = new FileWriter("file-io-app/src/itheima05.txt");){
              //追加数据的管道
              FileWriter fw = new FileWriter("file-io-app/src/itheima05.txt",true);){

            //2  write（int c）  写一个字符出去
                fw.write(97);
            fw.write('a');
            fw.write("刘");
            fw.write('就');
            //换行
            fw.write("\r\s");
            // 3 write（Sting c） 写一个字符出去
            fw.write("我爱你中国abc");
            fw.write("\r\s");
            //4.write（String c， int pos ，int len）写字符串的一部分出去
            fw.write("我爱你中国abc",0,5);
            fw.write("\r\s");
            //5.write（char[] buffer）写一个字符数组出去
            char[]buffer={'黑','马','a','b','c','d'};
            fw.write(buffer);
            fw.write("\r\s");
            //6.write(char[] buffer, int pos ,int len) 写字符数组的一部分出去
                fw.write(buffer,0,5);
        } catch (Exception e) {
            e.printStackTrace();
        }

    FileWriter fw = new FileWriter("file-io-app/src/itheima06.txt");
          fw.write('a');
          fw.write('b');
          fw.write('d');
          fw.write("我爱你中国");
          //刷新流
          fw.flush();//实现将文本写入
        //刷新完还能在文本中输入
        fw.write("张三");
        fw.flush();

        //关闭流(包含刷新，但是就不能继续加内容了)
        fw.close();

缓冲流

作用：1.提高读写能力。2.优化资源使用。3.提升程序响应速度。4.支持多种数据类型5.易于使用与管理。

1.字节缓冲流

1.定义一个字节缓冲输入流包装原始的字节输入流
InputStream bis =new BufferedInputStream(is);

2.定义一个字节缓冲输出流包装原始的字节输出流
OutputStream bos =new BufferedOutputStream(os);

修改缓冲流每次读取的字节数为16kb

InputStream bis =new BufferedInputStream(is，8192*2);

 try (
             FileInputStream     is = new FileInputStream("C:\\Users\\刘翀羽\\Pictures\\Camera Roll\\微信图片_20240912151440.jpg");
            //1.定义一个字节缓冲输入流包装原始的字节输入流
            InputStream bis =new BufferedInputStream(is);
             FileOutputStream  os = new FileOutputStream("D:\\360Downloads\\Software\\微信图片_20240912151440.jpg");
             //2.定义一个字节缓冲输出流包装原始的字节输出流
             OutputStream bos =new BufferedOutputStream(os);
        )

        {


            byte[] buffer = new byte[1024];//1kb

            int len;//记住每次读取了多少字节
            while ((len=bis.read(buffer))!=-1)
            {
                bos.write(buffer,0,len);
            }

            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }

2.字符缓冲流

1.BufferedReader（字符缓冲输入流）

创建一个字符缓冲流包装原始的字符输入流
BufferedReader br =new BufferedReader(fr);

try(  FileReader fr = new FileReader("file-io-app\\src\\itheima07.txt");
                //创建一个字符缓冲流包装原始的字符输入流
              BufferedReader br =new BufferedReader(fr);

        ){

            char[]buffer= new char[3];
            int len;
            while ((len=br.read(buffer))!=-1)
            {
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

在实现读取数据的便利方法

String line ;//记住每次读取的一行数据
while ((line=br.readLine())!=null)
{
System.out.println(line);
}

  try(  FileReader fr = new FileReader("file-io-app\\src\\itheima07.txt");
                //创建一个字符缓冲流包装原始的字符输入流
              BufferedReader br =new BufferedReader(fr);

        ){

//            char[]buffer= new char[3];
//            int len;
//            while ((len=br.read(buffer))!=-1)
//            {
//                System.out.print(new String(buffer, 0, len));
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());//返回null
            String  line ;//记住每次读取的一行数据
            while ((line=br.readLine())!=null)
            {
                System.out.println(line);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }

2. BufferedWriter(字符缓冲输出流)

创建一个字符缓冲输出流包装原始的字符输出流
BufferedWriter bw = new BufferedWriter(fw)


        try (
                //追加代码
              FileWriter fw = new FileWriter("file-io-app/src/itheima05.txt",true);
                //创建一个字符缓冲输出流包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);){


            bw.write(97);
            bw.write('a');
            bw.write("刘");
            bw.write('就');

            bw.write("\r\s");
            bw.write("我爱你中国");
            bw.newLine();

        } catch (Exception e) {
            e.printStackTrace();
        }

案例

 //恢复出师表的顺序到新文件中
        public static void main(String[] args) {
            try (
            //2.创建缓冲字符输入流管道与源文件接通
            BufferedReader br =   new BufferedReader( new FileReader("file-io-app\\src\\csb.txt"));
            BufferedWriter bw =new BufferedWriter( new FileWriter("file-io-app\\src\\itheima08.txt"));

            )



            {
                //1.定义一个Arraylist集合储存每段内容
                List<String> data =new ArrayList<>();
                //3.按照行读取每段，存入到集合中去
                String  line;
                while ((line = br.readLine())!=null)
                {
                    data.add(line);
                }
                //4.对list集合进行每段的排序，依次写出去到新文件
                Collections.sort(data);
                System.out.println(data);
                for (String ln : data) {
                    bw.write(ln);
                    bw.newLine();//换行
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

io流与缓冲流的区别

一、数据处理方式

普通的IO流：
- 直接从数据源（如文件、网络等）读取或写入数据，没有中间缓冲过程。
- 每次读写操作都涉及到底层的IO系统调用，效率相对较低。
缓冲流：
- 在内存中设置了一个缓冲区，作为数据源与程序之间的临时存储。
- 读取数据时，先从数据源读取一定量的数据到缓冲区，然后从缓冲区中逐次读取数据给程序。
- 写入数据时，先将数据写入缓冲区，当缓冲区满或关闭流时，再将缓冲区中的数据写入数据源。
- 这种方式减少了与底层IO系统的交互次数，提高了数据处理的效率。

二、性能差异

普通的IO流：
- 由于每次读写操作都直接涉及到底层IO系统调用，因此性能相对较低。
- 在处理大量数据时，频繁的IO操作会导致程序运行缓慢。
缓冲流：
- 通过引入缓冲区，显著提高了数据读写的效率。
- 缓冲区可以一次性读取或写入多个数据块，减少了IO操作的次数。
- 在处理大量数据时，缓冲流能够显著减少程序的运行时间。

三、编程复杂度

普通的IO流：
- 编程相对简单，直接调用读写方法即可。
- 但由于性能较低，可能需要额外的优化措施来提高程序效率。
缓冲流：
- 编程复杂度稍高，需要了解缓冲区的概念和使用方法。
- 但由于性能较高，通常可以减少程序的运行时间和资源消耗。
- 缓冲流提供了丰富的API，使得开发者可以更加方便地进行IO操作。

四、适用场景

普通的IO流：
- 适用于对性能要求不高、数据量较小的场景。
- 或者在需要直接访问底层IO系统调用的情况下使用。
缓冲流：
- 适用于对性能要求较高、数据量较大的场景。
- 如文件读写、网络通信等需要频繁进行IO操作的场景。

综上所述，缓冲流通过引入缓冲区来提高数据处理的效率，相对于普通的IO流具有显著的性能优势。在选择使用哪种流时，需要根据具体的应用场景和数据量进行权衡。

如果性能要求较高或数据量较大，建议使用缓冲流；

如果性能要求不高或数据量较小，可以选择普通的IO流。

注意：当使用字节数组去用低级字节数组与高级的字节缓冲流时差别不大

转换流

引入问题

代码编码是指像UTF-8，GBK等。

字符输入转化流

Reader isr =new InputStreamReader(is,"GBK");

 try (
                //1.得到文件的原始字节流（GBK的字节流形式）
             InputStream  is =  new FileInputStream("file-io-app\\src\\itheima04.txt");
             //2.把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr =new InputStreamReader(is,"GBK");
                //3.把字符输入流包装成缓冲字符输入流
                    BufferedReader br =new BufferedReader(isr);
        ) {
            String  line;
            while ((line=br.readLine())!=null)
            {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

字符输出转换流

Writer osw = new OutputStreamWriter(os,"GBK");

   try (
                //1.创建了一个文件字节输入流
                OutputStream os = new FileOutputStream("file-io-app/src/itheima09.txt");
                //2.把原始的字节输出流，按照指定的字符集编码转换成转换流（GBK）
                Writer osw = new OutputStreamWriter(os,"GBK");
                //3.把字符输出流包装成缓冲字符输出流
                BufferedWriter bw=new BufferedWriter(osw);


        ){//内容为
            bw.write("我爱你祖国abc");
            bw.write("我最最最爱的你");
        } catch (Exception e) {
            e.printStackTrace();
        }

打印流（printStream/Writer）

 try (
                PrintStream ps =new PrintStream("file-io-app/src/itheima10.txt");

        ){
          ps.print(97);
          ps.println('a');
          ps.println("我爱你中国");
          ps.println(true);
        } catch (Exception e) {
            e.printStackTrace();
        }

PrintStream ps =new PrintStream("file-io-app/src/itheima10.txt", Charset.forName("GBK"));//指定为gbk类型

注意：printStream为覆盖流，要实现追加必须转换为低级流

实现追加

PrintStream ps =new PrintStream(new FileOutputStream("file-io-app/src/itheima10.txt"));

输出语句的重定向

把系统默认的打印流对象改成自己设置的打印流
System.setOut(ps);

  //打印在控制台
        System.out.println("我爱你中国");
        try( PrintStream  ps =  new PrintStream("file-io-app/src/itheima11.txt");
        ) {
            //把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);
            //使得下面两行代码打印在文件中
            System.out.println("非法手段VS v");
            System.out.println("safacsvsvs");
        } catch (Exception e) {
            e.printStackTrace();
        }