javaIO ---字节流与字符流

最新推荐文章于 2022-11-23 13:03:03 发布
最新推荐文章于 2022-11-23 13:03:03 发布
阅读量141 收藏
点赞数
分类专栏： JAVA下半部分学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47798423/article/details/114679927
版权

流的基本概念

服务器与客户端传输的就是数据流，或者说比特流。
java.io包中的字节处理流：

  • 输出字节流：OutputStream
  • 输入字节流：InputStream

字符处理流：

  • 输出字符流：Writer
  • 输出字节流：Reader

对文件的读写流程：

  1. 通过File类找到文件路径
  2. 通过字节流或字符流对对象进行实例化
  3. 利用字节流与字符流的方法实现数据的输入输出
  4. 流操作属于资源操作，必须进行关闭处理

OutputStream字节输出流

类的声明：public abstract class OutputStream extends Object implements Closeable, Flushable
有两个接口：

CloseableFlushable
jdk1.5jdk1.5
void close();void flush();

Closeable接口实现了AutoCloseable接口（jdk1.7，出现了try…catch）

OutputStream类中定义了三个内容输出的方法：

方法名作用
public abstract void write(int b)throws IOException;输出单个字节数据
public void write(byte b[])throws IOException;输出一组字节数据
*public void write(byte b[],int off,int len)throws IOException;输出部分字节数据

（off参数表示偏移量，一般为0.）

