学习JavaEE的日子 Day35 字节流

5.字节流

应用场景：操作二进制数据（音频、视频、图片）

abstract class InputStream – 字节输入流的基类（抽象类）

abstract class OutputStream – 字节输出流的基类（抽象类）

class FileInputStream extends InputStream – 文件字节输入流 基础流

class FileOutputStream extends OutputStream – 文件字节输出流

class FilterInputStream extends InputStream – 过滤器字节输入流 一般不使用

class FilterOutputStream extends OutputStream – 过滤器字节输出流

class BufferedInputStream extends FilterInputStream – 带缓冲区的字节输入流 处理流

class BufferedOutputStream extends FilterOutputStream – 带缓冲区的字节输出流

默认缓冲区大小：8192字节

注意：处理流里包含基础流

在这里插入图片描述

5.1 利用 文件字节输出流 向文件写入数据FileOutputStream

1)不处理异常的方式

2)文件存在的情况

3)文件不存在的情况

经验：所有的输出流，文件不存在的情况都会创建文件

public class Test01 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileOutputStream fos = new FileOutputStream("io.txt");
		
		//2.写入数据
		//fos.write(97);//写入UniCode码
		//fos.write("123abc".getBytes());//写入byte数组
		fos.write("123abc".getBytes(), 2, 3);//写入byte数组、偏移量、写入长度
		
		//3.关闭资源
		fos.close();
		
	}
}
  1. 在文件末尾追加内容

经验：在文件末尾追加考虑基础流的构造方法

public class Test02 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象 + 设置在文件末尾追加
		FileOutputStream fos = new FileOutputStream("io.txt",true);
		
		//2.写入数据
		fos.write("123abc".getBytes());//写入byte数组
		
		//3.关闭资源
		fos.close();
		
	}
}
  1. 处理异常
public class Test03 {
	public static void main(String[] args) {
		
		
		FileOutputStream fos = null;
		try {
			//1.创建流对象 + 设置在文件末尾追加
			fos = new FileOutputStream("io.txt",true);
			
			//2.写入数据
			fos.write("123abc".getBytes());//写入byte数组
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			
			//3.关闭资源
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
		
	}
}

5.2 利用 文件字节输入流 读取文件里的数据FileInputStream

1)不处理异常的方式

2)文件存在的情况

public class Test04 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据
		//read()：一个字节一个字节的读取数据，读取到文件末尾返回-1
		//int read = fis.read();
		//System.out.println(read);
        
        int read;
		while((read = fis.read()) != -1){
			System.out.println((char)read);
		}
				
		//3.关闭资源
		fis.close();
	}
}
  1. 文件不存在

经验：所有文件输入流，在文件不存在的情况下都会报错 – FileNotFoundException

public class Test06 {
	public static void main(String[] args) throws IOException{
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据
		//read(bs)：读取bs长度的数据，并把数据放入数组，返回读取到的有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];
		int len;
		while((len = fis.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}	
		
		//3.关闭资源
		fis.close();
	}
}
  1. 处理异常
public class Test07 {
	public static void main(String[] args){
		
		FileInputStream fis = null;
		try {
			//1.创建流对象
			fis = new FileInputStream("io.txt");
			
			//2.读取数据
			//read(bs)：读取bs长度的数据，并把数据放入数组，返回读取到的有效字节数，如果读取到文件末尾则返回-1
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				System.out.println(new String(bs, 0, len));
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

5.3 深入 带缓冲区的字节输出流 FileOutputStream

public class Test04 {
	public static void main(String[] args) throws IOException{
		
		FileOutputStream fos = new FileOutputStream("io.txt");  基础流
		//写几次，就和硬盘交互几次  -- 6次（内存与硬盘交互的次数）
		fos.write("1".getBytes());
		fos.write("2".getBytes());
		fos.write("3".getBytes());
		fos.write("a".getBytes());
		fos.write("b".getBytes());
		fos.write("c".getBytes());
		fos.close();
		
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		//将数据写入到字节缓冲数组中 -- 1次（内存与硬盘交互的次数）
		bos.write("1".getBytes());
		bos.write("2".getBytes());
		bos.write("3".getBytes());
		bos.write("a".getBytes());
		bos.write("b".getBytes());
		bos.write("c".getBytes());
		//关闭时才将数据写入到文件中
		bos.close();
		
		//默认缓冲区 -- 8192个字节(8*1024)
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		
		//自定义缓冲区大小 -- 2048个字节
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"), 2048);
	}
}

5.4 利用 带缓冲区的字节输出流 向文件写入数据BufferedOutputStream

1)不处理异常的方式

2)文件存在的情况

3)文件不存在的情况

经验：所有的输出流，文件不存在的情况都会创建文件

public class Test01 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象                     处理流
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		
		//2.写入数据
		bos.write("123abc".getBytes());
		
