字符流，缓冲字符流(各种复制文件，文件夹)，集合与文件，序列化与反序列化

最新推荐文章于 2021-03-16 22:42:03 发布
原创 最新推荐文章于 2021-03-16 22:42:03 发布 · 460 阅读 · 0 ·
CC 4.0 BY-SA版权
博主原创，转发请私信。

本文深入讲解Java中的IO流操作，包括字节流、字符流及其缓冲机制，演示如何使用缓冲流进行高效的数据读写，同时介绍了字符流的使用方法及序列化与反序列化的实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

缓冲字节流的数据读写过程

读数据是从缓冲区中读取数据

文件→缓冲区→自定义容器

写出的数据是放在缓冲区里面，如果需要将数据刷新到硬盘上面去，需要调用flush方法。(否则只有当缓冲区填满的时候才会将数据写写出来)

public class Demo {
	public static void main(String[] args) {
		BufferedInputStream bis=null;
		BufferedOutputStream bos=null;
		try {
			FileInputStream fis= new FileInputStream("/Users/yoofale/Desktop/haha.txt");
			bis = new BufferedInputStream(fis);
			FileOutputStream fos= new FileOutputStream("/Users/yoofale/Desktop/666.txt");
			bos = new BufferedOutputStream(fos);
			byte[] buf=new byte[1024];
			int len=-1;
			while((len=bis.read(buf))!=-1){
				bos.write(buf,0,len);
//				写一次数据就刷新一次数据
				bos.flush();
			}
			System.out.println("拷贝成功");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(bos!=null){
				try {
					bos.close();//close内部会自动调用flush方法
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(bis!=null){
				try {
					bis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
}

依旧是复制文件标准套路，拷贝文件夹要用递归。

 

 

 

字符流：因为使用字节流操作文本数据比较麻烦，所以出现了字符流

字符流=字节流+编码表

编码表：就是一张可以表示文字的码表。

 

转换流：

OutputStreamWriter 字符流通向字节流的桥梁

InputStreamReader 字节流通向字符流的桥梁

 

字符流写出

	public static void main(String[] args) throws Exception {
		FileOutputStream fos = new FileOutputStream("/Users/yoofale/Desktop/haha.txt");
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		osw.write("大吉大利，今晚吃鸡");
		osw.flush();
		osw.close();
	}

 

 

 

字符流读取

public static void main(String[] args) throws Exception {
public InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
		FileInputStream fis = new FileInputStream("/Users/yoofale/Desktop/haha.txt");
//		public InputStreamReader(InputStream in,String charsetName)创建使用指定字符集的InputStreamReader
		InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
//		public int read(char[] cbuf)将字符读入数组，读取的字符数，如果已经到达流的末尾，返回-1
//		定义一个变量用于统计读取的字符的个数
		char[] cbuf=new char[1024];
		int len =isr.read(cbuf);
//		将字符数组转换成字符串
		String content = new String(cbuf,0,len);
		System.out.println(content);
	}

模式等同于字节流。读取后放入缓冲区，进行计数，多了一步将字符数组转化成字符串的过程

 

 

 

转换流的简化写法

FileWriter是OutputStreamWriter的简化写法，FileWriter的编码方式就是默认的平台编码(写入字符文件的便捷类)

FileReader是InputStreamReader的简化写法，FileReader的编码方式也是默认的平台编码

 

简化的写入

public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		FileWriter fw =new FileWriter("/Users/yoofale/Desktop/mm.txt");
		fw.write("简化版成功写入");
		fw.flush();
		fw.close();
	}

简化的读取

public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		FileReader fr = new FileReader("/Users/yoofale/Desktop/mm.txt");
		char[] brr=new char[1024];
		int len =fr.read(brr);
		System.out.println(new String(brr, 0, len));
			
	}

写入结束一定要刷新，关闭流。

读取一定要用缓冲区，定义变量。

 

简化版的复制文件

public class CopyTestQuickly {

	private static FileReader fr;

	public static void main(String[] args) throws Exception {
		fr = new FileReader("/Users/yoofale/Desktop/haha.txt");
		FileWriter fw = new FileWriter("/Users/yoofale/Desktop/hehe.txt");
		char[] ass =new char[1024];
		int len =-1;
		while((len=fr.read(ass))!=-1){
			fw.write(ass,0,len);
		}
		fw.close();
		fr.close();
		System.out.println("拷贝成功");
	}

}

 

 

 

缓冲字符流

写入数据

public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		FileWriter fw = new FileWriter("/Users/yoofale/Desktop/haha.txt");
		BufferedWriter bw = new BufferedWriter(fw);
		bw.write("西瓜皮");
		bw.append("6");//append是在后面写入
		bw.newLine();//nextLine()是换行
		bw.write("不知细叶谁裁出，二月春风似剪刀");
		bw.flush();
		bw.close();
	}

newLine换行

 

读取数据

public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		FileReader fr = new FileReader("/Users/yoofale/Desktop/haha.txt");
		BufferedReader br = new BufferedReader(fr);
		String line = br.readLine();
		System.out.println(line);
		line = br.readLine();
//		readLine()是读取一个文本行，没有数据了返回null
		System.out.println(line);
		line = br.readLine();
		System.out.println(line);
	}

 

 

关于使用缓冲拷贝和普通拷贝时间的区别，先System.currentTimeMillis()，再分别调用封装的拷贝文件类，再接收时间，求差值。比较差值即可比较出效率。

 

 

复制文本文件

使用缓冲区写出数据时，如果中途不着急将一部分数据刷新出去，就等到最后关闭流的时候顺带将数据刷出去   

如果缓冲区存满了，那么里面的数据都会强制刷新出去。

 

普通读取都是一次一个字符数组，很慢。写入可以一次一行。效率过低

缓冲字符流读取写入都很快，一次一行。！！！！！！！！！！！！切记newline换行

 

 

字符流缓冲最后都简化为BufferedReader BufferedWriter

字节流都是BufferedInputStream     BufferedOutputStream

 

将集合中的内容保存到文件中

public class ArrayListToFile {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		ArrayList<String> list = new ArrayList<String>();
		list.add("我");
		list.add("是");
		list.add("我");
		BufferedWriter bw = new BufferedWriter(new FileWriter("/Users/yoofale/Desktop/haha.txt"));
		for (String content : list) {
			bw.write(content);
			bw.newLine();
		}
		bw.close();
		System.out.println("写出成功");
	}

}

 

 

 

将文件中的内容写入集合中

public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new FileReader("/Users/yoofale/Desktop/haha.txt"));
		ArrayList<String> list = new ArrayList<String>();
		String line=null;
		while((line=br.readLine())!=null){
			list.add(line);
		}
		br.close();
		for (String content : list) {
			System.out.println(content);
		}
	}

 