OutputStream类是抽象类，实现其方法需要通过子类向上转型。那么子类（FileOutputStream）的关注点主要放在构造方法上即可。
例：FileOutputStream
【覆盖】构造方法：public FileOutputStream(File file)throws FileNotFoundException
【追加】构造方法：public FileOutputStream(File file,boolean append)throws FileNotFoundException

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class OutputTest {

	public static void main(String[] args) throws Exception {
		File file=new File("F:\\course\\output.txt");
		if(!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		OutputStream out=new FileOutputStream(file);
		String str="hello first file 操作";
		out.write(str.getBytes());
		out.close();
	}

}

由于OutputStream是AutoCloseable的子类，所以可以执行自动关闭处理。
但是否执行自动关闭取决于项目的整体结构。

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputTest {

	public static void main(String[] args) throws Exception {
		File file=new File("F:\\course\\output.txt");
		if(!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		try(OutputStream out=new FileOutputStream(file,true)){
			String str="hello first file 操作\r\n";//\n是换行，\r\n是标准换行
			out.write(str.getBytes());
		}catch(IOException e) {
			e.printStackTrace();
		}
	}

}

InputStream字节输入流

类的声明：public abstract class InputStream extends Object implements Closeable
主要方法：

方法名作用
public abstract int read(int b)throws IOException;输出单个字节数据（如果数据读取到末尾，返回“-1”）
*public int read(byte b[])throws IOException;输出一组字节数据（返回值为读取数据的个数，如果没有数据（已经读取到底）返回“-1”）
public int read(byte b[],int off,int len)throws IOException;输出一组字节数据的部分

InputStream是抽象类，依靠子类FileInputStream向上转型实现。
例：

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class InputTest {

	public static void main(String[] args) throws Exception {
		File file=new File("F:\\course\\Output.txt");
		if(file.exists()) {
			InputStream in=new FileInputStream(file);
			byte bt[]=new byte[1024];
			int len = in.read(bt);
			System.out.println("["+new String(bt,0,len)+"]");
			in.close();
		}
	}

}

字节输入流的问题，使用read()方法只能以字节数组为主进行接收。

jdk1.9中出现了一个方法：public byte[] readAllBytes()throws IOException;
如果要读取的内容很大，会使程序崩溃。最多10K。

Writer字符输出流

jdk1.1，java.io包
类声明：public abstract class Writer extends Object implements Appendable, Closeable, Flushable

接口名版本方法
Closeablejdk1.5void close();
Flushablejdk1.5void flush();
Appendablejdk1.5void append();

输出方法：

方法作用
public void write(char[] cbuf)throws IOException;输出字符数组
public void write(String str)throws IOException;输出字符串

范例：使用write输出：

import java.io.File;
import java.io.FileWriter;
import java.io.Writer;

public class WriterTest {

	public static void main(String[] args) throws Exception {
		File file = new File("F:/course/file.txt");
		if(!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		Writer out=new FileWriter(file,true);
		String str="?????????我被冷落了QAQ\n";
		out.append(str);
		out.close();
	}

}

使用Writer输出的最大优势在于可以使用字符串完成，字符流最大的优势在处理中文数据上。

Reader字符输入流

类声明：public abstract class Reader extends Object implements Readable, Closeable

接口名版本方法
Closeablejdk1.5void close();
Readablejdk1.5void read();

Reader里面没有提供整个字符串的输入处理操作，只能进行字符数组进行接收。

方法名作用
public abstract int read()throws IOException;输出单个字节数据（如果数据读取到末尾，返回“-1”）
*public int read(char[] cbuf )throws IOException;输出一组字节数据（返回值为读取数据的个数，如果没有数据（已经读取到底）返回“-1”）
public int read(char[] cbuf ,int off,int len)throws IOException;输出一组字节数据的部分

范例：实现数据读取

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

public class ReaderTest {

	public static void main(String[] args) throws Exception {
		File file=new File("F:/course/file.txt");
		if(file.exists()) {
			Reader in=new FileReader(file);
			char ch[]=new char[1024];
			int len=in.read(ch);
			System.out.println("["+new String(ch,0,len)+"]");
			in.close();
		}
	}

}

字节流与字符流的区别

输出流比较：
OutputStream类中，不close()关闭文件内容正常输出。
Writer类中，不使用close()文件内容无法输出。
原因：Writer使用了缓存区，使用close方法会强制刷新缓冲区，close时会将内容进行刷新，否则不刷新。如果想要在不使用close的情况下使结果输出可以使用flush方法强制清空。

import java.io.File;
import java.io.FileWriter;
import java.io.Writer;

public class WriterTest {

	public static void main(String[] args) throws Exception {
		File file = new File("F:/course/file.txt");
		if(!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		Writer out=new FileWriter(file,true);
		String str="?????????我被冷落了QAQ\n";
		out.append(str);
		out.flush();//强制刷新
		//out.close();
	}

}

字节流处理的时候不会使用缓冲区，但是字符流在进行处理的时候会使用到缓冲区。使用到缓冲区的字符流更加适合中文的处理。
字节流和字符流的处理方式相似，IO很多情况下是使用二进制，所以大都以字节流为主。

转换流

实现字节流和字符流的功能转换。
两个转换流的类：InputStreamReader，OutputStreamWriter
类的声明：

OutputStreamReaderInputStreamWriter
public class OutputStreamWriter extends Writerpublic class InputStreamReader extends Reader
public OutputStreamWriter​(OutputStream out)public InputStreamReader​(InputStream in)

在这里插入图片描述
通过类的结构和构造方法可以发现，转换处理本质是对象的转型和构造方法的接收，就是通过字节流对象通过向上转型变成字符流对象。

转换流主要是为了让我们明确的对结构分析处理。
FileReader和FileWriter的继承关系：

FileReaderFileWriter
public class FileReader extends InputStreamReaderpublic class FileWriter extends OutputStreamWriter

在这里插入图片描述

案例：文件拷贝

需求分析：

  1. 实现各种文件的拷贝，使用字节流。
  2. 大文件的拷贝问题。

方案：

  1. 使用InputStream将文件中所有的内容读到程序中，才一次性写入目标文件。（如果文件很大会让程序崩溃）
  2. 采用部分拷贝。

使用方法：

  • public void write(byte b[],int off,int len)throws IOException;
  • public void read(byte b[])throws IOException;

实现文件拷贝处理：（原始方法）

package wzr.study09.io;

import java.io.*;

public class FileUtilTest {

	public static void main(String[] args) throws Exception {
		if(args.length!=2) {
			System.out.println("格式：java filename str1 str2");
			System.exit(1);
		}
		long start=System.currentTimeMillis();
		FileUtil fu=new FileUtil(args[0],args[1]);
		System.out.println(fu.copy()?"文件拷贝成功":"文件拷贝失败");
		
		long end=System.currentTimeMillis();
		System.out.println("拷贝完成的时间："+(end-start));
	}

}
class FileUtil{
	private File srcfile;
	private File desfile;
	
	public FileUtil(File src,File des) {
		srcfile=src;
		desfile=des;
	}
	public FileUtil(String src,String des) {
		this(new File(src), new File(des));
	}
	public boolean copy() throws Exception {
		if(!srcfile.exists()) {
			System.out.println("拷贝的源文件不存在");
			return false;
		}
		if(!desfile.getParentFile().exists()) {
			desfile.getParentFile().mkdirs();
		}
		byte bt[]=new byte[1024];
		InputStream input=null;
		OutputStream output=null;
		try {
			input=new FileInputStream(srcfile);
			output=new FileOutputStream(desfile);
			
			int len=0;
			while((len=input.read(bt))!=-1) {
				output.write(bt,0,len);
			}
			return true;
			
		}catch(Exception e) {
			throw e;
		}finally {
			if(input!=null) {
				input.close();
			}
			if(output!=null) {
				output.close();
			}
		}
	}
}

jdk1.9开始，输入流InputStream和Reader都追加有缓存的处理方法
InputStream：public long transferTo(OutputStream out)throws Exception;
OutputStream：public long transferTo(Writer out)throws Exception;
使用转存的方式处理：

package wzr.study09.io;

import java.io.*;

public class FileUtilTest {

	public static void main(String[] args) throws Exception {
		if(args.length!=2) {
			System.out.println("格式：java filename str1 str2");
			System.exit(1);
		}
		long start=System.currentTimeMillis();
		FileUtil fu=new FileUtil(args[0],args[1]);
		System.out.println(fu.copy()?"文件拷贝成功":"文件拷贝失败");
		long end=System.currentTimeMillis();
		System.out.println("拷贝完成的时间："+(end-start));
	}

}
class FileUtil{
	private File srcfile;
	private File desfile;
	
	public FileUtil(File src,File des) {
		srcfile=src;
		desfile=des;
	}
	public FileUtil(String src,String des) {
		this(new File(src), new File(des));
	}
	public boolean copy() throws Exception {
		if(!srcfile.exists()) {
			System.out.println("拷贝的源文件不存在");
			return false;
		}
		if(!desfile.getParentFile().exists()) {
			desfile.getParentFile().mkdirs();
		}
		InputStream input=null;
		OutputStream output=null;
		try {
			input=new FileInputStream(srcfile);
			output=new FileOutputStream(desfile);
			input.transferTo(output);//没有避开文件过大的情况
			return true;
			
		}catch(Exception e) {
			throw e;
		}finally {
			if(input!=null) {
				input.close();
			}
			if(output!=null) {
				output.close();
			}
		}
	}
}

文件夹拷贝：

package wzr.study09.io;

import java.io.*;

public class FileUtilTest {

	public static void main(String[] args) throws Exception {
		if(args.length!=2) {
			System.out.println("格式：java filename str1 str2");
			System.exit(1);
		}
		long start=System.currentTimeMillis();
		FileUtil fu=new FileUtil(args[0],args[1]);
		if(new File(args[0]).isFile()) {
			System.out.println(fu.copyFile()?"文件拷贝成功":"文件拷贝失败");
		}else {
			System.out.println(fu.copyDir()?"文件夹拷贝成功":"文件夹拷贝失败");
		}
		long end=System.currentTimeMillis();
		System.out.println("拷贝完成的时间："+(end-start));
	}

}
class FileUtil{
	private File srcfile;
	private File desfile;
	
	public FileUtil(File src,File des) {
		srcfile=src;
		desfile=des;
	}
	public FileUtil(String src,String des) {
		this(new File(src), new File(des));
	}
	public boolean copyDir() throws Exception{
		try {
			copyDirImpl(this.srcfile);
			return true;
		}catch(Exception e) {
			return false;
		}
	}
	public boolean copyFile() throws Exception {
		if(!srcfile.exists()) {
			System.out.println("拷贝的源文件不存在");
			return false;
		}
		return copyFileImpl(this.srcfile,this.desfile);
	}
	private void copyDirImpl(File file) throws Exception{
		if(file.isDirectory()) {
			File result[]=file.listFiles();
			if(result!=null) {
				for(File obj:result) {
					copyDirImpl(obj);
				}
			}
		}else {
			System.out.println(file.getPath().replace(this.srcfile.getPath()+File.separator, ""));
//			String newfilepath=file.getPath().replace(this.srcfile.getPath()+File.separator, "");
//			File newfile=new File(this.desfile,newfilepath);
//			copyFileImpl(file,newfile);
		}
	}
	private boolean copyFileImpl(File srcfile,File desfile) throws Exception{
		if(!desfile.getParentFile().exists()) {
			desfile.getParentFile().mkdirs();
		}
		byte bt[]=new byte[1024];
		InputStream input=null;
		OutputStream output=null;
		try {
			input=new FileInputStream(srcfile);
			output=new FileOutputStream(desfile);
			//input.transferTo(output);//没有避开文件过大的情况
			int len=0;
			while((len=input.read(bt))!=-1) {
				output.write(bt,0,len);
			}
			return true;
			
		}catch(Exception e) {
			return false;
		}finally {
			if(input!=null) {
				input.close();
			}
			if(output!=null) {
				output.close();
			}
		}
	}
}
噢耶～
关注
专栏目录
java-io流学习总结.doc
11-24
Java IO 流学习总结的主要内容是对 Java 语言中 IO 流的机制和应用进行了详细的介绍，包括流的基本概念、字节流和字符流的区别、IO 体系的基本结构、FileReader 和 FileWriter 的使用、IO 流的应用等等。
Java I/O流处理字节类和字符类及例子
Coder_py的博客
03-09 574
对字符和字节的处理，在Java的I/O包里面有很好的处理类 1字节的处理 有FileOutputScream和FileInputScream两个常用类 FileInputScream构造方法常用两个，一个FileInputScream(File file)和FileInputScream(String name),FileOutputScream一样。 FileOutputScream对应
JavaIO流：概述
栗筝i的博客
11-23 3828
在接触 IO 流前，无论是 变量的声明、数组的创建，又或者是复杂的并发设计还是 Jvm 的性能调优，我们更多的还是和内存打交道。但我们知道计算机组成包括运算器，控制器，存储器，输入设备，输出设备。也就是不仅仅只有内存和 CPU，所以程序设计语言必须要提供程序与外部设备交互的方式，这就是 IO 框架的由来。我们需要和外部设备进行数据的交互。本篇内容包括：关于 IO 流、关于 Java IO 流、Java IO 层次体系结构
IO相关问题总结
weixin_44491927的博客
11-18 1296
Java IO流有什么特点？ Java IO流分为几种类型？ 字节流和字符流的关系与区别？ 字符流是否使用了缓冲？ 缓冲流的效率一定高吗？为什么？ 缓冲流体现了Java中的哪种设计模式思想？ 为什么要实现序列化?如何实现序列化? 序列化数据后，再次修改类文件，读取数据会出问题，如何解决呢?
[Java]_[初级]_[实用的byte处理类]
Tobey(我是机器人)
02-24 4963
场景: 1. C++可以使用std::string来缓存uint8_t的字节数组,比如在接收socket数据包时, 需要接收完整才可以处理某些数据，这时候就需要先缓存起来再处理。 2. 问题来了，Java的String是存储的UNICODE双字节结构,而且只支持字符,不支持如\0这些字符,并不适合处理字节数据.
Java字节数组处理工具类-Mina的IoBuffer封装
带着键盘走江湖。。。
05-30 5574
Java字节数组处理工具类-Mina的IoBuffer封装处理网络数据的项目中经常需要处理字节数据，Java的ByteBuffer很强大，但是Mina和Netty两个常用的网络通信框架都拥有自己的数据读取Buffer，分别是IoBuffer和ByteBuff，IoBuffer基于Java原生ByteBuffer封装而成，ByteBuff则是Netty自己独有的字节数据Buffer，可以实现零拷贝。封
Java IO流常用字节字符流原理解析
08-19
Java IO流中的字节流和字符流是两个基本的流类型，字节流用于对文件、网络等进行读写操作，而字符流用于对文本文件、网络等进行读写操作。了解Java IO流的原理和实现，可以帮助我们更好地使用Java IO流来进行文件、...
详解Java中字符流与字节流的区别
09-02
根据处理的数据单位，Java提供了两种主要类型的流：字符流和字节流。这两种流在处理数据时有显著的区别，尤其是在处理文本数据和二进制数据时。 1. 什么是流 流在Java中是一个抽象概念，它描述了数据如何从一个地方...
Java-IO流/Stream流总结
最新发布
07-12
IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、转换、异常处理以及Stream流的使用。 1. **IO流分类** - **...
commons-io-1.4.jar.zip_io流jar
09-23
Java IO流体系结构分为四类：字节流（Byte Stream）、字符流（Character Stream）、对象流（Object Stream）和套接字流（Socket Stream）。字节流处理单个8位的字节，而字符流基于Unicode编码，处理16位的字符。对象...
最全面的Java字节byte操作,处理Java基本数据的转换及进制转换操作工具
eguid音视频技术分享（JavaCV教程、FFmpeg教程、openCV图像处理教程、音视频教程）
05-12 8039
前言：用于处理Java基本数据的转换及进制转换操作工具 一、实现功能 1、int与byte互转 2、int与byte[]互转 3、short与byte互转 4、short与byte[]互转 5、16位short与byte[]互转 6、long与byte[]互转 7、byte[]与inputstream互转 8、byte与String互转 9、16进制字符转int 10、十进制
Java技术篇·IO包·字节流
筱光的博客
11-18 785
前言 Java中，IO流从数据流向可以分为输入流、输出流，从外部设备流向中央处理器的数据流成为“输入流”，反之成为“输出流”。流还可分为字节流、字符流。字节流和字符流的区别： 字节流读取的时候，读到一个字节就返回一个字节；字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编码表，将查到的字符返回。 字节流可以处理所有类型数据，如：图片...
Day17_8 Java学习之IO、字节流与字符流
weixin_43717536的博客
08-17 338
解析：1.IO分别代表输入（Input）流和输出（Output）流。2.在Java中所有数据都是使用流读写的。流是一组有序的数据序列，将数据从一个地方带到另一个地方。3.就是java提供的一个IO技术，它主要的功能就是把我们程序中的数据可以保存到程序以外的其他持久设备中(如：我们电脑的硬盘)，或者从其他持久设备中。4.按流向分为：输入（Input）流和输出（Output）流；按类型分为：字节输入：InputStream ，字节输出：OutputStream。...
java I/O流：字节流和字符流（概要及其方法）
a1160568825的博客
04-13 1595
** java I/O流：字节流和字符流（概要及其方法） ** IO流按照操作数据的不同可分为字节流和字符流。按照数据传输方向的不同又可以分为输入流和输出流。程序从输入流中读取数据，向输出流中写入数据。 在IO包中，字节流的输入/输出流分别用java.io.Reader和java.io.Writer表示。 - [ 一] 字节流： 针对字节输入、输出提供的一系列流。 文本、图片、音频和视频都是以字节的形式存在的，因此要对这些内容进行传输就要使用字节流。 两个抽象类：InputStream（字节输入流 ）、O
位（bit）字节（byte）字节流 字
aaaaaa177的博客
02-18 1338
  一、位和字节   1字节（byte）=8位（bit） 1KB=1024B   1Mb=1024KB   1字符=2字节   所有文件储存都是以字节（byte）存的。   磁盘保留的是：将字符编码成字节，再存；而不是存文件的字符。 读取文件（特别文本文件）：一个字节一个字节地读取，形成字节序列。 注：二进制0101010中0或1所占的就是1个位（bit）     ...
Java、BitOutputStream
m0_62659797的博客
07-31 285
代码】Java、BitOutputStream。
Java中的IO流之数据流和对象流
java面试笔试
08-07 1113
今天我们来了解一下数据流和对象流数据流数据输出流数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。通过 ...
H.264 NAL单元流和字节流之间的关系，二者均称作比特流。
wmnmtm的专栏
07-28 412
 原文（标准第33/341页）： 6.1 比特流格式本小节规定NAL单元流和字节流之间的关系，二者均称作比特流。比特流可以有两种格式：NAL 单元流格式或字节流格式。从概念上来说，NAL 单元流格式是一个更为“基本”的类型。由一系列称为NAL 单元的语法结构组成，按照解码顺序排序。NAL 单元流中NAL 单元的解码顺序（和内容）是受约束的。字节流可以用NAL 单元流构造，...
Java IO：字节流与字符流解析
除了基本的读写操作，Java还提供了转换流（`InputStreamReader`和`OutputStreamWriter`）来在字节流和字符流之间进行转换，这样可以在处理文本数据时，结合字节流的高效性与字符流的便捷性。 理解Java IO中的字符流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值