IO流----字节流

news2025/1/23 22:25:40

字节流

  • 字节流：
    • 操作：
      • 文件字节输入输出流 ：
        • 写入数据：
        • 读取数据：
        • 文件拷贝：
      • 带缓冲区的字节输入输出流：
        • 拷贝文件：
        • 写入数据：
        • 读取数据:
    • 深入 带缓冲区的字节输出流 ：
      • 底层源码：

字节流：

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

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字节----> new byte[8192]

在这里插入图片描述

 
 

操作：

文件字节输入输出流 ：

写入数据：

利用 文件字节输出流 向文件 写入 数据。
 
​        1. 不处理异常

​        2. 当文件存在时

​        3. 当文件不存在时
 
经验：所有的输出流，当文件不存在时都会创建该文件。

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. 不处理异常

​        2. 当文件存在时

​        3. 当文件不存在时

​        4. 在文件末尾追加内容
 
经验：在文件末尾追加考虑基础流的构造方法。

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. 不处理异常

​        2. 当文件存在时

​        3. 当文件不存在时

​        4. 在文件末尾追加内容

​        5. 处理异常

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();
				}
			}
		}
	}

 
 

读取数据：

利用 文件字节输入流 读取文件里的数据。
 
​        1. 不处理异常

​        2. 文件存在

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);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		
		
		//3.关闭资源
		fis.close();
	}

 
 

改进：

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

 
 

再改进：

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. 不处理异常

​        2. 文件存在

​        3. 文件不存在

​        4. 处理异常

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();
				}
			}
		}
		
	}

 
 

文件拷贝：

读取源文件，写入目标文件。

public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("Original.mp4");
		FileOutputStream fos = new FileOutputStream("copy.mp4");
		
    	//一个一个字节的拷贝，速度太慢
		int read;
		while((read = fis.read()) != -1){
			fos.write(read);
		}
		
		fis.close();
		fos.close();
	}

 
 

改进:

public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("Original.mp4");
		FileOutputStream fos = new FileOutputStream("copy.mp4");
		//read(bs)：读取bs长度的数据，并把数据放入数组，
    	//返回读取到的有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];
		int len;
		while((len = fis.read(bs)) != -1){
			fos.write(bs, 0, len);
		}
		
		fis.close();
		fos.close();
	}

 
 

异常处理：

public static void main(String[] args){
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("Original.mp4");
			fos = new FileOutputStream("copy.mp4");
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

 
 

改进：

public static void main(String[] args){
		
		//注意：小括号里创建的流会在try...catch后自动关闭
		try(FileInputStream fis = new FileInputStream("Original.mp4");
				FileOutputStream fos = new FileOutputStream("copy.mp4");) {
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

 
 

带缓冲区的字节输入输出流：

拷贝文件：
public static void main(String[] args) throws IOException {
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Original.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. 不处理异常的方式

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

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();
		
	}

 
 

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

  1. 不处理异常的方式

  2. 文件存在的情况

  3. 文件不存在的情况

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

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();
		
	}

 
 

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

  1. 不处理异常的方式

  2. 文件存在的情况

  3. 文件不存在的情况

  4. 在文件末尾追加内容

  5. 处理异常

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();
				}
			}
		}
	}

 
 

读取数据:

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

  1. 不处理异常

  2. 文件存在

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

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();
	}

 
 

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

  1. 不处理异常
  2. 文件存在
  3. 文件不存在
  4. 异常处理