拷贝单级文件

public class CopyFolderDemo {

	public static void main(String[] args) {
//		1.封装原文件夹的文件对象
		File srcFolder = new File("/Users/yoofale/Desktop/666");
//		2.封装要拷贝到的文件夹对象
		File destFolder = new File("/Users/yoofale/Desktop/777");
//		3.在目标位置创建一个一模一样的文件夹
		destFolder =new File(destFolder,srcFolder.getName());
		destFolder.mkdir();
//		4.获取原文件夹中所有的子文件对象
		File[] files = srcFolder.listFiles();
//		5.遍历所有的子文件对象数组，然后拷贝到目标文件夹中
		for (File srcFile : files) {
//			在目标文件夹里面创建一个名字一模一样的文件
			File destFile = new File(destFolder,srcFile.getName());
//			调用拷贝文件的方法
			copyFile(srcFile,destFile);
		}
		System.out.println("拷贝成功");
	}

	private static void copyFile(File srcFile, File destFile) {
		try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
				BufferedOutputStream bos =new BufferedOutputStream(new FileOutputStream(destFile))){
			byte[] buf= new byte[1024];
			int len =-1;
			while((len=bis.read(buf))!=-1){
				bos.write(buf,0,len);
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

 

 

 

 

java序列化：把Java对象转换成字节序列的过程

Java反序列化：把字节序列恢复为Java对象的过程

当两个java进程进行通信的时候，发送方需要进行java序列化，接收方需要进行java反序列化

 

序列化

// 被序列化的对象必须实现Serializable接口，否则运行错误
	public static void main(String[] args) throws Exception {
		// public objectOutputStream(OutputStream
		// out)创建写入指定OutputStream的ObjectOutputStream
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("/Users/yoofale/Desktop/person.txt"));
		// 将对象写出到文件中
		// public final void writeobject(Object obj)将指定对象写入ObjectOutputStream
		oos.writeObject(new Person("张三", 17));
		oos.close();
	}

要序列化的类一定要实现Serializable接口

一个成员如果被transient修饰，那么这个对象不能序列化保存。

 

反序列化

private static void fileToObject() throws Exception {
		// TODO Auto-generated method stub
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("/Users/yoofale/Desktop/person.txt"));
		Object obj = ois.readObject();
		System.out.println(obj);
	}

 

YooFale
关注
Java中的序列化与反序列化
yuiezt的专栏
07-15 3912
序列化（Serialization）与反序列化（Deserialization）是编程中常见的两个概念，它们主要涉及到将数据结构或对象状态转换为可以存储或传输的格式，以及将存储或传输的格式转换回原始的数据结构或对象状态的过程。这两个过程在数据持久化、网络通信、对象深拷贝等多个场景中发挥着重要作用。
day21_缓冲流、转换流、序列化流、Commons IO.pdf
11-02
缓冲流分为字节缓冲流和字符缓冲流两大类，分别是`BufferedInputStream`和`BufferedOutputStream`（处理字节流）以及`BufferedReader`和`BufferedWriter`（处理字符流）。缓冲流的主要作用在于减少对系统I/O操作的...
Java 字符流缓冲复制文件
fly
03-16 289
package FileDemo.StringDemo; import java.io.*; /** * 字符流缓冲 */ public class BuffDemo { public static void main(String[] args) throws IOException { String a = "stu\\src\\FileDemo\\StringDemo\\11.txt"; // BufferedWriter bw = new Buffe.
字符缓冲流复制文件
Ting1king的博客
03-22 379
//封装数据 BufferedReader br=new BufferedReader(new FileReader("a.txt")); BufferedWriter bw=new BufferedWriter(new FileWriter("e.txt")); // //方式1 // int len; // while((len=br.read())!=-1){ // ...
Java基础小知识1——分别使用字节流和字符流复制文件
考研数学笔记、高等数学笔记、线性代数笔记、计算机专业课资源
06-08 1129
在日常使用计算机过程中经常会涉及文件的复制，今天我们就从Java代码的角度，看看在Java程序中文件复制的过程是如何实现的。 1.使用字节流缓冲区复制文件 示例代码如下： import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; public ...
缓冲流---为字节流和字符流复制文件增加缓冲流
shimeath_rafael的博客
01-28 178
缓冲流继承自节点流
【JAVA复制文件】【字节流】&【字符流】&【缓冲字节流】&【缓冲字符流】
黑桃
05-21 256
文件字节流（这个应该好用点）： 代码 package ht; import java.io.FileInputStream; import java.io.FileOutputStream; public class F { public static void main(String[] args) { new F().copy("C:/Users/ACER/Desktop/计算机组成原理 指令缩写.png", "C:/Users/ACER/Desktop/NEW计算机组成原理 指令缩写.pn
XmlDemoTranfer Xml序列化与反序列化
05-24
Xml序列化与反序列化是.NET框架中一种重要的数据转换技术，主要应用于将对象的状态转换成XML格式的字符串，便于存储或传输，同时也能够将XML数据还原为对象。在C#编程中，这一功能通常通过System.Xml.Serialization...
IO流与序列化
05-09
通过学习IO流与序列化，开发者能够更好地理解Java中数据的读写和对象状态的保存，这对于开发涉及文件操作、网络通信和持久化存储的程序至关重要。同时，熟悉这些技术也有助于提升代码的可维护性和性能。
Kryo序列化及反序列化用法示例
08-29
最后，我们使用Assert.assertEquals方法来检查反序列化后的对象是否与原始对象相同。 Kryo序列化的主要步骤包括： 1. 创建Kryo对象 2. 使用Output对象将对象序列化为字节流 3. 使用Base64将字节流编码为字符串 4. ...
字符流 集合到文件，文件到集合
august197210的博客
08-28 252
package com.io.liushuaishuai; /* 把ArrayList集合中的字符串数据写入到文本文件。 要求：每一个字符串作为文件中的一行数据 */ import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; im...
文件复制、对象可序列化存储
yuzhiyun3536的专栏
09-06 746
eclipse中文件复制 public class CopyPaste { public static void main(String[] args) throws IOException { // 也可以直接写score.txt，都表示当前目录 InputStream is = new FileInputStream(new File("./score.tx
用读写操作复制文件，csv ，序列化和反序列化
xiao_liushui的博客
08-10 752
用读写操作复制文件 r :只能读 w； 只能写 覆盖整个文件 不存在则创建 a 只能写 从文件底部添加内容 不存在则创建 “rb” ： 以二进制读方式打开，只能读文件 ， 如果文件不存 在，会发生异常 “wb”： 以二进制写方式打开，只能写文件， 如果文件不存 在，创建该文件；如果文件已存在，先清空，再打开文件 file_path = r'C...
缓冲字符流复制文件
初学java
07-17 440
package ioTest; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /* * 字符缓冲输出流：BufferedWriter * 字符缓冲输...
java学习：IO流（缓冲流）实现文件拷贝、文件夹拷贝、文件读取与写出、关闭流（封装代码）
weixin_42924812的博客
03-26 1003
IO流实现文件的读取与写出，文件、文件夹的拷贝 附代码，IO流实现文件操作封装类。 （1）读取、写出文件，拷贝文件； （2）拷贝文件夹； （3）关闭流。 public class FileUtils { /** * 拷贝文件夹 * * @param srcPath * @param destPath */ public static void copyDir(Strin...
字符缓冲流之把集合中的数据写入到文件(2020.7.29)
qq_45469824的博客
07-29 327
有时候我们会把集合里面的数据写入文件里面 如下
字符缓冲流之把集合的数据写入文件中升级版 （2020.8.2）
qq_45469824的博客
08-02 173
Student类： main方法： text文件数据： 输出结果：
IO流的练习2 —— 复制单级文件夹中的文件
dielunyuan5091的博客
10-02 152
需求：把C:\Users\Administrator\Desktop\记录\测试里面的所有文件复制到 　　　　C:\Users\Administrator\Desktop\新建文件夹\copy文件夹中 分析： 　　　　A：封装目录 　　　　B：获取该目录下的所有文件的File数组 　　　　C：遍历该集合，得到每一个File对象 　　　　D：把每个File复制到目的...
字符缓冲流之把集合中的数据写到文件(升级版) 2020.8.1
qq_45469824的博客
08-01 179
要求：按照(学号，姓名，年龄，地址 ) 这种各种写入到学生信息表.txt文件,并且每一个学生对象的数据作为文件中的一行 Student类： main方法： 最终结果文件内的数据：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值