JAVA将字节存入文本文档

转载

mob64ca14133dc6 2024-09-25 09:05:46

文章标签 JAVA将字节存入文本文档 java 数据 System 文章分类 Java 后端开发

文章目录

流Stream是什么?
字节流实现复制图片(二进制文件)
字节缓冲流实现复制图片(二进制文件)
字符流实现复制文本
字符缓冲流实现复制文本

流Stream是什么?

在 Java中所有数据都是使用流读写的。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
按照流向分：输入流；输出流 (单纯站在数据角度: CPU直接从内存里读取数据，不会和外设打交道，为什么呢？因为硬盘太慢了, 所以数据要能够被CPU处理，就必须先被拿到内存，才能够被CPU处理)
输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中。
输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。
例如键盘就是一个标准的输入设备，而显示器就是一个标准的输出设备，但是文件既可以作为输入设备，又可以作为输出设备。
按照处理数据的单位分：字节流(8位的字节)；字符流(16位的字节)

字节流操作的基本单元是字节；字符流操作的基本单元为Unicode码元。
字节流在操作的时候本身不会用到缓冲区的，是与文件本身直接操作的；而字符流在操作的时候使用到缓冲区的。
所有文件的存储都是字节(byte)的存储，在磁盘上保留的是字节。
在使用字节流操作中，即使没有关闭资源（close方法），也能输出；而字符流不使用close方法的话，不会输出任何内容。

流对象的核心操作就是

打开文件（构造函数）
read 把文件的数据读到内存中
write 把数据从内存中写入文件中
close 关闭文件（如果不关闭文件就会造成文件泄漏所谓文件泄漏就是一个PCB中会有一个数组一样的东西去记录打开的文件这个数组的大小是有限的如果不关闭一直打开文件就会让数组满了后序的文件就会打开失败这就是文件泄漏）

字节流实现复制图片(二进制文件)

FileInputStream(File file)
通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File 对象 file 命名
FileInputStream(String name)
通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name 命名。
FileOutputStream(File file)
创建文件输出流以写入由指定的 File 对象表示的文件。
FileOutputStream(String name)
创建文件输出流以指定的名称写入文件。

import com.sun.media.sound.FFT;

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

public class IoTest1 {
    public static void main(String[] args) {
        copyFile();
    }

    private static void copyFile() {

        try (FileInputStream fileInputStream = new FileInputStream("D:\\java\\test\\more\\flower.png");
             FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\test\\more\\flower2.png")){

            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = fileInputStream.read(buffer)) != -1) {
                fileOutputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.getStackTrace();
        }

        System.out.println("复制成功");
    }
}

JAVA将字节存入文本文档_数据

JAVA将字节存入文本文档_JAVA将字节存入文本文档_02

字节缓冲流实现复制图片(二进制文件)

为什么需要有缓冲流？
当我们用read()读取文件时，每读一个字节，访问一次硬盘，效率很低。文件过大时，操作起来也不是很方便。因此我们需要用到buffer缓存流，当创建buffer对象时，会创建一个缓冲区数组。当我们读一个文件时，先从硬盘中读到缓冲区，然后直接从缓冲区输出即可，效率会更高。
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，输入流 in ，供以后使用。
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
使用BufferedOutputStream还有一个特殊操作就是 flush操作（手动刷新缓冲区）就是把数据从缓冲区写入磁盘的IO设备
缓冲区合适会被刷新

缓冲区满了的时候就会自动刷新
调用close方法的时候也会触发刷新
主动调用flush也会刷新

import java.io.*;

public class OiTest2 {
    public static void main(String[] args) {
        copyFile();
    }

    private static void copyFile() {
        try (BufferedInputStream bufferedInputStream
                     = new BufferedInputStream(new FileInputStream("D:\\java\\test\\more\\flower.png"));
             BufferedOutputStream bufferedOutputStream
                     = new BufferedOutputStream(new FileOutputStream("D:\\java\\test\\more\\flower2.png"))){


            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = bufferedInputStream.read(buffer)) != -1) {
                bufferedOutputStream.write(buffer, 0, len);
            }

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

