JavaWeb输入输出流

瘦皮猴117

已于 2022-08-19 01:10:31 修改

阅读量1.8k

点赞数 1

分类专栏： JavaWeb 文章标签： java

于 2022-06-30 13:35:21 首次发布

本文链接：https://blog.csdn.net/XHT117/article/details/125528256

版权

JavaWeb 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Writer抽象类OutputStreamWriter 实现类

利用 PrintWriter 找到我们熟悉的方法

小结

练习

关于内容的读写

关于读InputStream

1. 直接读取(以二进制数据的方式读取，表现在代码中 byte为单位)

2. 文本读取

1. java.io.InputStream 输入流

2. 本身是一个抽象类，真正使用过程中要依赖这个抽象的具体实现子类
FilelnputStream关于文件的输入流
3. 抽象模型

4.要记得关闭
is.close()

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Arrays;

public class Demo4 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("./hello.txt");
        // FileInputStream 赋值给 InputStream，是因为有继承关系
        // FileInputStream是InputStream的下级类
        // 准备水桶
        // 1024 代表能接 1024 滴（字节）水，我们准备好桶的容量
        byte[] buf = new byte[1024];
        // n是真正接到多少（字节）的水
        // n >= 0&& n < 1024
        int n = is.read(buf); //12
        System.out.println(n);
        // 真正的数据放在 buf 从 [0, 12)
        byte[] bytes = Arrays.copyOf(buf, n);
        for (byte b : bytes) {
            System.out.printf("%02x\n", b);
        }
        is.close();
    }
}

windows 上的换行默认是“\r\n"也写作CRLF

如何利用InputStream进行二进制数据的直接读取

1)一个字节

2)一次读一批

理解EOS (-1)

End Of Stream(EOS)

除了要接水之外，我们还需要一个明确的信号（说明肯定不会有新的数据了)

End Of Stream(EOS)
如果这次接了0滴水
A.是暂时现在没水了?——0

B.还是以后永远没水了?—— -1

一次读一滴

import java.io.FileInputStream;
import java.io.InputStream;

public class Demo5 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("./hello.txt");
        while (true) {
            int data = is.read();
            if (data == -1) {
                // 所有数据都被读完了
                break;
            }
            // 否则，data 就是我们取到的数据
            byte b = (byte) data;
            System.out.printf("%02x\n", b);
        }
        is.close();
    }
}

一次读一桶

import java.io.FileInputStream;
import java.io.InputStream;

public class Demo6 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("./hello.txt");
        byte[] buf = new byte[5];
        while (true) {
            int n = is.read(buf);
            // n == 0 只是本次没数据，以后还有
            // n == -1 本次没数据，以后也没数据了
            if (n == -1) {
                // 代表数据全部读完
                break;
            }
            for (int i = 0; i < buf.length; i++) {
                byte b = buf[i];
                System.out.printf("%02x\n", b);
            }
        }
        is.close();
    }
}

处理文本数据（字符数据)

处理文本数据（字符数据)
ASCII、Unicode、UTF-8、GBK (GB18030、GB2312)
字符集(char set)
字符编码规则(char encoding)
计算机中的数据<->数字(有范围的整数)
图像、声音、文字->数字

如果每个人都定义自己的字符集，实际上没有任何的意义。
所以，总是由标准委员会来规定好一个字符集，大家一起遵守!
所以才有各种各样的标准字符集的出现!

文件内容中填充中文的读操作

public class Demo8 {
    public static void main(String[] args) throws Exception {
        try (InputStream is = new FileInputStream("./test.txt")) {
            byte[] bytes = new byte[1024];
            int n = is.read(bytes);
            String s = new String(bytes, 0, n, "UTF-8");
            System.out.println(s);
        }
    }
}

利用 Scanner 进行字符读取

Scanner scanner = new Scanner(System.in);

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Scanner;

public class Demo8 {
    public static void main(String[] args) throws Exception {
        try (InputStream is = new FileInputStream("./test.txt")) {
            try (Scanner scanner = new Scanner(is, "UTF-8")) {
                while (scanner.hasNextLine()) {
                    String line = scanner.nextLine();
                    System.out.println("|" + line + "|");
                }
            }
        }
    }
}

关于写OutputStream

内存的写速度远远快于硬盘的写速度。
所以，为了平衡这个速度之差，一般通过“缓冲区buffer”来处理

之前文件不存在，直接写入

import java.io.FileOutputStream;
import java.io.OutputStream;

public class Demo10 {
    public static void main(String[] args) throws Exception {
        // OutputStream -> FileOutputStream
        // 所以很少用  file.createNewFile()
        // 如果文件之前不存在，则会进行创建（创建可能失败： 1. 权限、2. 路径上的目录还不存在）
        // 如果文件之前存在，会清空之前的文件内容，重新写入
        try (OutputStream os = new FileOutputStream("./out.txt")) {
            // 0xe6 0x88 0x91 是 "我" 的 UTF-8 编码的字节序列
            os.write(0xe6);
            os.write(0x88);
            os.write(0x91);

            // 确保把缓冲区内可能遗留的数据全部写入 Output 设备中
            os.flush();
        }
    }
}

