Java-IO（字节流）

1. 字节输出流

步骤：

1.创建字节输出流对象

2.调用 write() 方法写入数据

3.释放资源

写入数据的三种方式

public void write(int b)

public void write(byte[] b)

public void write(byte[] b,int off,int len)

代码如下：

public class FileOutputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\o.txt");

        //public void write(int b)  写入的是数字，输出的是数字对应的Assic码
//        fileOutputStream.write(99);
//        fileOutputStream.write(96);
//        fileOutputStream.write(35);
//        fileOutputStream.write(56);

        // public void write(byte[] b)  写入数组
        byte[] bytes = {33,56,87,57,22,57,14,89,22};
//        fileOutputStream.write(bytes);

        //public void write(byte[] b,int off,int len)
        fileOutputStream.write(bytes, 2, 3);

        fileOutputStream.close();
    }
}

注意事项：

换行问题：

1、没有换行，如何实现换行呢？
为什么上一个代码中没有进行换行呢？
因为我们在写数据的时候，只写了字节，没有写入换行符
如何实现呢？
理论上，我们每写完一部分的时候，就写一个换行符进行换行
注意，每一个系统对应的换行不大一样
Windows：\r\n
Mac： \r
Linux： \n

追加问题

2、每次运行写入的时候，会把上一次运行的数据进行覆盖，如何实现追加写入呢？
追加：在原有的文件内容上继续添加一些新的内容
覆盖：将原有的文件内容删掉，再添加一些新的内容

FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。

public class FileOutputStreamDemo3 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //如果不添加后面的 append 参数的话。 默认的是 FALSE ，不追加写入
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\p.txt",true);

        //调用 write 方法写入数据
        for (int i = 0; i < 5; i++) {
            fileOutputStream.write(("大数据，yyds"+i).getBytes());
            fileOutputStream.write("sdfasdf".getBytes());
            //添加换行操作
            fileOutputStream.write("\r\n".getBytes());
        }
        fileOutputStream.close();
    }
}

2. 字节输入流

步骤

字节输入流：ImputStream
子类：FileInputStream

1、创建字节输入流对象

2、调用方法读取数据

3、释放资源

FileInputStream的构造方法：

FileInputStream(File file)

FileInputStream(String name)

字节输入流读取对象读取数据的两种方式：

public int read()

public int read(byte[] b)

上代码

public class FileInputStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
//        File file = new File("D:\\a.txt");
//        FileInputStream fileInputStream = new FileInputStream(file);
        FileInputStream fileInputStream = new FileInputStream("D:\\a.txt");

        // public int read()读取
//        System.out.println((char)fileInputStream.read());
//        System.out.println((char)fileInputStream.read());
//        System.out.println((char)fileInputStream.read());
//        System.out.println((char)fileInputStream.read());
/*
        //我们发现，当文件的内容过多的时候，一个字节一个字节去读取，发现很麻烦，而且语句都是一样
        //使用循环改进，使用哪一种循环呢？
        //因为我们不知道要循环多少次才能读到文件的末尾，所以采用while循环
        //使用while循环，就得有一个循环条件
        //想一下，这个循环条件是不是就是读到了末尾就不读
        //如何使用代码表示读到文件末尾呢？如果达到文件的末尾， -1 。
        //一次读取一个字节
 */
        int len = 0;
        while ((len = fileInputStream.read()) != -1){
            System.out.println((char)len);
        }
        fileInputStream.close();
    }
}

字节输入流读取数据的第二种方法，一次读取一个数组

public class FileInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输入对象
        FileInputStream fileInputStream = new FileInputStream("D:\\b.txt");
        //创建字节数组，依据大小来读取
        byte[] bytes = new byte[4];
        int len = 0;
        while ((len = fileInputStream.read(bytes)) != -1){
            System.out.println(new String(bytes, 0, len));
        }
    }
}

3 字节缓冲流

字节缓冲输出流：BufferedOutputStream

构造方法：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

public class BufferedOutputStreamDemo1 {
    public static void main(String[] args) throws IOException {
//        FileOutputStream fos = new FileOutputStream("out5.txt");
//        //创建一个字节缓冲流对象
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("out5.txt"));

