java文件的读写操作(字节流)

小鱼儿 2022-08-29 15:55 167阅读 0赞

[java的IO][java_IO]

### 文章目录 ###

*  java文件的读写操作(字节流)
 *   *   *  InputStream和FileInputStream
         *   *   *  InputStream和FileInputStream的常用方法
                 *  示例
         *  OuputStream和FileOuputStream
         *   *   *  OutputStream和FileOutputStream的常用方法
                 *  示例
         *  实现文件的复制

# java文件的读写操作(字节流) #

上篇博文提到了File类和流的概念，这篇博文将详细介绍具体的使用:

### InputStream和FileInputStream ###

##### InputStream和FileInputStream的常用方法 #####

*  InputStream类的常用方法
    
    > int read()从输入流一个字节一个字节的读，返回的是该字节的整数表示形式，如果读到了输入流的末尾，返回-1
    > 
    > int read(byte\[\] b)从输入流读取若干的字节，将这些字节保存到数组b中，返回的是读取到的字节数，如果读到了输入流的末尾，返回-1
    > 
    > int read(byte\[\]b ,int off,int len)从输入流读取若干字节，把这些字节保存在数组b中。off指的是字节数组中开始保存数据的起始下标，len指的是读取的字节数目，返回的是实际读取到的字节数，如果读到了输入流的末尾，返回-1
    > 
    > void close():关闭输入流
    > 
    > int available():可以从输入流中读取的字节数目

InputStream是作为抽象基类，创建对象的话是需要它的子类FileInputStream。

*  子类FileInputStream常用的构造方法
    
    > FileInputStream(File file)
    > 
    > FileInputStream(String pathname)

##### 示例 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70]

前提是:当前项目中创建一个test.txt文件，从中写入一串文字，保存退出.

package Test;
    //1.引入相关的流
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    //通过字节输入流完成对文件的读操作
    public class FileInputStreamDemoTest { 
        public static void main(String[] args) { 
            FileInputStream fis = null;
    
            try { 
                //2.创建FileInputStream对象
                fis = new FileInputStream("E:\\file\\code\\java\\day01\\src\\Test\\test.txt");
                //3.借助FileInputStream对象的read()方法读取文件
                /* System.out.println("\n可以读取到的字节数:" + fis.available()); int data;读取到的每个字节的整数表示形式 while ((data = fis.read()) != -1) { System.out.print((char) data); } System.out.println("\n可以读取到的字节数:" + fis.available()); */
                //3.借助FileInputStream对象的read(byte[])方法读取文件
                byte[] b = new byte[1024];
                int data;//读取到的字节数
                while ((data = fis.read(b)) != -1) { 
                    //字节读取到了字节数组b中，需要循环输出
                    for (int i = 0; i < data; i++) { 
                        System.out.print((char) b[i]);
                    }
                }
            } catch (FileNotFoundException e) { 
                e.printStackTrace();
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                //4.关闭输入流
                try { 
                    fis.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

### OuputStream和FileOuputStream ###

##### OutputStream和FileOutputStream的常用方法 #####

*  OutputStream的常用方法
    
    > void write(int c)往输出流中写入一个一个的字节
    > 
    > void write(byte\[\] buf)往输出流中写入一个字节数组
    > 
    > void write(byte\[\] b,int off,int len):往输出流中写入一个字节数组，off代表开始从字节数组的off位置开始往外写，len代表往外写len长度的字节
    > 
    > void close():关闭输出流
    > 
    > void flush():强制把缓冲区的数据写到输出流中
    
    OutputStream是一个抽象基类，要创建对象需要它的子类FileOutputStream。
 *  子类FileOutputStream的常用构造方法
    
    > FileOutputStream(File file)
    > 
    > FileOutputStream(String pathname)
    > 
    > FileOutputStream(String pathname,bool append)

前两种构造方法在向文件中写数据时将覆盖文件中的原有的内容  
创建FileOutputStream示例时，如果相应的文件并不存在，则会自动创建空的文件

##### 示例 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 1]

package Test;
    //1.引入资源
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    //借助字节输出流完成对文件的写入操作
    public class FileOutputStreamDemoTest { 
        public static void main(String[] args) { 
            FileOutputStream fos = null;
            try { 
                //2.创建字节输出流对象(FileOutputStream)
                fos = new FileOutputStream("E:\\file\\code\\java\\day01\\src\\Test\\test.txt");
                //fos = new FileOutputStream("E:\\file\\code\\java\\day01\\src\\Test\\test.txt",true);代表的是文件不会进行覆盖，而是追加
                //3.调用字节输出流对象(FileOutputStream)的write()方法写入文件
                String info = "hello first file";
                //将写入的字符串打散为一个字节数组
                byte[] infos = info.getBytes();
                fos.write(infos, 0, infos.length);
                System.out.println("test文件已经被更新!");
            } catch (FileNotFoundException e) { 
                e.printStackTrace();
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                //4.关闭输出流
                try { 
                    fos.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

### 实现文件的复制 ###

将E:\\file\\mysoft\\deveco-studio\\DevEco Studio 2.1.0.501\\NOTICE.txt文本文件复制到E:\\file\\code\\java\\day01\\src\\Test\\NOTICE.txt，其实复制就是先读取文本文件，读取到文本文件后再到指定的位置创建一个文本文件，之后写入文本文件

package Test;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    //借助字节输入输出流综合使用，实现文件的复制(读 写)
    //E:\file\mysoft\deveco-studio\DevEco Studio 2.1.0.501\NOTICE.txt-->E:\file\code\java\day01\src\Test\NOTICE.txt
    public class InAndOutStreamDemoTest { 
        public static void main(String[] args) { 
            FileInputStream fis = null;//输入流 读
            FileOutputStream fos = null;//输出流 写
            try { 
                fis = new FileInputStream("E:\\file\\mysoft\\deveco-studio\\DevEco Studio 2.1.0.501\\NOTICE.txt");
                fos = new FileOutputStream("E:\\file\\code\\java\\day01\\src\\Test\\NOTICE.txt");
                byte[] words = new byte[1024];
                int len = -1;
                //文件的内容读取出来存放到了字节数组words中
                while ((len = fis.read(words)) != -1) { 
                    //将字节数组words写出到输出流fos中
                    fos.write(words, 0, len);
                }
                System.out.println("文件复制完毕");
            } catch (FileNotFoundException e) { 
                e.printStackTrace();
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                try { 
                    fos.close();
                    fis.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

[java文件的读写操作(字符流)][java]

[java_IO]: https://blog.csdn.net/qq_45671732/article/details/118677387
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70]: /images/20220829/dd51058273ab4026b2b65e288e6cf648.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 1]: /images/20220829/a647e46de9f84d6bbaf2bdaeb147c7ea.png
[java]: https://blog.csdn.net/qq_45671732/article/details/118966916