之前文件存在，清空内容，重新写入

import java.io.FileOutputStream;
import java.io.OutputStream;

public class Demo10 {
    public static void main(String[] args) throws Exception {
        // OutputStream -> FileOutputStream
        // 所以很少用  file.createNewFile()
        // 如果文件之前不存在，则会进行创建（创建可能失败： 1. 权限、2. 路径上的目录还不存在）
        // 如果文件之前存在，会清空之前的文件内容，重新写入
        try (OutputStream os = new FileOutputStream("./out.txt")) {
            // 0xe6 0x88 0x91 是 "我" 的 UTF-8 编码的字节序列
//            os.write(0xe6);
//            os.write(0x88);
//            os.write(0x91);

            os.write(0x20);     // 空格
            os.write(0x0d);     // '\r'
            os.write(0x0a);     // '\n'
            os.write(0x65);
            os.write(0x65);
            os.write(0x65);
            // 确保把缓冲区内可能遗留的数据全部写入 Output 设备中
            os.flush();
        }
    }
}

连续写入

import java.io.FileOutputStream;
import java.io.OutputStream;

public class Demo11 {
    public static void main(String[] args) throws Exception {
        try(OutputStream os = new FileOutputStream("./out.txt")) {
            byte[] buf = {0x65,0x65,0x20,0x65,0x0d,0x0a,(byte) 0xe6,(byte)0x88,(byte)0x91};
            // 整个 buf 的数据全部写入
            os.write(buf);
//            os.write(buf,2,4);
            os.flush();
        }
    }
}

Writer抽象类OutputStreamWriter 实现类

import java.io.*;

public class Demo12 {
    public static void main(String[] args) throws Exception {
        try (OutputStream os = new FileOutputStream("./word.txt")) {
            try (Writer writer = new OutputStreamWriter(os, "UTF-8")) {
                writer.write("你好\r\n");
                writer.write("哈哈");
                writer.flush();
            }
        }
    }
}

利用 PrintWriter 找到我们熟悉的方法

PrintWriter
printIn(...)

print(...)

printf(fmt, ...)

import java.io.*;

public class Demo12 {
    public static void main(String[] args) throws Exception {
        try (OutputStream os = new FileOutputStream("./printWriter.txt")) {
            try (Writer writer = new OutputStreamWriter(os, "UTF-8")) {
                try (PrintWriter printWriter = new PrintWriter(writer)) {
                    printWriter.println(1+1);
                    printWriter.print(3);
                    printWriter.printf("%s+%d","我",10);
                    printWriter.flush();
                }
            }
        }
    }
}

小结

InputStream输入流，背后就是输入设备（模拟的输入设备)

1.read() 、read(byte[])
2.EOS(-1)
3.Scanner(is, "UTF-8");

lnputStream 读取数据流的设备。将输入设备抽象成数据流的源头。
1.数据被抽象成流式(stream)的形式。
2.需要有内存空间，存放读取到的数据:一个变量的空间或者一个数组的空间

3.EOS:表示数据已经被读完。和本次读取暂时没有读到数据。
4.可以将InputStream接上其他的数据处理对象（水龙头上接净水器)

OutputStream输出流，背后就是输出设备（模拟的输出设备)

1. write(int)、write(byte[])
2. flush()缓冲区(buffer)平衡写入次数
3. OutputStreamWriter(做字符集编码处理) + PrintWriter(使用我们熟悉的print/println/printf)

OutputStream将内存中的数据，通过写入数据流的设备，最终将数据写到输出设备中。
1. 写的时候，为了同步内存和输出设备之间的写入速度差，一般是存在缓冲区(buffer)的。减少写的频次，提升写的速度。

2. 冲刷缓冲区(flush)的操作非常重要。

练习

1.给定路径，查找文件名中包含指定的字符的文件列表，并且根据用户的选择，决定是否删除
思路
1.从一个树的根开始，遍历整棵树
2.将每个结点的名字匹配查找条件
3.如果符合条件，就保存File对象
4.遍历完成之后，得到一组符合条件的File对象5.依次询问用户，这些对象的下一步处理方式

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class FindAndDelete {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        String rootPath = "D:\\学习";
        String condition = ".txt";

        List<File> resultList = new ArrayList<>();  // 存放符合条件的文件列表

        // 遍历整棵树，找到符合条件的所有文件，并且将结果放入 resultList
        File rootFile = new File(rootPath);
        traversal(rootFile, condition, resultList);

        // 依次针对每个结果，询问用户是否要删除
        for (File file : resultList) {
            System.out.println("是否要删除该文件: " + file.getCanonicalPath());
            if (!scanner.hasNextBoolean()) {
                System.out.println("退出");
                return;
            }

            boolean isDelete = scanner.nextBoolean();
            if (isDelete) {
                file.delete();
            }
        }
    }

    private static void traversal(File dirFile, String condition, List<File> resultList) {
        File[] files = dirFile.listFiles();
        if (files == null) {
            return;
        }

        for (File file : files) {
            if (file.isDirectory()) {
                traversal(file, condition, resultList);
            } else if (file.isFile()) {
                // 判断文件名是否满足条件 ：是否以 xxx 结尾
                String name = file.getName();
                if (name.endsWith(condition)) {
                    // 说明符合查找条件
                    resultList.add(file);
                }
            }
        }
    }
}