		//3.关闭资源
		bos.close();
		
	}
}

4)在文件末尾追加内容

经验：在文件末尾追加考虑基础流的构造方法

public class Test02 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt",true));
		
		//2.写入数据
		bos.write("123abc".getBytes());
		
		//3.关闭资源
		bos.close();
		
	}
}

5)处理异常的方式

public class Test03 {
	public static void main(String[] args){
		
		
		BufferedOutputStream bos = null;
		try {
			//1.创建流对象
			bos = new BufferedOutputStream(new FileOutputStream("io.txt",true));
			//2.写入数据
			bos.write("123abc".getBytes());
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(bos != null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
		
	}
}

5.5 手撕BufferedOutputStream底层源码

public class FilterOutputStream extends OutputStream {
    
	protected OutputStream out;//0x001
    
    //out - 0x001
    public FilterOutputStream(OutputStream out) {
        this.out = out;
    }
    
    //b - [65]
    public void write(byte[] b) throws IOException {
        this.write(b, 0, b.length);
    }
    
    @SuppressWarnings("try")
    public void close() throws IOException {
        try (OutputStream ostream = out) {
            flush();
        }
    }
}

public class BufferedOutputStream extends FilterOutputStream {
    //缓冲区数组
    protected byte[] buf;//new byte[8192]
    //缓冲区存放数据的个数
    protected int count;//1
    
    //out - 0x001
    public BufferedOutputStream(OutputStream out) {
        this(out, 8192);
    }
    
    //out - 0x001
    //size - 8192
    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];
    }
    
    //b - [65]
    //off - 0
    //len - 1
    public synchronized void write(byte b[], int off, int len) throws IOException {
        //判断现在需要写出的数据长度是否大于缓冲区数组
        if (len >= buf.length) {//1 >= 8192
            //将缓冲区数组里的数据写入到文件,将缓冲区清空
            flushBuffer();
            //将线程需要写出的数据写入到文件
            out.write(b, off, len);
            return;
        }
        
        //判断现在需要写出的数据长度 超过了缓冲区剩余的存储长度
        if (len > buf.length - count) {//1 > 8192-0
            //将缓冲区数组里的数据写入到文件,将缓冲区清空
            flushBuffer();
        }
        //将数据写入到缓冲区数组里
        System.arraycopy(b, off, buf, count, len);
        //更新缓冲区数组数据个数
        count += len;
    }
    
    private void flushBuffer() throws IOException {
        //count > 0说明缓冲区数组里有数据
        if (count > 0) {
            super.out.write(buf, 0, count);//调用的是FileOutputSteam的write()
            count = 0;//缓冲区清空
        }
    }
    
    public synchronized void flush() throws IOException {
        //将缓冲区数组里的数据写入到文件,将缓冲区清空
        flushBuffer();
        super.out.flush();//调用的是FileOutputSteam的close() -- 关流
    }
}

FileOutputStream fos = new FileOutputStream("io.txt");//0x001
BufferedOutputStream bos = new BufferedOutputStream(fos);

bos.write("1".getBytes());
bos.write("2".getBytes());
bos.write("3".getBytes());
bos.write("a".getBytes());
bos.write("b".getBytes());
bos.write("c".getBytes());

bos.close();

5.6 利用 带有缓冲区的字节输入流 读取文件里的数据 BufferedInputStream

  1. 不处理异常

  2. 文件存在

  3. 文件不存在

经验：所有输入流，当文件不存在都会报错

public class Test05 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象 （默认缓冲区大小：8192字节）
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"));
		
		//1.创建流对象 （自定义缓冲区大小：2048字节）
		//BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"),2048);
		
		//2.读取数据 
		byte[] bs = new byte[1024];
		int len;
		while((len = bis.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		bis.close();
	}
}

5.7 拷贝文件

思路：读取源文件，写入目标文件

public class Copy {
	public static void main(String[] args) throws IOException {
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("麻生希.mp4"));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.mp4"));
		
		byte[] bs = new byte[1024];
		int len;
		while((len = bis.read(bs)) != -1){
			bos.write(bs, 0, len);
		}
		
		bis.close();
		bos.close();
	}
}

总结

1.BufferedInputStream 和 BufferedOutputStream
理解底层
理解缓冲区是如何提高效率

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/535197.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

JVM 垃圾回收算法

JVM 垃圾回收算法

