Javase | IO流

已于 2023-09-04 00:07:41 修改
阅读量193 收藏 1
点赞数 2
分类专栏： Java知识点-整合 文章标签： java IO流 开发语言
于 2023-09-02 12:10:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70720417/article/details/132636284
版权

目录：

1.输入 (Intput/Read)

  • 把 硬盘 中的文件放到 内存 中，这个过程叫输入 (Intput) / 读 (Read)。

  • 把硬盘中的文件放到内存中，可重新表述为：

    ①把硬盘中的文件 输入(Intput) 到内存中。

    ②把硬盘中的文件 读(Read) 进内存中。

  • 内存中文件在关机后会丢失 。
  • 硬盘中文件在关机后仍存在。

2.输出 (Output/Write)

  • 把 内存中的文件放到硬盘中，这个过程叫输出 (Output) / 写 (Write)。

  • 把内存中的文件放到硬盘中，可表述为：

    ①把内存中的文件 输出 (Output) 到硬盘中。

    ②把内存中的文件 写 (Write)到硬盘中。

在这里插入图片描述

  • 不管是输入还是输出，参照物都是内存。
  • 从内存出来 (到硬盘中)，叫输出。
  • 进内存中 (从硬盘进到内存中)，叫输入。

3.IO

I: 输入 (Intput)

O : 输出 (Output)

通过 IO (输入 和 输出)可以完成硬盘文件的读和写。

4.IO流

在读和写的过程中，会产生 数据的流动，叫 IO流 (Input/Output Stream) 。

5.IO流的分类：

5.1 分类总述

  • Java IO 有 四大家族：

  • 四大家族的首领为：

    • java.io.**InputStream **(字节输入流)
    • java.io.OutputStream(字节输出流)
    • java.io.Reader(字符输入流)
    • Java.io.Writer (字符输出流)

  • 四大家族的首领都是抽象类 ( abstract class )

  • 在java中：

    以类名 “Stream” 结尾的都是字节流。 以 “Reader / Writer” 结尾的都是字符流。

    如：
    java.io.BufferedReader 为字符流 ，其是java.io.Reader的子类。

    java.io.FileInputStream 是字节流，其是java.io.InputStream 是子类。

  • 所有流实现了java.io.Closeable接口，都是可关闭的，都有close()方法，流毕竟是一个管道，是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费 (占用) 很多资源。用完流一定要关闭。
  • 所有的输出流都实现了java.io.Flushable接口，都是可刷新的，都有flush()方法。输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示通道/通道当中剩余的数据强行输出完 (清空管道!)，刷新的作用就是清空管道。
    如果没有flush()可能导致数据丢失。

5.2 按照 “流的方向” 进行分类

  • 按照**流的方向**进行分类分为：
    java.io.InputStream : 字节输入流
    java.io.OutputStream : 字节输出流

  • 字节流输入流 (InputStream) 是 读取字节数据的输入流。

  • 字节流输出流 (InputStream) 是 写入字节数据的输出流。

  • 字节流按照字节的方式读取数据，一次读取一个字节byte ( 即一次读取8个二进制位)，字节流是万能的，
    什么类型的文件都可以读取。包括文本文件、图片、声音文件、视频文件等。

  • 例子如：

    假设文件file.txt中有以下字符组合 ，采用字节读的话就是：

    a中国bc张三fe

    第一次读：读一个字节，读到 ‘a’

    第二次读：读一个字节，读 ‘中’的一半

    第三次读：读一个字节，读 ‘中’的另一半

    第四次读：读一个字节，读 ‘国’的一半

    第五次读：读一个字节，读 ‘国’的另一半

    第六次读：读一个字节，读 ‘b’

5.3 按照 “读取数据的方式” 进行分类

  • 按照 读取数据的方式 进行分类：

  • java.io.Reader: 字符输入流
    java.io.Writer: 字符输出流

    例子如：

    假设文件file.txt中有以下字符组合 ，采用字符流读的话就是：
    a中国bc张三fe

    第一次读：读一个字节，读到 ‘a’

    第二次读：读一个字节，读 ‘中’的一半

    第三次读：读一个字节，读 ‘中’的另一半

    第四次读：读一个字节，读 ‘国’的一半

    第五次读：读一个字节，读 ‘国’的另一半

    第六次读：读一个字节，读 ‘b’

注意：

  • 在windows系统中，一个英文字符‘a’占一个字节，一个中文字符‘中’占两个字节。
  • 但在Java，一个英文字符‘a’占二个字节，一个中文字符‘中’占两个字节。（因为‘a’ 字符、‘中’字符 都是char类型，char类型占两个字节）。
  • 上面的file.txt文件是windows操作系统上的普通文件，文件中‘a’占一个字节 ,‘中’占两个字节。
  • 如果我们用java打开这个file.txt文件，如果用字节流读取，一个字节一个字节 (8个二进制位) 那样读取会识别不了，但如果用字符流进行读取，就可以识别（能一个字符一个字符的进行读取）。