2. 一个文件的复制
给定两个路径：源文件路径（必须存在)、目标路径（必须不存在&&目录存在)，源文件只是普通文件，不是目录。

思路
1.由于我们只是进行复制，所以根本不考虑文件的内容具体是什么
2.所以我们要做的是:遍历{从源文件中读取数据，写入目标文件}直到所有的数据全部写完。

import java.io.*;

public class CopyFile {
    public static void main(String[] args) throws Exception {
        File srcFile = new File("D:\\学习\\1.png");
        File destFile = new File("D:\\学习\\123.png");
        // 0. 统计复制速度
        long startedAt = System.currentTimeMillis();
        // 1. 准备好搬数据的桶
        byte[] buf = new byte[1024];
        // 2. 打开两个文件
        try (InputStream is = new FileInputStream(srcFile)) {
            try (OutputStream os = new FileOutputStream(destFile)) {
                // 3. 不断地用桶从 is 接水，倒入 os 中
                while (true) {
                    int n = is.read(buf);
                    if (n == -1) {
                        // 全部读完了，可以中止循环了
                        break;
                    }
                    // 直接将读入的数据，原封不同的写入 os 中
                    os.write(buf, 0, n);
                }
                // 4. 冲刷缓冲区
                os.flush();
            }
        }
        // 0. 统计复制速度
        long endedAt = System.currentTimeMillis();    // 获取当前时间戳（ms）
        long ms = endedAt - startedAt;
        double s = ms / 1000.0;
        System.out.printf("复制共消耗了: %.3f 秒\n", s);
    }
}

3. 一个目录的复制
给定两个路径:源文件路径（必须存在&&是目录)、目标路径（必须不存在&&父目录存在)

思路：遍历整棵树
if目录:继续递归＋目标的相对位置创建目录

if 文件:目标的相对位置，进行文件的复制

import java.io.*;

public class CopyDirectory {
    // 定义成 static 属性，保证在 traversal 中可以读取
    static File srcFile = new File("D:\\学习\\content");
    static File destFile = new File("D:\\学习\\dest");

    public static void main(String[] args) throws Exception {
        traversal(srcFile);
    }

    private static void traversal(File dirFile) throws Exception {
        File[] files = dirFile.listFiles();
        if (files == null) {
            return;
        }

        for (File file : files) {
            // 怎么得到相对位置：利用 srcFile 的 绝对路径、destFile 的绝对路径、file 的绝对路径
            String srcFilePath = srcFile.getCanonicalPath();
            String filePath = file.getCanonicalPath();
            String destPath = destFile.getCanonicalPath();

            String relativePath = filePath.substring(srcFilePath.length());
            String destFilePath = destPath + relativePath;
            File oneDestFile = new File(destFilePath);

            if (file.isDirectory()) {
                // 是目录时，直接创建目录
                oneDestFile.mkdir();    // 我们可以保证其父目录一定存在
                traversal(file);
            } else if (file.isFile()) {
                copyFile(file, oneDestFile);
            }
        }
    }

    private static void copyFile(File srcFile, File destFile) throws Exception {
        // 0. 用于统计复制速度
        long startedAt = System.currentTimeMillis();    // 获取当前时间戳（ms）

        // 1. 准备好搬数据的桶
        byte[] buf = new byte[1024];

        // 2. 打开两个文件
        int count = 0;
        try (InputStream is = new FileInputStream(srcFile)) {
            try (OutputStream os = new FileOutputStream(destFile)) {
                // 3. 不断地用桶从 is 接水，倒入 os 中
                while (true) {
                    int n = is.read(buf);
                    count += n;
                    // System.out.printf("已经复制了 %d 字节的数据\n", count);
                    if (n == -1) {
                        // 全部读完了，可以中止循环了
                        break;
                    }
                    // 直接将读入的数据，原封不同的写入 os 中
                    os.write(buf, 0, n);
                }
                // 4. 冲刷缓冲区
                os.flush();
            }
        }
        // 0. 用于统计复制速度
        long endedAt = System.currentTimeMillis();    // 获取当前时间戳（ms）
        long ms = endedAt - startedAt;
        double s = ms / 1000.0;
        System.out.printf("复制共消耗了: %.3f 秒\n", s);
    }
}