11.IO 流

1.IO 流引入

概述：以应用程序为参照物，读取数据为输入流（Input），写数据为输出流（Output），大量输入输出数据简称 IO 流
原理：

2.IO 流的分类

读写的文件分类

二进制文件：打开后是乱码，或者是 16 进制，无法生成文件的文件
文本文件：打开文件内容可以直接阅读

IO流读取数据内容分类

字符流：读取的内容最小单位是 char 类型
字节流：读取的内容最小单位是 byte 类型

3.IO 流的访问方式分类

随机读写文件：文件中存在一个游标，通过移动游标的方式，改变读写数据的位置
顺序读写文件：每次都从文件开始的位置开始读写

4.IO 字节流

输入输出字节流：InputStream、OutputStream
API：

int read()：从流中读取一个字节，返回值为 int 类型
void wirte(int b)：把一个字节写入到流中（把int 类型的低八位）
void close()：关闭管道流

4.1.文件输出/入字节流

文件流：FileInputStream（文件输入流）、FileOutputStream（文件输出流）
特点：文件流是节点流，直接可以操作磁盘的文件
节点流概念：能够介质（文件、网络、控制台）直接相连的流
API：

FileInputStream(File file)
FileInputStream(String name)
FileOutputStream(String name)
FileOutputStream(String name, boolean append)
FileOutputStream(File file, boolean append)
FileOutputStream(File file)

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

/**
 * 完成文件的拷贝
 */
public class FileStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建一个文件输入流
        FileInputStream fis = new FileInputStream("test.txt");
        // 2.创建一个文件输出流
        FileOutputStream fos = new FileOutputStream("text.txt");
        // 3.创建一个数组
        byte[] data = new byte[1024];

        while (true) {
            // 4.读取数据
            int len = fis.read(data);
            // 7.判断读取的长度是否为 -1
            if (len == -1){
                System.out.println("文件拷贝成功");
                break;
            }
            // 5.写数据
            fos.write(data, 0, len);
        }
        // 6.关闭管道流
        fis.close();
        fos.close();

    }
}

4.2.ByteArray 字节流

Byte 字节流：ByteArrayInputStream（比特数组输入流）、ByteArrayOutputStream（比特数组输出流）
特点：包含一个缓冲区，该缓冲区存储从流中读取的数据
API：

ByteArrayInputStream(byte[] buf)
ByteArrayInputStream(byte[] buf, int offset, int length)

import java.io.*;

/**
 * 文件拷贝
 */
public class ByteArrayStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建一个文件管道流
        FileInputStream fis = new FileInputStream("E:\\software\\developSoftware\\Java\\JavaSE\\basic\\src\\test.txt");
        // 2.创建另一个文件输出流
        FileOutputStream fos = new FileOutputStream("E:\\software\\developSoftware\\Java\\JavaSE\\basic\\src\\123.txt");
        // 3.创建数组管道流
        ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
        // 5.定义数组
        byte[] data = new byte[1024];
        while (true) {
            // 4.读取数据
            int len = fis.read(data);
            // 7.跳出
            if (len == -1) break;
            // 6.写数据
            bos.write(data, 0, len);
        }
        bos.writeTo(fos);
        // 8.关闭管道
        fis.close();
        fos.close();
        bos.close();
    }
}

4.3.Data 字节流

Data 字节流：DataInputStream（数据输入流）、DataOutputStream（数据输出流）
特点：读取数据就是 Java 的数据类型，属于处理流

import java.io.*;

public class DateStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.创建输入管道流
        DataInputStream dis = new DataInputStream(new FileInputStream("test.txt"));
        //2.创建一个输出管道流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("text.txt"));
        //3.边读边写
        byte[] data = new byte[1024];
        while (true){
            int len = dis.read(data);
            if (len == -1) break;
            dos.write(data, 0 ,len);
        }
        //4.关闭管道
        dis.close();
        dos.close();
    }
}

4.4.缓冲字节流

缓冲字节流：BufferedInputStream（缓冲输入字节流）、BufferedOutputStream（缓冲输出字节流）
特点：

处理了，一边和程序连接，一边和修饰流或者节点流连接。不能直接面对外部介质（文件、网络）
缓冲流中的缓冲区为了提高读取或写入的效率，将读取或写入的文字暂时存储在缓冲区，当缓冲区满了之后，一起将数据读出或写入，减少读写的次数

API：

BufferedInputStream(InputStream is)
BufferedOutputStream(InputStream is)
int read(byte[] b)：将读取文件内容放置在 byte[] 数组中，然后返回读取的字节数。int：读取的字节数。如果读到末尾，返回 -1

import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.创建一个输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
        //2.创建一个输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("text.java"));
        //3.边读边写
        byte[] data = new byte[1024];
        while (true){
            int len = bis.read();
            if (len == -1) break;
            bos.write(data, 0, len);
            bos.flush(); //当缓冲区满了就会自动刷出
        }
        //4.关闭流
        bis.close();
        bos.close();
    }
}

5.IO 字符流

5.1.输入输出字符流

输入输出字符流：Reader（输入字符流）、Writer（输出字符流）
特点：

读写的内容是字符
是抽象类
是字符流的根类
读取的文件是文本文件

PAI：

int read()：读取文本文件内容
void write(int )：写入文件
void close()：关闭管道

5.2.文件输入输出字符流

FileReader（文件输入字符流）、FileWriter（文件输出字符流）
特点：读数据方式是字符、属于节点流
API：

FileReader(String fileName)：根据路径加载文件，并且建立和程序的输入管道
FileWriter(String fileName)：根据路径加载文件，并且建立和程序的输出管道
int reader(char[] c)
void write(char[] c);
void flush();
void close();

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

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //获取文件路径
        String path = FileReaderDemo.class.getResource("").getPath();
        //1.创建文件输入字符流
        FileReader reader = new FileReader(path + "test.txt");
        //2.输出字符流
        FileWriter writer = new FileWriter(path +"text.txt");
        while (true){
            //3.读取文件内容
            int buf = reader.read();
            if (buf == -1) break;
            //将字符写入文件
            writer.write(buf);
            //情况缓冲区
            writer.flush();
        }
        //关闭管道流
        reader.close();
        writer.close();
    }
}

posted @ 2024-05-06 16:43 落落的学习阅读(72) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

luoluostudy