public static void main(String[] args) {
		
		
		BufferedInputStream bis = null;
		try {
			//1.创建流对象 （默认缓冲区大小：8192字节）
			bis = new BufferedInputStream(new FileInputStream("io.txt"));
			
			//2.读取数据 
			byte[] bs = new byte[1024];
			int len;
			while((len = bis.read(bs)) != -1){
				System.out.println(new String(bs, 0, len));
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(bis != null){
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

 
 

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

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);
	}

 
 

底层源码：

//继承关系
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();

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

OTTO、亚马逊、Temu卖家如何运用测评补单来提高购买率？

OTTO、亚马逊、Temu卖家如何运用测评补单来提高购买率？

在跨境电商的广阔舞台上&#xff0c;测评补单无疑是一股不可或缺的强劲动力。商家们深知&#xff0c;通过补单这一手段&#xff0c;能够快速为产品注入活力&#xff0c;使销量迅猛攀升&#xff0c;评论如潮涌至&#xff0c;进而在激烈的竞争中脱颖而出&#xff0c;勇攀销量之巅…
阅读更多...
论文AI率不达标？AI工具助你一臂之力

论文AI率不达标？AI工具助你一臂之力

告诉大家一个非常残忍的答案&#xff0c;以后所有论文都会被查ai率的。 学术界不仅关注传统的抄袭问题&#xff0c;还增加了一项名为“AIGC检测”的指标。例如知网、维普等平台都能检测论文AI率。 用GPT写论文虽然重复率基本不用担心&#xff0c;但是AI率基本都较高&#xff…
阅读更多...
异常概述

异常概述

自学python如何成为大佬(目录):https://blog.csdn.net/weixin_67859959/article/details/139049996?spm1001.2014.3001.5501 在程序运行过程中&#xff0c;经常会遇到各种各样的错误&#xff0c;这些错误统称为“异常”。这些异常有的是由于开发者将关键字敲错导致的&#xf…
阅读更多...
探索魁北克：IT专业人士的移民新天地

探索魁北克：IT专业人士的移民新天地

在这个数字化飞速发展的时代&#xff0c;IT专业人士无疑是推动社会进步的关键力量。魁北克省&#xff0c;作为加拿大的科技与文化中心&#xff0c;正以其开放的姿态和优越的移民政策&#xff0c;吸引着全球IT精英的目光。今天&#xff0c;让我们一起探索魁北克省为IT专业人士量…
阅读更多...
用 DataGridView 控件显示数据

用 DataGridView 控件显示数据

使用DataGridView&#xff0c;可以很方便显示数据。 1.为解决方案添加数据集XSD&#xff0c;用作为项目数据源。 2.拖DataGridView控件到WinForms上。 3.在DataGridView控件的任务处&#xff0c;选择数据源。 4.选好数据源后&#xff0c;VS自动添加DataSet、BindingSourse和T…
阅读更多...
2024年5月第四周LLM重要论文总结

2024年5月第四周LLM重要论文总结

本文总结了2024年5月第四周发表的一些最重要的LLM论文。这些论文的主题包括模型优化和缩放到推理、基准测试和增强性能。 LLM发展与基准 1、Towards Modular LLMs by Building and Reusing a Library of LoRAs 基本大型语言模型(LLM)的参数越来越对&#xff0c;这就要求我们研…
阅读更多...
nvm for wins下载地方

nvm for wins下载地方

https://github.com/coreybutler/nvm-windows
阅读更多...
使用springboot+vue实现阿里云oss上传

使用springboot+vue实现阿里云oss上传

一、前言 我们后端开发中&#xff0c;时常需要用到文件上传的功能&#xff0c;无非是保存到服务器本地或者如阿里云、七牛云这种云存储的方案。本篇介绍一种使用后台springboot结合前端vue实现阿里云oss上传的功能。 二、前端实现过程 前端实现一个通用的上传组件UploadFile…
阅读更多...
C# 声音强度图绘制

C# 声音强度图绘制

C# 声音强度图绘制 采集PCM音频数据 音频原来自麦克风 音频源来自录音文件 处理PCM音频数据 将PCM数据进行强度值换算 private void UpdateVoice(double[] audio){// 计算RMS值double rms Math.Sqrt(audio.Select(x > x * x).Average());// 将RMS值转换为分贝值&#x…
阅读更多...
【Js】深入浅出的js for循环 for loop以及闭坑指南

【Js】深入浅出的js for循环 for loop以及闭坑指南

在JavaScript中使用forEach循环来删除数组中的特定元素可能会导致一些问题&#xff0c;因为forEach不允许你在迭代过程中修改数组的长度。 这会导致意外的行为&#xff0c;例如跳过元素或错误地索引。因此&#xff0c;建议使用其他方法来安全地删除数组中的元素。 存在的问题 1…
阅读更多...
大数据基础问题：在Hive中如何实现全增量统一的UDTF、内置函数、聚合、Join等计算引擎常见算子？

大数据基础问题：在Hive中如何实现全增量统一的UDTF、内置函数、聚合、Join等计算引擎常见算子？

仁者见仁智者见智&#xff0c;每个程序员的方法都不一样&#xff0c;老的程序员和新的程序员之间的思维差距很大&#xff0c;新入公司的和老员工的代码差距也很大。 在Apache Hive中&#xff0c;实现全增量统一的用户定义表生成函数&#xff08;UDTF&#xff09;、内置函数、聚…
阅读更多...
数据结构：模拟栈

数据结构：模拟栈

数据结构&#xff1a;模拟栈 题目描述参考代码 题目描述 输入样例 10 push 5 query push 6 pop query pop empty push 4 query empty输出样例 5 5 YES 4 NO参考代码 #include <iostream>using namespace std;const int N 1000010;int m, x; int q[N]; string op; int…
阅读更多...
爬虫之反爬思路与解决手段

爬虫之反爬思路与解决手段

阅读时间建议&#xff1a;4分钟 本篇概念比较多&#xff0c;嗯。。 0x01 反爬思路与解决手段 1、服务器反爬虫的原因 因为爬虫的访问次数高&#xff0c;浪费资源&#xff0c;公司资源被批量抓走&#xff0c;丧失竞争力&#xff0c;同时也是法律的灰色地带。 2、服务器反什么…
阅读更多...
Docker基础篇之Docker常规软件安装

Docker基础篇之Docker常规软件安装

文章目录 1. 总体步骤2. 安装tomcat3. 安装Mysql4. 安装Redis 1. 总体步骤 安装软件的总体步骤如下所示&#xff1a; 搜索镜像拉取镜像查看镜像启动镜像停止容器移除容器 2. 安装tomcat docker hub上查找tomcat镜像 或者使用一下命令查找&#xff1a; docker search tomca…
阅读更多...
微信小游戏性能优化解决方案全新发布

微信小游戏性能优化解决方案全新发布

小游戏凭借其简单易上手、玩法多样、互动性强的特点&#xff0c;迅速在市场中崭露头角。MMO、ARPG、卡牌等游戏类型也纷纷入局。玩家对启动时间长、发热、加载缓慢、闪退等问题也越来越敏感。 为了突破这些性能瓶颈&#xff0c;UWA全新发布了针对微信小游戏的性能优化解决方案…
阅读更多...
240.搜索二维矩阵

240.搜索二维矩阵

题目描述 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性&#xff1a; 每行的元素从左到右升序排列。每列的元素从上到下升序排列。 示例 1&#xff1a; 输入&#xff1a;matrix [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,…
阅读更多...
深度学习中torch.max函数的作用

深度学习中torch.max函数的作用

文章目录 解释代码举例 解释 torch.max 是 PyTorch 中的一个函数&#xff0c;用于在张量中沿指定维度计算最大值。它有两种用法&#xff1a; ① 如果只提供一个输入张量&#xff0c;则返回该张量中的最大值和对应的索引。     ② 如果提供两个输入张量&#xff0c;则返回两…
阅读更多...
算法学习笔记——时间复杂度和空间复杂度

算法学习笔记——时间复杂度和空间复杂度

时间复杂度和空间复杂度 常数操作&#xff1a; 固定时间的操作&#xff0c;执行时间和数据量无关 位运算 > 算数运算 > 寻址 > 哈希运算&#xff0c;都是常数操作&#xff0c;哈希运算操作时间最慢 链表的get(i)方法不是常数操作&#xff0c;因为链表不是连续的存储…
阅读更多...
【第三节】C/C++数据结构之栈与队列

【第三节】C/C++数据结构之栈与队列

目录 一、数据结构-栈 1.1 栈的定义 1.2 栈的 ADT (Abstract Data Type) 1.3 栈的顺序存储结构及实现 二、数据结构-队列 2.1 队列的定义 2.2 队列的 ADT 2.3 队列的顺序存储结构与实现 2.4 优先队列 2.5 各种队列异同点 一、数据结构-栈 1.1 栈的定义 栈(Stack)可…
阅读更多...
[数据集][目标检测]道路圆石墩检测数据集VOC+YOLO格式461张1类别

[数据集][目标检测]道路圆石墩检测数据集VOC+YOLO格式461张1类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;462 标注数量(xml文件个数)&#xff1a;462 标注数量(txt文件个数)&#xff1a;462 标注类别…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023