6.IO包下要重点掌握的流：

6.1 文件专属 (流)

  • java.io.FileInputStream ：文件字节输入流 (重点掌握)
  • java.io.FileOutputStream ：文件字节输出流 (重点掌握)
  • java.io.FileReader ：文件字符输入流
  • java.io.FileWriter ： 文件字符输出流

6.2 转换流 ( 将字节流转换为字符流 )

java.io.InputStreamReader : 将“字节输入流” 转换为 “字符输入流”

java.io.OutputStreamWriter : 将“字节输出流” 转换为 “字符输出流”

6.3 缓冲流专属

java.io.BufferedReader

java.io.BufferedWriter

java.io.BufferedInputStream

java.io.BufferedoutputStream

6.4 数据流专属

java.io.DataInptStream : 字节数据输入流

java.io.DataOutputStream：字节数据输出流

6.5 打印输出流

java.io.printWriter

java.io.printStream : (重点掌握)

6.6 对象流专属

java.io.ObjectInputStream (重点掌握)

java.io.ObjectOutputStream (重点掌握)

7.字节流：

7.1 文件字节输入流 (FileInputStream)

7.1.1 read( )方法
  • 从输入流中读取一个字节的数据。
  • 文件字节输入流是万能的，任何类型的 文件 都可以用这个流来读，以 字节 的方式完成 读 的操作。

例子如：

public class FileInputStreamTest01 {   //文件输入流
 public static void main(String[] args) throws IOException {
     //创建文件字节输入流对象
     FileInputStream fis = null;

     try {
         fis = new FileInputStream("D:\\file.txt");
         int readData;
         char DataInfo;

         //读入一个字节的数据(的Unicode值)，如果到达文件末尾返回-1
         while ((readData = fis.read()) != -1) {
              DataInfo = (char) readData; //将unicode值转换为具体的字符
             System.out.println(DataInfo);
         }
     } catch (FileNotFoundException e) {
         e.printStackTrace();
     } catch (IOException e) {
         e.printStackTrace();
     }finally { //在finally语句中确保流的关闭
         if (fis != null) { //关闭流的前提是: 流不是空 ，流是null是没必要关闭
             //关闭输入流
             fis.close();
         }
     }
 }
}