        System.out.println("复制成功");
    }
}

对比有无缓冲区的效率

import java.io.*;

public class IoTest1 {
    public static void main(String[] args) {
        copyFile();
        copyFileBuffer();
    }

    private static void copyFile() {
        long beg = System.currentTimeMillis();
        try (FileInputStream fileInputStream = new FileInputStream("D:\\java\\test\\more\\flower.png");
             FileOutputStream fileOutputStream = new FileOutputStream("D:\\java\\test\\more\\flower2.png")){

            byte[] buffer = new byte[1];
            int len = -1;
            while ((len = fileInputStream.read(buffer)) != -1) {
                fileOutputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.getStackTrace();
        }

        System.out.println("复制成功");
        long end = System.currentTimeMillis();
        System.out.println("无buffer的时间为" + (end - beg) + "ms");
    }

    private static void copyFileBuffer() {
        long beg = System.currentTimeMillis();
        try (BufferedInputStream bufferedInputStream
                     = new BufferedInputStream(new FileInputStream("D:\\java\\test\\more\\flower.png"));
             BufferedOutputStream bufferedOutputStream
                     = new BufferedOutputStream(new FileOutputStream("D:\\java\\test\\more\\flower3.png"))){


            byte[] buffer = new byte[1];
            int len = -1;
            while ((len = bufferedInputStream.read(buffer)) != -1) {
                bufferedOutputStream.write(buffer, 0, len);
            }

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

        System.out.println("复制成功");
        long end = System.currentTimeMillis();
        System.out.println("有buffer的时间为" + (end - beg) + "ms");
    }
}

JAVA将字节存入文本文档_System_03

字符流实现复制文本

FileReader(File file)
创建一个新的 FileReader ，给出 File 读取。
FileReader(String fileName)
创建一个新的 FileReader ，给定要读取的文件的名称。
FileWriter(File file) 给一个File
对象构造一个FileWriter对象。
FileWriter(String fileName)
构造一个给定文件名的FileWriter对象。

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

public class IOTest3 {
    public static void main(String[] args) {
        copyFile();
    }

    private static void copyFile() {

        try (FileReader fileReader = new FileReader("D:\\java\\test\\more\\NBA.txt");
             FileWriter fileWriter = new FileWriter("D:\\java\\test\\more\\NBA2.txt")){

            char[] buffer = new char[1024];
            int len = -1;
            while ((len = fileReader.read(buffer)) != -1) {
                fileWriter.write(buffer, 0, len);

            }

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

JAVA将字节存入文本文档_System_04

字符缓冲流实现复制文本

为了提高字符流读写的效率，引入了缓冲机制，进行字符批量的读写，提高了单个字符读写的效率。BufferedReader 用于加快读取字符的速度，BufferedWriter 用于加快写入的速度。BufferedReader 和 BufferedWriter 类各拥有 8192个字符的缓冲区。当 BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并放满缓冲区，而之后若使用read()方法，会先从缓冲区中
进行读取。如果缓冲区数据不足，才会再从文件中读取，使用 BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。

import java.io.*;

public class IOTest4 {
    public static void main(String[] args) {
        copyFile();
    }

    private static void copyFile() {

        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\java\\test\\more\\NBA.txt"));
             BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\java\\test\\more\\NBA2.txt"))){

            char[] buffer = new char[1024];
            int len = -1;
            while ((len = bufferedReader.read(buffer)) != -1) {
                bufferedWriter.write(buffer, 0, len);
            }

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

        System.out.println("复制成功");
    }
}

还有一种一次获取一行的写法

import java.io.*;

public class IOTest4 {
    public static void main(String[] args) {
        copyFile();
    }

    private static void copyFile() {

        try (BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\java\\test\\more\\NBA.txt"));
             BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\java\\test\\more\\NBA2.txt"))){

            String line;
            while ((line = bufferedReader.readLine()) != null) {
                bufferedWriter.write(line);
                //每次读入一行要换行 给line加 “\n" 或者下面这种都行
                bufferedWriter.newLine();
            }

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

        System.out.println("复制成功");
    }
}