JVM 垃圾回收算法 标记清除算法复制算法标记整理算法分代算法 标记清除算法 标记-清除&#xff08;Mark-Sweep&#xff09;算法属于早期的垃圾回收算法&#xff0c;它是由标记阶段和清除阶段构成的。标记阶段会给所有的存活对象做上标记&#xff0c;而清除阶段会把没有被标记的…
阅读更多...
记录一次浅拷贝导致的缺陷

记录一次浅拷贝导致的缺陷

背景&#xff1a;假期表查询&#xff0c;表中存放的工作日信息是按照月份维度的&#xff0c;例如1月的假期表信息是NNNYYYYYNN.....一共31天&#xff0c;如果是工作日那么就是Y&#xff0c;如果非工作日那就是N。获取指定日期的下一个工作日&#xff0c;就会先查出这个月份的这…
阅读更多...
史上首位阿贝尔奖、图灵奖双得主！2023图灵奖授予随机性大佬Avi Wigderson

史上首位阿贝尔奖、图灵奖双得主！2023图灵奖授予随机性大佬Avi Wigderson

ChatGPT狂飙160天&#xff0c;世界已经不是之前的样子。 新建了免费的人工智能中文站https://ai.weoknow.com 新建了收费的人工智能中文站https://ai.hzytsoft.cn/ 更多资源欢迎关注 这位多产的研究者发现了随机性和计算之间的深刻联系&#xff0c;其贡献影响了密码学、复杂性…
阅读更多...
LLM激活稀疏性加速

LLM激活稀疏性加速

相关工作 Deja vu Contextual sparsity for efficient llms at inference time LLM in a flash Efficient Large Language Model Inference with Limited Memory ReLU Strikes Back Exploiting Activation Sparsity in Large Language Models ReLU2 Wins: Discovering Effi…
阅读更多...
家居网购项目（一）

家居网购项目（一）

文章目录 1.前置知识1.项目开发阶段2.Java经典三层架构3.项目具体分层&#xff08;包方案&#xff09;4.MVC 2.开发环境搭建1.新建普通javaweb项目&#xff0c;导入jar包2.创建项目结构3.搭建前端页面 3.会员注册前端js校验1.需求分析2.代码login.html 3.结果4.调试阶段1.验证信…
阅读更多...
[目标检测] OCR: 文字检测、文字识别、text spotter

[目标检测] OCR: 文字检测、文字识别、text spotter

概述 OCR技术存在两个步骤&#xff1a;文字检测和文字识别&#xff0c;而end-to-end完成这两个步骤的方法就是text spotter。 文字检测数据集摘要 daaset语言体量特色MTWI中英文20k源于网络图像&#xff0c;主要由合成图像&#xff0c;产品描述&#xff0c;网络广告(淘宝)MS…
阅读更多...
Linux下使用C语言实现高并发服务器

Linux下使用C语言实现高并发服务器

高并发服务器 这一个课程的笔记 相关文章 协议 Socket编程 高并发服务器实现 线程池 使用多进程并发服务器时要考虑以下几点&#xff1a; 父进程最大文件描述个数(父进程中需要close关闭accept返回的新文件描述符)系统内创建进程个数(与内存大小相关)进程创建过多是否降低整体…
阅读更多...
代码随想录训练营day36

代码随想录训练营day36

第八章 贪心算法 part05 1.LeetCode. 无重叠区间 1.1题目链接&#xff1a;435. 无重叠区间 文章讲解&#xff1a;代码随想录 视频讲解&#xff1a;B站卡哥视频 1.2思路&#xff1a;我来按照右边界排序&#xff0c;从左向右记录非交叉区间的个数。最后用区间总数减去非交叉区…
阅读更多...
yolov8训练自己数据集的一些小细节

yolov8训练自己数据集的一些小细节

例如我的路径格式如下: 这里要保证两个对齐, train/images/img1.jpg,2,3,xxx train/labels/img1.txt,2,3,xxx val/images/img1.jpg,2,3,xxx val/labels/img1.txt,2,3,xxxyaml文件读取路径的时候,个人猜测是依靠替换字符串找标签的, 因为yaml文件里没有指明如何加载labels,它后…
阅读更多...
MobX原理剖析：基于可观察状态和自动依赖追踪的响应式状态管理

MobX原理剖析：基于可观察状态和自动依赖追踪的响应式状态管理