public class FileInputStreamTest02 {   //文件输入流
 public static void main(String[] args) throws IOException {
  FileInputStream fis = null;
     try {
         //创建文件字节输入流
         fis = new FileInputStream("D:\\file.txt");

         while (true) {
             int readData =  fis.read();
             if (readData == -1) {
                 break;
             }
             char DataInfo = (char) readData;
             System.out.println(DataInfo);
         }

          //改造上面的while语句
          int readData =  0;
         while ((readData = fis.read()) != -1) {

         }

     } catch (FileNotFoundException e) {
         e.printStackTrace();
     }finally {
         if (fis != null) {
             try {
                 fis.close();
             } catch (IOException e) {
                 e.printStackTrace();
       }
  }
}
7.1.2 read( byte[ ] b )方法

  • 从该输入流中读取最多b.length个字节的数据作为字节数组。

  • 上面的.read( )方法 一次读取一个字节byte，这样内存和硬盘交互太频繁了，基本上时间/资源耗费在交互上，能不能一次读取多个字节呢？

    可以，用 read( byte[ ] b ) 方法从输入流中读取b.length个字节数据，且返回一个byte数组 (字节数组 )。

    例子如：

//文件字节输入流的 read(byte[] b)方法 : 获得指定长度的字节，存储到字节数组中
public class FileInputStream04 {
 public static void main(String[] args) {
     try (
          //创建文件字节输入流对象
 FileInputStream fis = new FileInputStream("D:\\file.txt")) { //里面有 abcdef
         //创建存储字节数组，用以存储读取的数据
         byte[] bytes = new byte[5];
         int bytesReadNum = 0;

         /**
             * 从字节数组中逐个输出字节数据
          */
         //返回值为读到的字节数，如果到字节末尾返回值为-1
         while ((bytesReadNum=fis.read(bytes))!= -1) {
             // 处理读取到的字节数据 (将每个字节数据都转换为char类型数据)
             for (int i = 0; i < bytesReadNum; i++) { //逐个输出字节数据
                 System.out.print((char) bytes[i]);  //不换行输出 : abcdef
             }
         }
        } catch (IOException e) {
         e.printStackTrace();
     }
 }
}

//文件字节输入流的 read(byte[] b)方法 : 获得指定长度的字节，存储到字节数组中
public class FileInputStream04 {
 public static void main(String[] args) {
     try (
          //创建文件字节输入流对象
FileInputStream fis = new FileInputStream("D:\\file.txt")) { //里面有 abcdef
         //创建存储字节数组，用以存储读取的数据
         byte[] bytes = new byte[5];
         int bytesReadNum = 0;
          /**
             * 将获得的字节数组转换为“字符串”且输出
          */
         //返回值为读到的字节数，如果到字节末尾返回值为-1
         //输出内容为: 第一行: abcde  第二行: fg
         while ((bytesReadNum=fis.read(bytes))!= -1) {  
 System.out.println(new String(bytes,0,bytesReadNum)); //将字节数组转换为字符串
         }
     } catch (IOException e) {
         e.printStackTrace();
     }
 }
}

文件字节输入流的最终工作规范版本：

public class FileInputStream05 { //文件字节输入流-最终版（工作规范版）
 public static void main(String[] args) {
     FileInputStream fis = null;

     try {
          fis = new FileInputStream("D:\\file.txt");
          //准备一个byte数组
         byte[] bytes = new byte[5];
         while (true) {
             int readCount = fis.read(bytes);
             if (readCount==-1) {
                 break;
             }
             //如果文件还未到末尾,同时输出上面获得的（字节数组转换成的）字符串
             //读到多少个就输出多少个，没有读到就是-1
             System.out.println(new String(bytes,0,readCount));
         }
         
//     while ((bytesReadNum=fis.read(bytes))!= -1) {
//     System.out.println(new String(bytes,0,bytesReadNum)); //将字节数组转换为字符串
//  }
     } catch (FileNotFoundException e) {

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

  • 注意点：

    IDEA中默认的当前路径是Project的根 / 根路径。

7.1.3 available( )方法

  • 返回从输入流中可以读取 / 跳过的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。

    例子如：

    public class FileInputStream06 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
             fis = new FileInputStream("D:\\file.txt"); // 其中的内容为: abcdefg (7个字符/7个字节)
             //读一个字节
            int Byte = fis.read();
            //从该输入流中可以读取/跳过的字节数
            int availableCount = fis.available();
            System.out.println("剩下多少个字节没读: "+availableCount); // 6
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
7.1.4 skip(long n)方法

  • 跳过并从输入流中丢弃n个字节的数据。

    例子如：

    public class FileInputStream07 {
    public static void main(String[] args) { // skip()方法: 跳过几个字节不读
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\file.txt"); // 其中的内容为: abcdefg (7个字符/7个字节)
            //用skip(long on)方法跳过指定的字节数
            fis.skip(3);
            //读一个字节
            int byte_num = fis.read();
            System.out.println((char) byte_num); // d (前面已跳过了三个字节)
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7.2 文件字节输出流 (FileOutputStream)

7.2.1 write(byte b)方法

  • 将b.length字节从指定的字节数组写入文件输出流。 （将字节数据写入到文件中）

    例子1如：在文件开始处写入数据（覆盖）

    //在文件开始处写入数据（覆盖）
public class FileOutputStreamTest01 { //文件字节输出流
    public static void main(String[] args) {
        try {
          //假设文件中有：: 123
         FileOutputStream fos = new FileOutputStream("D:\\file.txt"); //覆盖
            //创建一个byte数组
            byte[] bytes = {97,98,99,100,101};
            //用文件字节输入流进行存储
            fos.write(bytes); //写 abcde 到文件(硬盘)中，文件最后有: abcde
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    例子2如：在文件末尾处写入数据（追加）

    public class FileOutputStreamTest01 { //文件字节输出流
    public static void main(String[] args) {
        try {
            //假设文件中有：: 123
    FileOutputStream fos = new FileOutputStream("D:\\file.txt",true); //追加
            //创建一个byte数组
            byte[] bytes = {97,98,99,100,101};
            String str = "世界你好!";
            byte[] byte_Info =str.getBytes();

            //用文件字节输入流进行存储
            fos.write(bytes); //写 abcde 到文件(硬盘)中,文件中最后有:  123abcde
            fos.write(byte_Info);
            //最后文件中的信息为: 123abcde世界你好!
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
7.2.2 write(byte b , int off ,int len) 方法

  • 将len字节从位偏移量off的指定数组写入此文件的输出流。（将指定范围的字节写入到文件中）

    例子如：

    public class FileOutputStream02 {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("D:\\file.txt");
            //创建一个byte数组
            byte[] bytes = {97,98,99,100,101}; //数字分别代表: a b c d e
             /*
               用文件字节输入流进行存储
               将len字节从位偏移量off的指定数组写入此文件的输出流。（将指定范围的字节写入到文件中）
             */
            fos.write(bytes,0,3); //写 abc 到文件(硬盘)中
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8.字符流

8.1 文件字符输入流 ：FileReader

  • 文件字符输入流，只能读取普通文本，读取文本内容时，比较方便、快捷。（读取文件中的字符）
  • 文件字符输入流读取文件中的字符，一个字符一个字符地读取。
8.1.1 int read( ) 方法

  • 读取单个字符。返回值为 int类型数据 (代表该字符的 unicode码 ) ，如果达到文件末尾，则返回-1

    例子如：

    public class FileReader01 { //文件字符输入流 : 一个一个字符的读取
    public static void main(String[] args) {
        try {
            //创建文件字符输入流
            FileReader fr = new FileReader("D:\\file_reader.txt");
            int readCount = 0;
            //如果到达文件末尾则返回值为-1，否则返回值为字符的unicode值 (int)
            while ((readCount = fr.read()) != -1) { 
                System.out.print((char)readCount);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
8.1.2 int read( char c ) 方法

  • 返回多个字符，且将字符存入到字符数组中。返回为读取到的字符个数，如果达到文件末尾，则返回-1。

    例子如：

    public class FileReader01 {
    public static void main(String[] args) {
        FileReader fr =null;
        try {
            //创建文件字符输入流
            fr = new FileReader("D:\\file_reader.txt");
            char[] chars = new char[5];
            int readcount = 0;
            while ((readcount = fr.read(chars)) != -1) {
                //将获得的字符数组 转换为 字符串
                //读取到多少个，则输出多少个
       	   System.out.print(new String(chars,0,readcount)); 
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

8.2 文件字符输出流：FileWriter

8.2.1 void write( )方法

  • 向文件中写入字符数据。

    例子如：

    public class FileWriter01 {
    public static void main(String[] args) {
        try {
            FileWriter fw = new FileWriter("D:\\file.txt");
            //100, 101, 102 ,103  分别代表字符 d e f g
            char[] chars = {'中', '国'};

            fw.write("世界你好!");
            fw.write(100);
            fw.write(chars);
            fw.write(chars,0,2);

            fw.flush(); //刷新该输出流
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

9.文件复制：

9.1 用文件字节输入流 + 文件字节输出流

  • 使用FileInputStream + FileOutputStream完成文件的拷贝。（一边读一边拷贝）

  • 文件字节输入流是万能的，什么类型的文件都能读取。

    例子如：

    public class FileCopy {  //文件复制
    public static void main(String[] args)  {
        FileInputStream fis =null;
        FileOutputStream fos =null;
        //创建文件输入流 和 文件输出流 ，以此来进行文件复制
        try {
      fis = new FileInputStream("D:\\file1.txt"); // file1.txt中内容为: 世界你好!
             fos =new FileOutputStream("D:\\file2.txt");

             byte[] byte_Info = new byte[1024]; //存储在文件中获得的信息
             
             //从硬盘(文件)中读取文件进内存
            int readCount = 0;
            while ((readCount = fis.read(byte_Info)) != -1) {
               //存储获得信息进新的文件中
                fos.write(byte_Info); //此时 file2.txt中内容为: 世界你好!
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

9.2 用文件字符输入流 + 文件字符输出流

  • 使用FileReader + FileWriter完成文件的拷贝。（一边读一边拷贝）

  • 使用文件字符输入流 和 文件字符输出流，只能拷贝“普通文本”文件
    (能用记事本编译的都是“普通文本”文件，不一定都是.txt文件)

    例子如：

    public class FileCopy2 { //使用字符输入流 和 字符输出流 进行文件复制
    public static void main(String[] args) throws IOException {
        FileReader fr = null;
        FileWriter fw = null;
        try {
             fr = new FileReader("D:\\file1.txt");
             fw = new FileWriter("D:\\file2.txt");

             char[] chars =new char[5];
             int readCount = 0;
            while ((readCount = fr.read(chars)) != -1) {
                //一遍读取一遍写入新的文件
                fw.write(chars,0,readCount);
            }
            //刷新
            fw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fr != null) {
                fr.close();
            }
            if (fw != null) {
                fw.close();
            }
        }
    }
}

10.缓冲流：

10.1 缓冲输入流 (BufferedReader)

BufferedReader ：带有缓冲区的字符输入流。使用这个流不需要自定义char数组、byte数组，自带缓冲。

10.1.1 String readLine( )方法

  • 读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (‘\n’)、回车 (‘\r’) 或回车后直接跟着换行。

  • 如果已到达流末尾，返回值为null 。

  • readLine( )方法 读取一个文本行，但 不包括换行符。

    例子如：

    public class BufferedReader01 { // 带有缓冲区的字符输入流
    public static void main(String[] args) throws IOException {
         /**
            file.txt文件的内容为: (两行数据) :
            世界你好!中国中国
            1231234helloWorld
         */
        FileReader fr = new FileReader("D:\\file.txt"); //此时其为: 节点流
        BufferedReader br = new BufferedReader(fr);  //此时其为: 包装流
        String s = null;
   //读取一行数据，遇到"换行符"或"回车符" 会自定结束读取; 如果已到达流末尾，返回值为null
        while ((s = br.readLine()) != null) {
            /**
             * 第一次循环输出: 世界你好!中国中国
             * 第二次循环输出: 1231234helloWorld
             */
            System.out.println(s);
        }
        //关闭流
        br.close();
    }
}

10.2 缓冲输出流 (BufferedWriter)

  • BufferedReader ：带有缓冲区的字符输出流。使用这个流不需要自定义char数组、byte数组，自带缓冲。

    例子如：

    public class BufferedWriter01 { //缓冲字符流
    public static void main(String[] args) {
       //带有缓冲区的字符输出流
        try {
            BufferedWriter out = new BufferedWriter(new FileWriter("D:\\file.txt"));
            //开始写（将数据写入到文件中）
            out.write("helloWorld");
            out.write("\n");
            out.write("12345");
            //刷新
            out.flush();
            //关闭最外层
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

11.节点流

  • 当一个流的构造方法中需要一个流的时候，这个（作为参数）被传进来的流叫：节点流。

  • 外部负责包装的流叫：包装流 / 处理流。

  • 对应包装流来说，只需要关闭最外层就行，里面的节点流会自动关闭。

    例子如：

    // 代码中包括了: 包装流、节点流
public class BufferedReader01 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\\file.txt"); //FileReader :节点流
        BufferedReader br = new BufferedReader(fr);  //BufferedReader: 包装流
        String s = null;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        //关闭流
        br.close();
    }
}

12.包装流/处理流

  • 当一个流的构造方法中需要一个流的时候，这个（作为参数）被传进来的流叫：节点流。

  • 外部负责包装的流叫：包装流 / 处理流。

  • 对应包装流来说，只需要关闭最外层就行，里面的节点流会自动关闭。

    例子如：

    // 代码中包括了: 包装流、节点流
public class BufferedReader01 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\\file.txt"); //FileReader :节点流
        BufferedReader br = new BufferedReader(fr);  //BufferedReader: 包装流
        String s = null;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        //关闭流
        br.close();
    }
}

13.转换流

  • 转换流 ：将字节流转换为字符流

  • InputStreamReader : 将字节输入流 转换 为 字符输入流

  • OutputStreamWriter ：将字节输出流 转换为 字符输出流

    例子如：

    public class InputStreamReader01 { //
    public static void main(String[] args) throws IOException {

        FileInputStream fis = new FileInputStream("D:\\file.txt");
        //使用转换流 : 将“字节流”转换为“字符流”
        InputStreamReader reader = new InputStreamReader(fis);
        /**
          BufferedReader()构造方法: 参数为: Reader类对象
          但上面只有FileInputStream对象，可用“缓冲流”: 将“字节流”转换为“字符流”
         */
        BufferedReader br = new BufferedReader(reader);
        String s = null;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        //关闭流
        br.close();
    }
}

    public class InputStreamReader01 {
    public static void main(String[] args) throws IOException {
        //合并
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\file.txt")));
        String s = null;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        //关闭流
        br.close();
    }
}

14.数据流

14.1 字节数据输出流 (DataOutptStream)

  • 输出数据专属的流。这个流可以将数据连同数据类型一并 写入文件。
    (这个文件不是普通的文本文件，其不能用记事本打开，用记事本打开会乱码)

  • 写的文件，只能用DataInputStream ( 数据字节输入流 )去读。并且读的时候需要提前知道写入的顺序。读的顺序和写的顺序一致，才可以正常取出数据。

    例子如：

    public class DataOutputStream01 { //字节数据输出流
    public static void main(String[] args) {

        try {
            //创建数据专属的字节输出流
		DataOutputStream dos =new DataOutputStream(new    	 FileOutputStream("D:\\file.txt"));
            byte b =100;
            short s =200;
            int i =300;
            float f =3.0F;
            long l =400;
            double d =3.14;
            boolean istrue =false;
            char c = 'a';

            //把 “数据” 连同 “数据类型” 一并写入文件当中。
            dos.writeByte(b);
            dos.writeShort(s);
            dos.writeInt(i);
            dos.writeLong(l);
            dos.writeFloat(f);
            dos.writeBoolean(istrue);
            dos.writeChar(c);

            //刷新
            dos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

14.2 字节数据输入流 (DataInptStream)

  • 用数据流写入的文件，只能用DataInputStream (数据字节输入流)去读。并且读的时候需要提前知道写入的顺序。读的顺序和写的顺序一致，才可以正常取出数据。

    例子如：

    public class DataInputStream01 {  //字节数据输入流
    public static void main(String[] args) {
        try {
            //创建字节数据输入流
            DataInputStream dis = new DataInputStream(new FileInputStream("D:\\file.txt"));
            byte b=dis.readByte();
            short s=dis.readShort();
            int i = dis.readInt();
            long l = dis.readLong();
            float f = dis.readFloat();
            double d = dis.readDouble();
            boolean istrue = dis.readBoolean();
            char c = dis.readChar();

            //打印通过“字节数据输入流”得到的数据
            System.out.println(b);
            System.out.println(s);
            System.out.println(i);
            System.out.println(l);
            System.out.println(f);
            System.out.println(d);
            System.out.println(istrue);
            System.out.println(c);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

15.打印流

15.1 打印输出流

  • 打印输出流 (printStream) : 默认输出到控制台， 标准输出流不需要手动close( )关闭 。

  • 可修改输出方向，将输出方向指向具体的文件，此时不再将信息输出到控制台。（这是日志框架的实现原理）

    例子如：

    // PrintStream : 打印输出流，默认输出到控制台
public class PrintStream01  {
    public static void main(String[] args) throws FileNotFoundException {
        /**
         * PrintStream : 打印输出流，默认输出到控制台
         * (默认的输出方向为: 控制台)
         */
        //联合起来写
        System.out.println("Hello,World");

        //分开写
        //System.out的返回值为 : 打印输出流
        PrintStream ps = System.out;
        ps.println("hello,zhangsan");
        ps.println("hello,lisi");
        ps.println("hello,wangwu");


        /**
         * 修改打印输出流的 “输出方向”
         *
         * 修改输出方法为: D盘下的log文件，打印数据到该文件上
         */
        //打印输出流不再指向控制台，指向“log”文件
        PrintStream ps2 = new PrintStream(new FileOutputStream("D:\\log"));
        //修改输出方向，将输出方向修改到“log”文件
        System.setOut(ps2); 

      //打印输出流，不需要手动close()关闭
    }
}

15.2 用“打印输出流” 编写 “日志工具”

  • 通过 修改输出方向，将输出方向指向具体的文件，来编写“日志工具”，收集日志信息。

    例子如：

    /**
 * 日志工具
 */
public class Logger {

    /**
     *  记录日志的方法
     */
    public static void log(String msg) {
        try {
            //创建“打印输出流” : 指向一个日志文件
            PrintStream out = new PrintStream(new 	 	          				        FileOutputStream("log.txt"));
            //修改默认输出方法
            System.setOut(out);
            //获得当前时间
            Date nowTime = new Date();
            //格式化时间
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = sdf.format(nowTime);

            System.out.println(strTime+": "+msg);

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

    日志工具类的测试类 例子：

    public class LogTest {
    public static void main(String[] args) {
        //测试工具类是否好用
        Logger.log("hello!");
        Logger.log("调用了System类的gc()方法，建议启动垃圾回收");
        // ...
    }
}

16.拷贝目录 ： 拷贝指定 “文件夹” 下的 “所有子文件夹和文件” （到 “ 别的路径” 下）

  • 拷贝目录 ： 拷贝指定 “文件夹” 下的 “所有子文件夹和文件” （到 “ 别的路径” 下）

    例子如：
    （有注释版例子 和 简洁版/少注释版例子）

    /**
 *  拷贝目录
 */
public class CopyAll4 {
    public static void main(String[] args) {
        /**
         * 目的的:
         * 将 D:\\apple目录下的所有子目录或文件 复制一份 且放到  S:\\123 路径下
         */
        //拷贝源
        File srcFile = new File("D:\\apple");

        //拷贝目标
        File tarFile = new File("S:\\123");

        try {
            //调用方法完成 “目录拷贝”
            copyDir(srcFile,tarFile);

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

    }

    /**
     *
     * @param srcFile 拷贝源
     * @param tarFile 拷贝目标 (要复制到具体哪个盘符下的 什么文件夹)
     */
    private static void copyDir(File srcFile, File tarFile) throws IOException {
        //判断该File对象是否是“文件”
        //如果是文件要进行“读”和“写” , 如果不是则跳过该if语句，执行下面代码
        if (srcFile.isFile()) {
            //是文件进行"读"和"写"
            FileInputStream in = null;
            FileOutputStream out = null;

            in = new FileInputStream(srcFile);

            /**
             *  通过拼接得到 “要被写入信息” 的 “文件的路径”
             *
             *  如: D:\\apple\\aaa\\ccc\\123.txt
             *  结合目标目录: S:\\123 那就要拼接出 : S:\\123 + \\ + 			   	 			*  apple\\aaa\\ccc\\123.txt
             *  拼接代码如下，拼接得到的path被用于创建 FileOutputStream 中
             */
            // D:\\apple\\aaa\\ccc\\123.txt
            // S:\\123 + \\ + apple\\aaa\\ccc\\123.txt
            String path = tarFile.getAbsolutePath().endsWith("\\") ? tarFile.getAbsolutePath() : tarFile.getAbsolutePath() + "\\" + srcFile.getAbsolutePath().substring(3);
            byte[] bytes = new byte[1024 * 1024];  //一次复制1MB

            int readCount = 0;  // read(bytes)方法返回值为: 读取的字节数
            out = new FileOutputStream(path);
            while ((readCount = in.read(bytes)) != -1) {
                //边读边写
            out.write(bytes,0,readCount); //读到多少就写多少
        }
            //刷新流
            out.flush();
            return;
    }

        //获得该目录下的所有File对象
        File[] files = srcFile.listFiles();
         for (File file : files) {
            //判断该File对象是否是文件夹/目录
            //如果该File对象是一个文件夹，要对其进行创建。（同时也要在if语句之后用递归，因		       为文件夹中可能也有子文件夹或子文件）
            if (file.isDirectory()) {

                //获得此时File对象的 真实路径
                String srcDir = file.getAbsolutePath();
                //拼接出要创建的目录/文件夹的 路径,然后创建紧接着创建该目录
                // S:\\123 + \\ + apple\\aaa
                String tarDir = tarFile.getAbsolutePath().endsWith("\\") ? tarFile.getAbsolutePath() : tarFile.getAbsolutePath() +"\\" + srcDir.substring(3);
                //创建该目录
                File newFile = new File(tarDir); // S:\\123\\apple\\aaa
                newFile.mkdirs();
                //在if语句外面进行递归，无论该File对象是文件夹 还是 文件，都要进行递归。
            }

            //无论循环中的File对象是文件夹还是文件都要进行递归。为其创建子目录 或 子文件
            // 因为是文件夹，所以还要进去文件夹中判断里面是否还有子文件夹 或 子文件 : 递归
            //方法递归
            copyDir(file,tarFile);
        }
    }
}

    简洁版/没注释版：

    /**
 *  拷贝目录
 */
public class CopyAll4 {
    public static void main(String[] args) {
        /**
         * 目的的:
         * 将 D:\\apple目录下的所有子目录或文件 复制一份 且放到  S:\\123 路径下
         */
        //拷贝源
        File srcFile = new File("D:\\apple");

        //拷贝目标
        File tarFile = new File("S:\\123");

        try {
            //调用方法完成 “目录拷贝”
            copyDir(srcFile,tarFile);

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

    }

    /**
     *
     * @param srcFile 拷贝源
     * @param tarFile 拷贝目标 (要复制到具体哪个盘符下的 什么文件夹)
     */
    private static void copyDir(File srcFile, File tarFile) throws IOException {
        //判断该File对象是否是“文件”
        if (srcFile.isFile()) {
            //是文件进行"读"和"写"
            FileInputStream in = null;
            FileOutputStream out = null;

            in = new FileInputStream(srcFile);

            /**
             *  通过拼接得到 “要被写入信息” 的 “文件的路径”
             */
            // D:\\apple\\aaa\\ccc\\123.txt
            // S:\\123 + \\ + apple\\aaa\\ccc\\123.txt
            String path = tarFile.getAbsolutePath().endsWith("\\") ? tarFile.getAbsolutePath() : tarFile.getAbsolutePath() + "\\" + srcFile.getAbsolutePath().substring(3);
            byte[] bytes = new byte[1024 * 1024];  //一次复制1MB

            int readCount = 0;  // read(bytes)方法返回值为: 读取的字节数
            out = new FileOutputStream(path);
            while ((readCount = in.read(bytes)) != -1) {
                //边读边写
                out.write(bytes,0,readCount); //读到多少就写多少
            }
            //刷新流
            out.flush();
            return;
        }

        //获得该目录下的所有File对象
        File[] files = srcFile.listFiles();
        for (File file : files) {
            //判断该File对象是否是文件夹/目录
            if (file.isDirectory()) {

                //获得此时File对象的 真实路径
                String srcDir = file.getAbsolutePath();
                String tarDir = tarFile.getAbsolutePath().endsWith("\\") ? tarFile.getAbsolutePath() : tarFile.getAbsolutePath() +"\\" + srcDir.substring(3);
                //创建该目录
                File newFile = new File(tarDir); // S:\\123\\apple\\aaa
                newFile.mkdirs();
            }

            copyDir(file,tarFile);
        }
    }
}
一只大皮卡丘
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaSE|IO流：FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream
笔记本
12-11 239
JavaSE|IO流IO流分类FileOutputStream构造方法成员方法常见问题加入异常处理FileInputStream构造方法成员方法字节缓冲流BufferedOutputStream构造方法BufferedInputStream构造方法 IO流用来处理设备之间的数据传输。 Java对数据的操作是通过流的方式。 Java用于操作流的对象都在IO包中。 IO流分类 按照数据流向 – 输入...
JavaSE之io流
weixin_51985152的博客
02-21 288
流的分类： 根据流的操作的方式分类：输入流和输出流 根据数据的类型分类：字节流和字符流 字节流：传输的是字节，可以传输任意类型的数据。----视频，音频，文件，图片等。 字符流：传输的也是字节，不同点在于传输过程中加入了编码的操作，让我们在传输字符的时候更加便捷。----文件。 字节流：–对应的父类 字节输入流：InputStream 字节输出流：OutputStream 字符流：–对应的父类 字符读入流（将数据输入内存）：Reader 字符写出流（将数据从内存取出）：Writer 流的体系 缓
【JavaSE】IO流
m0_64098804的博客
03-19 705
【学习记录】Java后端路线，Java核心语法，关于IO的那些事儿。
JavaSE之IO流
weixin_47543906的博客
11-12 480
FileInputStream构造器 FileInputStream(String name) FileInputStream(File file) FileInputStream读数据方法 int read() 从输入流读取一个字节,返回读取的字节数据 int read(byte b[]) 从输入流读取一个字节数组,返回读取的数量
JavaSE—IO流
小宝的博客
01-29 401
苦难，是化了妆的祝福。 和大家一起学习Java IO流。
JavaSE进阶IO流
Hello_super的博客
11-15 343
FileInputStream | FileOutputStream | FileReader | FileWriter | InputStreamReader | OutputStreamWriter | ObjectInputStream | ObjectOutputStream | PrintWriter | PrintStream
JAVASE之IO流
unknown09的专栏
11-29 426
Java流操作有关的类或接口： Java流类图结构：   流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。  IO流的分类 根据处理数据类型的不同分为：字符流和字节流根据数据流向不同分为：输入流和输出流   字符流和字
javaSE 之io流
qq_45551151的博客
08-05 126
关于JavaEE IO流
javase的IO流
qq_42991138的博客
08-16 139
IO数据流的介绍及模板 1. IO流的介绍 IO流用来处理设备之间的数据传输，上传文件和下载文件，Java对数据的操作是通过流的方式。 2. Io流的分类 按照数据流向： 输入流 ： 读入数据 输出流 ： 写出数据 按照数据类型： 字节流（一般情况使用字节流） ...
javase:IO流
qq_46128504的博客
09-26 65
javase:IO流IO流引入IO流分类IO流的访问方式分类RandomAccessFile类原理RandomAccessFile类API IO流引入 1.图灵模型 2.IO流概述 以应用程序为参照物，读取数据为输入流（input），写数据为输出流OutPut，大量输入输出数据简称IO流 IO流原理 IO流分类 1.读写的文件分类 ①二进制文件：打开之后是乱码，或者是16进制无法生成文字的文件。例如：视频，音频，图片，exe，dll文件等 尔文本文件：打开文件内容可直接阅读。例如：记事本，java程序，网页
JAVASE，IO流部分模块导图
01-13
里面包含了字节输入输出流、字符输入输出流的接口继承以及具体...适用于：初学者：能更清晰地认清javaSE的IO流部分接口与实现类之间的关系。 其他人：要使用IO部分但忘记具体的实现类和常用方法可以充当帮助文档使用。
JavaSe基于IO流的用户管理系统
02-19
使用IO流实现文本存储，集合存放用户信息，使用了stream流等java8新特性，适用于大学生大作业、课设，本人原创
JavaSE文件IO流详解.pptx
06-08
JavaSE文件IO流详解
10、JavaSE：IO流.pdf
04-24
看B站视频项目总结的系列文档，仅供个人学习使用
JavaSE专题-IO流重点总结(必读).doc
06-03
Try块里面存放的是有可能发生异常的代码,通常和catch块一起使用,catch块用于处理try块中抛出的异常,finally块不是必须的,通常将释放资源(例如IO流的close方法)的代码放到finally块里面 注意:finally和Final还有...
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 321
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 604
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 544
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 410
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
javaSE基础项目实战
06-01
4. IO流操作练习：包括JavaSE中的文件读写操作、网络编程等IO流操作的练习。 5. 多线程编程练习：包括JavaSE中的多线程编程知识，如线程的创建、同步、互斥等的练习。 6. 数据库操作练习：包括JavaSE中的数据库...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值