4.3.3 字节流

最新推荐文章于 2024-05-29 11:42:44 发布

蟑螂恶霸不是恶霸

最新推荐文章于 2024-05-29 11:42:44 发布

阅读量263

点赞数

分类专栏：零基础入门到就业--JAVA篇文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/whatfuswd/article/details/127625285

版权

零基础入门到就业--JAVA篇专栏收录该内容

224 篇文章 4 订阅

订阅专栏

文章目录

1.概述
2.字节流读取
3.字节流写出

1.概述

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。
所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等

2.字节流读取

2.1 InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象；

常用方法：
abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源

2.1.1 InputStream案例练习

package partThree;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
/*本类用于练习字节输入流*/
public class TestInputstream {
    public static void main(String[] args) {
        method1();
    }

    private static void method1() {
        try {
            //1.创建流对象
            //InputStream in = new InputStream();
            //抽象父类   对象名   抽象类的子实现类(构造函数需要的File对象)

            //思路分析：字节输入流InputStream,它是一个抽象类，无法创建对象
            //既然父类是抽象的，那我就找它的子实现类：FileInputStream
            //FileInputStream的构造函数有两个：一个需要File对象，一个需要String路径
            //创建时这个代码会抛出异常，注意try-catch
            //InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
            InputStream in = new FileInputStream("E:\\ready\\1.txt");

            //2.开始读取
            System.out.println(in.read());//97
            System.out.println(in.read());//98
            System.out.println(in.read());//99
            System.out.println(in.read());//-1
            System.out.println(in.read());//-1

        } catch (Exception e) {
            e.printStackTrace();//万一报错了会在控制台给程序员打印错误信息用来调试
        }

    }

}

和File文件类一样，需要先手动创建需要的目录与文件。

2.1.2 案例总结

字节输入流：

抽象父类：InputStream – 不能创建对象
子级：
- FileInputStream - 操作文件的字节输入流
  构造方法的参数：File file / String pathname
- BufferedInputStream - 高效/缓冲字节输入流
  构造方法的参数：InputStream,但无法创建抽象父级的对象，所以传入的是FileInputStream对象

2.2 FileInputStream子类

直接插在文件上，直接读取文件数据

创建对象 FileInputStream(File file)—直接传文件对象通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(Stringpathname)—传路径通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name指定

2.3 BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象 BufferedInputStream(InputStream in) 创建一个 BufferedInputStream并保存其参数，即输入流 in，以便将来使用。

2.4 练习：字节流读取案例

package partThree;

import java.io.*;

/*本类用于练习字节输入流*/
public class TestIn {
    public static void main(String[] args) throws Exception{
        //method();//字节流的读取
        method2();//高效字节流的读取
    }

    //本方法用于测试高效字节流的读取
    private static void method2() {
        //定义一个在本方法中都生效的局部变量in,注意手动初始化，值为null
        InputStream in = null;
        try {
            //1.创建高效字节输入流对象
//            InputStream in = new BufferedInputStream(
//                    new FileInputStream(new File("E:\\ready\\1.txt")));
            in = new BufferedInputStream
                    (new FileInputStream("E:\\ready\\1.txt"));
            //2.使用流进行读取
            int b;
            while ((b= in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {//关流操作写在finally{}中
            //3.流用完以后一定要关闭！！！
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

    //本方法用于测试字节流的读取
    private static void method() {
        //创建一个在本方法都生效的局部变量注意手动初始化
        InputStream in = null;
        try {
            //1.创建字节输入流对象用于读取
            //InputStream in = new InputStream();//报错原因：抽象类不可实例化
            //InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
            in = new FileInputStream("E:\\ready\\1.txt");
            //2.开始读取
            /*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
            //需求：需要循环读取文件中的所有内容，直至读完
            //定义变量，记录读到的数据
            int b;
            while((b=in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();//打印错误信息
            /*try-catch结构中的第三个部分：finally{}
             * 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/
        }finally {
            try {
                //3.释放资源，流资源用完必须释放！！！
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.字节流写出

3.1 OutputStream抽象类

此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

常用方法:
Void close() 关闭此输出流并释放与此流相关的所有系统资源
Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流Abstract void write(int b) 将指定的字节写入此输出流

3.2 FileOutputStream 子类

直接插在文件上,直接写出文件数据

构造方法(创建对象):
FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)：创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)：如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

3.3 字节输出流实现方案

字节输出流
OutputStream作为抽象父类是不能创建对象的，同样的，我们可以通过实现其子类来创建相应的对象。

子类：

FileOutputStream - 操作文件的字节输出流
- 构造方法的参数：File file / String pathname
- 注意：除了上述两个构造方法以外，文件字节输出流对象创建的时候还可以指定输出的方式
- 默认存在一个参数boolean append,默认值为false，默认覆盖
- 如果将这个append的值设置为true，数据是按追加的效果输出，不覆盖文件中的原数据
BufferedOutputStream - 高效/缓冲字节输出流
- 构造方法的参数：OutputStream,但无法创建抽象父级的对象，所以传入的是FileOutputStream对象
- 该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

通过其构造方法来创建对象：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

3.4 练习: 字节输出流

package partThree;
import java.io.*;

/*本类用于测试字节输出流*/
public class TestOut {
    public static void main(String[] args) {
        method();//用于测试普通字节输出流
        //method2();//用于测试高效字节输出流
    }
    //创建一个用于测试高效字节输出流的方法
    private static void method2() {
        //1.创建一个在本方法都生效的局部变量，注意手动初始化
        OutputStream out = null;
        try{
            //2.创建高效字节输出流对象
//          out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
            out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
            //3.使用流对象--进行写出操作
            out.write(97);
            out.write(97);
            out.write(97);
        }catch (Exception e){
            e.printStackTrace();
        }finally {//关流操作要放在finally{}中
            try {
                //4.关流
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //创建一个用于测试普通字节输出流的方法
    private static void method() {
        //1.创建一个在本方法中都生效的局部变量，注意手动初始化null
        OutputStream out = null;
        //2.创建try-catch-finally结构，因为IO操作可能会产生异常
        try{
            //3.创建普通字节输出流对象
            //out = new FileOutputStream(new File("E:\\ready\\2.txt"));
            //out = new FileOutputStream("E:\\ready\\2.txt");
            out = new FileOutputStream("E:\\ready\\2.txt",true);
            //4.使用流对象--进行写出操作
            out.write(99);//对应ASCII码表中的a
            out.write(99);//对应ASCII码表中的b
            out.write(99);//对应ASCII码表中的c
        }catch (Exception e){
            e.printStackTrace();
        }finally {//如果想要代码一定会执行，需要写在finally中
            try {
                //5.关流操作
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

蟑螂恶霸不是恶霸

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
4.3.3 字节流

字节流是由字节组成的,字符流是由字符组成的.Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等抽象父类：InputStream – 不能创建对象子级：FileInputStream - 操作文件的字节输入流构造方法的参数：File file / String pathnameBufferedInputStream - 高效/缓冲字节输入流。
复制链接

扫一扫