我们用代码示例来说明 MobX 的核心原理。 首先,我们定义一个简单的 Store 类,其中包含一个可观察的计数器状态: import { observable, action } from mobx;class CounterStore {observable count 0;actionincrement () > {this.count;};actiondecrement () > {this.…
阅读更多...
【STM32G431RBTx】备战蓝桥杯嵌入式→省赛试题→第十四届

【STM32G431RBTx】备战蓝桥杯嵌入式→省赛试题→第十四届

文章目录 前言一、题目二、模块初始化三、代码实现interrupt.h:interrupt.c:main.h:main.c: 四、完成效果五、总结 前言 无 一、题目 二、模块初始化 1.LCD这里不用配置&#xff0c;直接使用提供的资源包就行 2.KEY, 四个按键IO口都要配置&#xff0c;分别是PB0, PB1,PB2,PA…
阅读更多...
【端云一体化开发】云函数本地运行/调试启动失败的两种解决方案

【端云一体化开发】云函数本地运行/调试启动失败的两种解决方案

最近本地调试云函数一直出现这个错误&#xff1a;Before launch task execute failed! details:java.lang.lllegalStateException: npm installfailed 这个问题的原因似乎是运行云函数的时候会重新下载 npm 及相关依赖文件&#xff0c;但是 DevEco 的 npm 模块出错导致这个步骤…
阅读更多...
软考121-上午题-【软件工程】-敏捷方法

软考121-上午题-【软件工程】-敏捷方法

一、敏捷方法 敏捷开发的总体目标是通过“尽可能早地、持续地对有价值的软件的交付”使客户满意。通过在软件开发过程中加入灵活性&#xff0c;敏捷方法使用户能够在开发周期的后期增加或改变需求。 敏捷过程的典型方法有很多&#xff0c;每一种方法基于一套原则&#xff0c;这…
阅读更多...
内核驱动更新

内核驱动更新

1.声明我们是开源的 .c 文件末尾加上 2.在Kconfig里面修改设备&#xff0c;bool&#xff08;双态&#xff09;-----》tristate&#xff08;三态&#xff09; 3.进入menuconfig修改为M 4.编译内核 make modules 也许你会看到一个 .ko 文件 5.复制到根目录文件下 在板子…
阅读更多...
【Linux的进程篇章 - 进程终止和进程等待的理解】

【Linux的进程篇章 - 进程终止和进程等待的理解】

Linux学习笔记---008 Linux之fork函数、进程终止和等待的理解1、fork函数1.1、什么是fork?1.2、fork的功能介绍1.3、fork函数返回值的理解1.4、fork函数的总结 2、进程的终止2.1、终止是在做什么&#xff1f;2.2、进程终止的3种情况 3、进程的终止3.1、进程终止的三种情况3.2、…
阅读更多...
深度学习简介

深度学习简介

深度学习简介 一、引言&#xff1a;深度学习的兴起 简短介绍深度学习的历史背景 深度学习&#xff0c;作为人工智能领域的一颗冉冉升起的新星&#xff0c;其根源可以追溯到上世纪的感知机学习算法。这种算法模拟人类的神经元行为&#xff0c;是最早期的尝试之一。然而&#x…
阅读更多...
一天300收入打底，​一个适合任何人的创业项目！

一天300收入打底，​一个适合任何人的创业项目！

共享旅游卡项目&#xff0c;一天300收入打底&#xff0c;一个适合任何人的创业项目&#xff01; 只要你不懒&#xff0c;生活总过得不会太差。只要你不贪&#xff0c;就算不能大富大贵&#xff0c;至少不会负债累累。 人性最难戒掉的两个字&#xff1a;一个是懒&#xff0c;另…
阅读更多...
Web安全漏洞原理（5万字最全总结）

Web安全漏洞原理（5万字最全总结）

资料来源–安恒攻防实验室 目录 SQL注入漏洞 漏洞原理 举例说明 测试方式 数字型注入&#xff1a;字符型注入&#xff1a;搜索型注入&#xff1a; 判断注入方式如何利用漏洞 识别数据库类型注入方法&#xff08;union&#xff09; 绕过过滤方式 大小写混合替换关键字使用编码…
阅读更多...
Java——数组练习

Java——数组练习

目录 一.数组转字符串 二.数组拷贝 三.求数组中元素的平均值 四.查找数组中指定元素(顺序查找) 五.查找数组中指定元素(二分查找) 六.数组排序(冒泡排序) 七.数组逆序 一.数组转字符串 代码示例&#xff1a; import java.util.Arrays int[] arr {1,2,3,4,5,6}; String…
阅读更多...
Python(1)：认识Python并且了解一些简单函数

Python(1)：认识Python并且了解一些简单函数

文章目录 一、Python的优势及其使用场景二、Python环境的安装三、Python中的变量及其命名四、Python中的注释五、一些简单常见的函数和认识ASCII表六、Python导入模块的方式 一、Python的优势及其使用场景 优点&#xff1a; 开发效率高&#xff1a;Python具有非常强大的第三方…
阅读更多...
最新文章

Copyright @ 2022~2023