• Java学习笔记（二十三）

    在完成对C语言的学习后，我最近开始了对C++和Java的学习，目前跟着视频学习了一些语法，也跟着敲了一些代码，有了一定的掌握程度。现在将跟着视频做的笔记进行整理。本篇博客是整理Java知识点的第二十三篇博客。

    本篇博客介绍了Java的字节流。

    本系列博客所有Java代码都使用IntelliJ IDEA编译运行，版本为2022.1。所用JDK版本为JDK11。

    目录

    字节流

    IO流概述和分类

    字节流写数据

    字节流写数据的方式

    字节流追加数据

    字节流写数据加异常处理

    字节流读数据

    字节流复制文本文件

    字节流读数据

    字节流复制图片

    字节缓冲流

    字节流

    IO流概述和分类

    IO流是进行输入和输出的流。流是一种抽象概念，表示数据传输。IO流处理设备之间数据传输问题，用于文件复制，文件上传，文件下载等。

    IO流按照数据流向分为进行读数据的输入流和进行写数据的输出流。按照数据类型分为字节流和字符流。

    一般，如果用记事本能看懂内容，就用字符流，否则用字节流。如果不知道用哪种类型就用字节流。

    字节流写数据

    字节流的抽象基类InputStream表示字节输入流所有类的超类，抽象基类OutputStream是字节输出流所有类的超类。子类名称以父类名作为子类名的后缀。

    FileOutputStream用于将数据写入File。使用此类需要导包，import java.io.FileInputStream。

    FileOutputStream(String name)用于创建文件输出流，将数据写入name文件。

    写数据要先创建流对象，然后调用写数据方法，最后释放资源。close方法关闭流并释放资源。

    1. import java.io.FileNotFoundException;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4. public class writetest1 {
    5.     public static void main(String[] args) throws IOException {
    6.         FileOutputStream f = new FileOutputStream("test.txt");
    7.         f.write(48);
    8.         f.write(65);
    9.         f.write(97);
    10.         f.close();
    11.     }
    12. }

    程序创建了一个FileOutputStream流，并进行输出。程序无输出，test.txt的内容是：

    0Aa

    字节流写数据的方式

    void write(int b)将b写入输出流，这里的b是字符的ASCII码值，一次写一个数据。

    void write(byte[] b)将b.length字节写入输出流，一次写入整个数组数据，数值是ASCII码值。

    void write(byte[] b,int off,int len)从b的off位置开始，将len个字节写入输出流，数值是ASCII码值。

    1. import java.io.FileNotFoundException;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. public class writetest2 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileOutputStream f = new FileOutputStream("test.txt");
    8.         f.write(66);
    9.         f.write(98);
    10.         f.write(10);
    11.  
    12.         byte[] by = {99,100,101,102};
    13.         f.write(by);
    14.  
    15.         byte[] bys = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes();
    16.         f.write(bys,11,3);
    17.         f.close();
    18.     }
    19. }

    程序无输出，test.txt的内容是：

    Bb
    cdefLMN

    覆盖了原来的内容（即上次输出）。

    String类的getBytes()方法将字符串内容转换为byte数组。

    1. import java.io.FileNotFoundException;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. public class writetest3 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileOutputStream f = new FileOutputStream("test.txt");
    8.         int i;
    9.         for(i = 0; i < 10;i += 1){
    10.             f.write("Hello".getBytes());
    11.             f.write("\n".getBytes());
    12.         }
    13.         f.close();
    14.     }
    15. }

    程序无输出，test.txt的内容是：

    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello

    共10行Hello。覆盖了原有数据。

    字节流追加数据

    public FileOutputStream(String name,boolean append)创建文件输出流，写入name文件。如果append为true，就写入文件末尾。

    1. import java.io.FileNotFoundException;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. public class writetest4 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileOutputStream f = new FileOutputStream("test.txt",true);
    8.         f.write("Hello Java".getBytes());
    9.         f.close();
    10.     }
    11. }

    程序无输出。test.txt的内容是：

    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello Java

    原来的内容没有被覆盖，末尾增加了Hello Java。

    字节流写数据加异常处理

    异常处理时，finally块执行所有清除操作。被finally控制的语句一定执行。格式是：

    try{

    可能出现异常的代码

    }catch(异常类名，变量名){

    异常的处理代码

    }finally{

    所有清除操作

    }

    1. import java.io.FileNotFoundException;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4.  
    5. public class writetest5 {
    6.     public static void main(String[] args){
    7.         FileOutputStream f = null;
    8.         try {
    9.             f = new FileOutputStream("E:\\test");
    10.         } catch (FileNotFoundException e) {
    11.            e.printStackTrace();
    12.         }finally{
    13.             try {
    14.                 f.close();
    15.             } catch (IOException e) {
    16.                 e.printStackTrace();
    17.             }
    18.         }
    19.     }
    20. }

    本人的电脑没有E盘，因此，程序的输出是：

    java.io.FileNotFoundException: E:\test (系统找不到指定的路径。)
        at java.base/java.io.FileOutputStream.open0(Native Method)
        at java.base/java.io.FileOutputStream.open(FileOutputStream.java:298)
        at java.base/java.io.FileOutputStream.(FileOutputStream.java:237)
        at java.base/java.io.FileOutputStream.(FileOutputStream.java:126)
        at writetest5.main(writetest5.java:9)
    Exception in thread "main" java.lang.NullPointerException
        at writetest5.main(writetest5.java:14)

    字节流读数据

    FileInputStream(String name)创建一个文件输入流，指向文件的名字是name。使用FileInputStream需要导包，import java.io.FileInputStream。

    读数据首先创建输入流对象，然后用读数据方法，最后close释放资源。

    read()方法向后读取一个字节，并返回其ASCII码值，结果是int类型，可以强制类型转换为char型。读到文件末尾返回-1。

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.io.IOException;
    4.  
    5. public class readtest1 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileInputStream f = new FileInputStream("test.txt");
    8.         int ch;
    9.         while((ch = f.read()) != -1){
    10.             System.out.print((char)ch);
    11.         }
    12.         f.close();
    13.     }
    14. }

    程序使用循环，只要不读到结尾就一直读取，读取后立即输出。程序的输出是：

    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello
    Hello Java

    字节流复制文本文件

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5. public class readwrite {
    6.     public static void main(String[] args) throws IOException {
    7.         int ch;
    8.         FileInputStream fis = new FileInputStream("test1.txt");
    9.         FileOutputStream fos = new FileOutputStream("test2.txt");
    10.  
    11.         while((ch = fis.read()) != -1){
    12.             fos.write(ch);
    13.         }
    14.  
    15.         fis.close();
    16.         fos.close();
    17.     }
    18. }

    程序创建了FileInputStream流对象fis和FileOutputStream流对象fos。采用循环，用int类型变量ch接受fis读取的内容，只要fis没有读到结尾，fos就将ch进行写入。结束后关闭fis和fos。

    程序无输出。执行结束后test1和test2都是下面内容：

    20220818
    Hello Java
    IO

    这是预先准备的内容。

    字节流读数据

    int read(byte[] b)最多读取b.length个长度，并将读入的长度返回，读完后返回-1。

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.io.IOException;
    4.  
    5. public class readtest2 {
    6.     public static void main(String[] args) throws IOException {
    7.         FileInputStream f = new FileInputStream("test1.txt");
    8.         byte[] bytes = new byte[1024];
    9.         int len;
    10.         while((len = f.read(bytes)) != -1){
    11.             System.out.println(new String(bytes,0,len));
    12.         }
    13.         f.close();
    14.     }
    15. }

    程序的输出是：

    20220818
    Hello Java
    IO

    字节流复制图片

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class readwritetest1 {
    7.     public static void main(String[] args) throws IOException {
    8.         FileInputStream fis = new FileInputStream("D:\\university\\13-2\\summary.png");
    9.         FileOutputStream fos = new FileOutputStream("D:\\university\\summary.png");
    10.         byte[] bytes = new byte[1024];
    11.         int len;
    12.         while((len = fis.read(bytes)) != -1){
    13.             fos.write(bytes,0,len);
    14.         }
    15.  
    16.         fis.close();
    17.         fos.close();
    18.     }
    19. }

    同样使用两个流，一个读一个写。读入后就将数据写出。程序无输出。复制了图片，此处不再展示。

    字节缓冲流

    BufferedOutputStream实现缓冲输出流，使得应用程序可以向底层输出流写入数据，不必因为写入的每个字节导致底层系统的调用。构造方法是：

    BufferedOutputStream(OutputStream out)

    使用此类需要导包，import java.io.BufferedOutputStream

    BufferedInputStream实现缓冲输入流，此流创建一个内部缓冲区数组，从流中读取内容时，内部缓冲区根据需要从包含的输入流重新填充。构造方法是：

    BufferedInputStream(InputStream in)

    字节缓冲流只提供缓冲区，真正的读写还需要基本的字节流对象进行操作。

    1. import java.io.*;
    2. public class buffertest1 {
    3.     public static void main(String[] args) throws IOException {
    4.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test1.txt"));
    5.         byte[] bytes = new byte[1024];
    6.         int len;
    7.         while((len = bis.read(bytes)) != -1){
    8.             System.out.println(new String(bytes, 0, len));
    9.         }
    10.  
    11.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test1.txt"));
    12.         byte[] bytest = new byte[1024];
    13.         bytest = "20220717 mission accomplished".getBytes();
    14.         bos.write(bytest);
    15.         bis.close();
    16.         bos.close();
    17.     }
    18. }

    程序首先利用缓冲输入流读取数据，并将读入的数据进行输入。随后通过缓冲输出流进行输出。

    程序的输出是：

    20220818
    Hello Java
    IO

    同时向文件输出的内容也成功输出。

  • 相关阅读:
    WEB漏洞-文件操作之文件包含漏洞
    “文本界面”(Python插值字符串格式化打造)
    《大数据之路：阿里巴巴大数据实践》-第2篇 数据模型篇 -第11章 事实表设计
    Wireshark TS | 快速重传和乱序之混淆
    基于SSM的学生疫情信息管理系统设计与实现
    CCIE理论-IPSec的主模式和野蛮模式的区别
    【DETR用于3D目标检测】3DETR: An End-to-End Transformer Model for 3D Object Detection
    Acer宏碁暗影骑士5笔记本AN517-54原装出厂Win10系统工厂模式
    Zabbix Timeout 设置不当导致的问题
    BUUCTF key不在这里
  • 原文地址：https://blog.csdn.net/m0_71007572/article/details/126405418