        //调用方法写数据
        bos.write("大数据，yyds".getBytes());

        //释放资源
        bos.close();
//        fos.close();
    }
}

字节缓冲输入流：BufferedInputStream

构造方法：
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使

public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //调用方法，读取数据
        //一次读取一个字节
//        int b = 0;
//        while ((b=bis.read())!=-1){
//            System.out.print((char) b);
//        }
        System.out.println("=================================");
        //一次读取一个字节数组
        int length = 0;
        byte[] bytes = new byte[10];
        while ((length=bis.read(bytes))!=-1){
            String s = new String(bytes, 0, length);
            System.out.print(s);
        }
    }
}

各种流读取快慢测试

单个字节读取与字节数组比较

缓冲流与非缓冲流速度比较

package com.bigdat.java.day25;
import java.io.*;
/*
    测试
        单个字节和字节数组读取时间
        非缓冲与带缓冲的读取时间
 */
public class CopyDemo2 {
    public static void main(String[] args) {
          // oneTest();  单个字节读取视屏的时间为2107904毫秒
         // shuZuTest(); 数组读取视屏的时间为2392毫秒
        //  OneBufferText();  缓冲单字节读取视屏的时间为：9503毫秒
        // shuzuBufferText(); 缓冲字节数组读取视屏的时间为：547毫秒
    }
    //测试单个字符读取一段视屏的时间
    public static void oneTest(){
        //创建读取对象
        FileInputStream fileInputStream = null;
        //创建写出对象
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4");
            fileOutputStream = new FileOutputStream("D:\\我被改名了\\copy1.mp4");
            Long start = System.currentTimeMillis();
            //开始读取
            int len = 0;
            while((len = fileInputStream.read()) != -1){
                fileOutputStream.write(len);
            }
            long end = System.currentTimeMillis();
            System.out.println("单个字节读取视屏的时间为"+(end-start)+"毫秒");

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    //测试字节数组copy视屏的时间
    public static void shuZuTest(){
        //创建读取对象
        FileInputStream fileInputStream = null;
        //创建写出对象
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4");
            fileOutputStream = new FileOutputStream("D:\\我被改名了\\copy2.mp4");
            Long start = System.currentTimeMillis();
            //开始读取
            int len = 0;
            byte[] bytes = new byte[1024];
            while((len = fileInputStream.read(bytes)) != -1){
                fileOutputStream.write(bytes, 0, len);
            }
            long end = System.currentTimeMillis();
            System.out.println("数组读取视屏的时间为"+(end-start)+"毫秒");

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
      //缓冲流单个字节读取视屏测试时间
    public static void OneBufferText(){
        //创建读入字节的对象
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4"));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:\\我被改名了\\copy3.mp4"));

            //开始时间
            long start = System.currentTimeMillis();
            //开始写入到程序中
            int len = 0;
            while((len = bufferedInputStream.read()) != -1){
                bufferedOutputStream.write(len);
            }
            long end = System.currentTimeMillis();
            System.out.println("缓冲单字节读取视屏的时间为："+(end-start));


        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bufferedOutputStream.close();
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    public static void shuzuBufferText(){
        //创建读入字节的对象
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\我被改名了\\17day24 字节流速度对比，编码表 2.mp4"));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:\\我被改名了\\copy4.mp4"));

            //开始时间
            long start = System.currentTimeMillis();
            //开始写入到程序中
            int len = 0;
            byte[] bytes = new byte[1024];
            while((len = bufferedInputStream.read(bytes)) != -1){
                bufferedOutputStream.write(bytes, 0, len);
            }
            long end = System.currentTimeMillis();
            System.out.println("缓冲字节数组读取视屏的时间为："+(end-start)+"毫秒");


        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                bufferedOutputStream.close();
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }



    }
}

posted @ 2022-04-09 08:24 a-tao必须奥利给阅读(65) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java-IO(字符流)

· Java-IO(各种流的拷贝)

· Java：IO流(一、字节流)

· IO流-字节流

· java--IO流 ☞ 字节流

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

公告

昵称： a-tao必须奥利给
园龄： 3年1个月
粉丝： 20
关注： 18

+加关注

2025年3月

日

一

二

三

四

五

六

atao-BigData

人生如逆旅，你我亦行人。