I/O框架、对象序列化

最新推荐文章于 2023-12-19 09:58:24 发布
最新推荐文章于 2023-12-19 09:58:24 发布
阅读量198 收藏
点赞数
分类专栏： Java 相关 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu1shi/article/details/110498399
版权

在这里插入图片描述

  I/O 流结构。

在这里插入图片描述

在这里插入图片描述

  InputStream、OutputStream，字节流。
  FileInputStream 字节节点输入流。

// 字节读取
public class Test1 {

	public static void main(String[] args) throws IOException {
		//声明流对象
		InputStream is=null;
		try {
			//1.创建流对象,文件不存在会运行失败
			is=new FileInputStream("a1.txt");
			//2.用流对象读取文件中内容,一个字节一个字节读取,返回的是读取内容ascii码
			//先读取一次
			int content=is.read();
			while (content!=-1) {
				//将读取的字节转换为char类型内容再输出
				System.out.print((char)content);
				//接着读
				content=is.read();
			}
			System.out.println("\n读取完毕");
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (is!=null) {
				is.close();
			}
		}
	}
}

// 采用字节数组，一次读取多个字节
public class Test2 {

	public static void main(String[] args) throws IOException {
		//声明流对象
		InputStream is=null;
		try {
			//1.创建流对象
			is=new FileInputStream("a1.txt");
			//2.用流对象读取文件中内容,一个数组一个数组的读取,读取的内容存在数组中,返回的是读取内容长度
			//准备一个数组
			byte[] b=new byte[10];
			//先读取一次
			int len=is.read(b);
			while (len!=-1) {
				//将读取的字节数组内容转换为String,再输出
				String s1=new String(b, 0, len);
				System.out.println(s1);
				//接着读
				len=is.read(b);
			}
			System.out.println("\n读取完毕");
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (is!=null) {
				is.close();
			}
		}
	}
}

  用字节节点流实现拷贝文件功能。


public class Test {

	public static void main(String[] args) throws IOException {
		//声明流对象
		InputStream is=null;
		OutputStream os=null;
		try {
			//1.创建流对象,拷贝后的文件与原文件类型相同(后缀名一样)
			is=new FileInputStream("a1.jpg");
			os=new FileOutputStream("a2.jpg");

			//准备一个数组
			byte[] b=new byte[10];
			//先读取一次
			int len=is.read(b);
			while (len!=-1) {
				//每读取一次就写入一次
				os.write(b, 0, len);
				//接着读取
				len=is.read(b);
			}
			System.out.println("拷贝成功!");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (is!=null) {
				is.close();
			}
			if (os!=null) {
				os.close();
			}
		}
	}
}

  BufferedOutputStream、BufferedInputStream，字节过滤流。提高I/O效率，减少访问磁盘的次数；数据存储在缓冲区中，flush() 是将缓存区的内容写入文件中，也可以直接close()。


// 字节过滤输出流的使用
public class BufferedOutputStreamTest {

	public static void main(String[] args) throws IOException {
		//声明流对象
		BufferedOutputStream bos=null;
		try {
			//1.创建流对象
			bos=new BufferedOutputStream(new FileOutputStream("b1.txt",true));
			//2.用流对象向文件中写入内容,按一个数组来写入
			bos.write("dfefefefefef".getBytes());
			System.out.println("写入成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (bos!=null) {
				bos.close();
			}
		}
	}
}

// 字节过滤输入流的使用
public class Test {

	public static void main(String[] args) throws IOException {
		//声明流对象
		BufferedInputStream bis=null;
		try {
			//1.创建流对象
			bis=new BufferedInputStream(new FileInputStream("b1.txt"));
			//2.用流对象读取文件中内容,按一个数组来读取
			//准备一个数组
			byte[] b=new byte[10];
			//声明一个变量存每次读取的长度
			int len;
			while ((len=bis.read(b))!=-1) {
				//将读取的内容转换为String并输出
				System.out.println(new String(b, 0, len));
			}
			
			System.out.println("读取成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (bis!=null) {
				bis.close();
			}
		}
	}
}

  Reader、Writer，字符流。
  FileReader、FileWriter，字符节点流。


public class Test {

	public static void main(String[] args) throws IOException {
		//声明流对象
		FileReader r=null;
		FileWriter w=null;
		try {
			//1.创建流对象
			r=new FileReader("a1.txt");
			w=new FileWriter("b1.txt");
			//2.边读取边拷贝,按字符数组拷贝
			char[] c=new char[100];
			//声明一个变量存读取内容长度
			int len;
			while ((len=r.read(c))!=-1) {
				//每读取一次就写入一次
				w.write(c, 0, len);
			}
			System.out.println("拷贝成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (r!=null) {
				r.close();
			}
			if (w!=null) {
				w.close();
			}
		}
	}
}

  InputStreamReader、OutputStreamWriter，桥转换流。可将字节流转换为字符流。可设置字符的编码方式。

public class Test {

	public static void main(String[] args) throws IOException {
		//声明流对象
		InputStreamReader r=null;
		OutputStreamWriter w=null;
		try {
			//1.创建流对象
			r=new InputStreamReader(new FileInputStream("a1.txt"), "utf-8");
			w=new OutputStreamWriter(new FileOutputStream("b2.txt"), "utf-8");
			//2.边读取边拷贝,按字符数组拷贝
			char[] c=new char[100];
			//声明一个变量存读取内容长度
			int len;
			while ((len=r.read(c))!=-1) {
				//每读取一次就写入一次
				w.write(c, 0, len);
			}
			System.out.println("拷贝成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (r!=null) {
				r.close();
			}
			if (w!=null) {
				w.close();
			}
		}
	}
}

  BufferedWriter、BufferedReader，字符缓冲流。支持输入换行符。可一次写一行、读一行。

public class Test {

	public static void main(String[] args) throws IOException {
		//声明流对象
		BufferedReader r=null;
		BufferedWriter w=null;
		try {
			//1.创建流对象
			r=new BufferedReader(new InputStreamReader(new FileInputStream("a1.txt"), "utf-8"));
			w=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a2.txt"), "utf-8"));
			
			//2.边读取边写入,一行一行的读取
			//声明一个变量存每次读取内容
			String s1;
			while ((s1=r.readLine())!=null) {
				//每读取一次就写入一次
				w.write(s1);
				//每写入一次就换
				w.newLine();
				//刷新
				w.flush();
			}
			
			System.out.println("拷贝成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (r!=null) {
				r.close();
			}
			if (w!=null) {
				w.close();
			}
		}
	}

}

  PrintStream/PrintWriter，字节打印流/字符打印流。封装了 print() 、 println() 方法，支持写入后换行。支持数据原样打印

public class PrintStreamTest1 {

	public static void main(String[] args) {
		//声明流对象
		// PrintWriter ps=null;
		PrintStream ps=null;
		try {
			//1.创建流对象
			// ps=new PrintWriter("aa.txt");
			ps=new PrintStream("aa.txt");
			//2.用流对象调用方法向文件中写入内容 
			ps.write("Hellow".getBytes());
			ps.append("World");
			ps.println("java");
			ps.printf("%.2f", 3.343434545454);
			ps.print("html");
			System.out.println("写入成功!");
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (ps!=null) {
				ps.close();
			}
		}
	}
}

  setIn、setOut，重定向。


public class Test {

	public static void main(String[] args) throws FileNotFoundException {
		//输入重定向，输入的字符被文件接收
		System.setIn(new FileInputStream("bb.txt"));
		
		Scanner input=new Scanner(System.in);
		System.out.println("请输入一个字符串:");
		String s1=input.next();
		String s2=input.next();
		System.out.println("接收的字符串为:"+s1);
		System.out.println("接收的字符串为:"+s2);
	}
}

public class Test {

	public static void main(String[] args) throws FileNotFoundException {
		//输出重定向，输出的字符被文件接收
		System.setOut(new PrintStream("bb.txt"));
		
		System.out.println("想要月薪过万");
		System.out.println("键盘敲烂");
	}

}

  ObjectOutputStream、ObjectInputStream，对象流，属于字节过滤流。增强了缓冲区功能，增强了读写8种基本数据类型和字符串功能，增强了读写对象的功能。
  使用流传输对象的过程称为序列化、反序列化。
  对象序列化，必须实现 Serializable 接口；必须保证其所有属性均可序列化；transient 修饰为临时属性，不参与序列化；读取到文件尾部的标志，java.io.EOFException。

  声明序列化类，必须实现 Serializable 接口。如果序列化后还会更改类的属性，要固定序列化版本号。如果序列化类中某个属性不想被序列化可以用 static 或 transient 修饰。

public class Student implements Serializable {

	// 固定序列化版本号
	private static final long serialVersionUID = 9182661412185050266L;
	
	private String sname;
	//如果序列化类中某个属性不想被序列化可以用static或transient修饰
	private transient int sage;
	
	@Override
	public String toString() {
		return "Student [sname=" + sname + ", sage=" + sage + "]";
	}
	
	public Student() {
		
	}
	
	public Student(String sname, int sage) {
		super();
		this.sname = sname;
		this.sage = sage;
	}

	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getSage() {
		return sage;
	}
	public void setSage(int sage) {
		this.sage = sage;
	}
	
}

  向流中写入序列化对象。


public class Test1 {

	public static void main(String[] args) throws IOException {
		//声明流对象
		ObjectOutputStream oos=null;
		
		try {
			//1.创建流对象
			oos=new ObjectOutputStream(new FileOutputStream("cc.txt"));
			//2.用流向文件中写入对象
			//第一种:写入一个普通对象
//			String s1="饿了吗?";
//			oos.writeObject(s1);
			
			//第二种:写入一个自定义对象
			oos.writeObject(new Student("kk", 6));
			
			//第三种:将多个对象存入到集合中,再将集合写入到时文件中
			List<Student> stuList=new ArrayList();
			stuList.add(new Student("kk1", 18));
			stuList.add(new Student("kk2", 28));
			stuList.add(new Student("kk3", 38));
			stuList.add(new Student("kk4", 48));
			
			oos.writeObject(stuList);

			System.out.println("写入成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (oos!=null) {
				oos.close();
			}
		}
	}
}

  读取序列化对象。读写使用的方法类型应一致。


public class Test2 {

	public static void main(String[] args) throws IOException {
		//声明流对象
		ObjectInputStream ois=null;
		
		try {
			//1.创建流对象
			ois=new ObjectInputStream(new FileInputStream("cc.txt"));
			//2.用流读取文件中对象
			//第一种:读取一个普通对象
//			String s1=(String) ois.readObject();
//			System.out.println("读取的内容为:"+s1);
			
			//第二种:读取一个自定义对象
			Student stu=(Student) ois.readObject();
			System.out.println(stu);
			
			//第三种:读取集合
			List<Student> stuList=(List<Student>) ois.readObject();
			for (Student s : stuList) {
				System.out.println(s);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (ois!=null) {
				ois.close();
			}
		}

	}
}

  Properties 读取配置文件。


// 文件名后缀必须为 properties，健=值
// .class.getClassLoader() 方法直接从当前 bin 目录中取文件，方便其它位置调用

public class PropertiesTest {

	public static void main(String[] args) throws IOException {
		//创建Properties对象
		Properties p=new Properties();
		//读取配置文件
		p.load(PropertiesTest.class.getClassLoader().getResourceAsStream("jdbc.properties"));
		
		//获取配置文件中信息
		System.out.println("url:" + p.getProperty("url"));
		
	}
}
放气
关注
专栏目录
QingStor 对象存储架构设计及最佳实践
青云QingCloud
06-09 1063
对象存储概念及特性 在介绍 QingStor®️对象存储内部的的架构和设计原理之前，我们首先来了解一下对象存储的概念，也就是从外部视角看，对象存储有什么特性，我们应该如何使用。 对象存储本质上是一款存储产品，与其他的存储，如文件存储、块存储，功能是类似的，主要的功能都是数据的读和写。最大的不同在于对象存储是把数据作为对象进行管理，这是它最主要的特征，所有的数据在这里面都当做一个对象处理。 对象存储有一些非常鲜明的特点： 它的结构是扁平的，不像文件存储那样有目录层级，在读写数据时不需要对目录进行层层查找和打
redistemplate存对象_StringRedisTemplate与RedisTemplate
weixin_36331580的博客
01-23 4060
字节跳动就是我心中的耶路撒冷！首先我们先来谈谈它们两者之间的关系：两者的关系是StringRedisTemplate继承RedisTemplate。两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。其实他们两者之间的区别主要在于他们使用的序列化...
spring boot下使用RedisTemplate操作redis存取对象
热门推荐
混合动力火锅的博客
08-25 4万+
在spring boot环境下有个StringRedisTemplate对象，默认已经为我们配置好了，只需要自动注入过来就能用，但是使用它只能在Redis中存放字符串。具体操作如下： @RunWith(SpringRunner.class) @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) @...
redis数据操作封装（RedisTemplate）可存取对象
qq_39897814的博客
02-11 4669
以下是redis数据的操作封装 大概为（redsi对数据的增删查）几乎封装的大部分的方法 只有一小部分的方法没有写进来 序列化方法SerializeUtil请去这里拿（https://mp.csdn.net/postedit/88244655） package com.graduation.common; import java.util.Collection; import java.u...
RedisTemplate存取数据
最新发布
qq_46940224的博客
12-19 1726
RedisTemplate存取数据
Visual C++中对象的序列化与文件I/O研究
07-26
对象序列化的目的是保存和加载对象的状态数据，使得程序能够在终止后再恢复到之前的状态。这一过程在MFC（Microsoft Foundation Classes）框架中，特别是与C++结合使用时显得尤为重要。由于MFC中的绝大多数类是继承...
【Java】Java的I/O框架
yao_yaoya的博客
11-30 1261
IO流的概念：内存与存储设备之间传输数据的通道。数据借助流传输。
Java I/O流常用类小结
12-22
ObjectInputStream和ObjectOutputStream：这是处理对象序列化的流，可以将Java对象写入到流中，或者从流中恢复对象。这对于持久化对象和网络通信非常有用。 FileReader和FileWriter的局限性在于它们都是单线程的，...
深入分析 Java I/O 的工作机制(转载)
04-03
6. **对象序列化与反序列化** Java提供了Serializable接口，使得对象可以被序列化成字节流，便于存储或通过网络传输。ObjectInputStream和ObjectOutputStream负责对象的序列化和反序列化操作。 7. **NIO（非阻塞I/...
I/O框架（练习题）
Null_Kun
03-17 2436
Key Point： File类 流的分类 基本字节流 字节过滤流 基本字符流、桥转换 字符过滤流 对象序列化 问题： （File类）以下关于File类说法正确的是： A.一个File对象代表了操作系统中的一个文件或者文件夹 B.可以使用File对象创建和删除一个文件 C.可以使用File对象创建和删除一个文件夹 D.当一个File对象被垃圾回收时，系统上对应的文件或文件夹也被删除 ABD...
RedisTemplate-JDBCTemplate.zip
07-18
spring 封装了 RedisTemplate,JdbcTemplate 对象来进行对redis,jdbc的各种操作进行简化
audio 标签动态src 且src是http无法播放问题
weixin_43907110的博客
10-30 1426
注意如果，src跟本项目地址IP端口协议不同，会出现跨域问题。audio标签本身是允许跨域的资源的，但是如果src资源本身所在服务不允许跨域就会出现，直接访问文件地址能够播放，但是放到audio里面就无法播放的问题，这个有两个解决方法。无法播放因为动态src需要在赋值后对audio进行重载。不在audio里面去播放跨域的音频。直接用a标签连接打开新的浏览器页签。让资源服务器允许跨域。
redistemplate存对象取对象_Java高级架构师-JAVA基础之ServletContext对象
weixin_39855568的博客
12-08 637
欢迎关注头条号：Java小野猫个人理解： ServletContext类似字节码文件对象，在web创建的时候就自动生成了，并且是唯一的，跟随着项目和服务器共存亡了。通过这个对象，我们可以向里面存数据(键值对),也可以通过别的Servlet来获取这个数据；也可以根据相对(服务器)路径继来获取绝对路径。根据这个信息我们可以在以后创建文件的过程中，将静态资源的文件尽量创建在web-content文件夹下...
redis 保存对象（redisTemplate ）
小样
03-31 6544
原文：https://blog.csdn.net/qq_31024823/article/details/81233752 java 用redisTemplate 的 Operations存取list集合 一 、存取为list类型 @RestController @RequestMapping("/test") @Slf4j public class TestController { ...
VUE动态绑定audio/video/img的src不能播放或显示
weixin_33884611的博客
09-04 2800
2019独角兽企业重金招聘Python工程师标准>>> ...
Redis之通过RedisTemplate对象访问Redis
zifan_的博客
03-04 358
Redis之通过RedisTemplate对象访问Redis spring框架中 首先导入依赖 <!--jedis依赖--> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis<...
audio标签src引入文件无效_Django静态文件相关
weixin_33352628的博客
01-15 324
Ⅰ 原始引入方式<link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">如果setting.py的STATIC_URL = '/static/'路径被改变,那么就无法继续引入了但是STATIC_URL = '/static/'的路径一般不会动它Ⅱ 第二种引方式 {% load static ...
audio src 属性 用法 以及 不能自动播放,Uncaught (in promise) DOMException: play() failed because the us
qq_42112846的博客
04-01 6438
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_42112846 最近做项目，要求再网页上取循环得播放背景音乐，最后嵌入到安卓，查阅了之后最后咏鹅audio这个属性，下面我们用来看一下它的使用方法以及说一下它的对于 谷歌以及ios等得局限性： 首先我们来看一下它的用法： 官网 给出得demo 是： <audio src="son...
html5 audio标签 src 赋空值产生错误
liubangbo的专栏
05-01 2620
在业务中用audio标签播放完一首歌曲后，自动播放下一首。 想着播放完在产生onended事件后做一些清理工作然后播放下一首： audio.src = ""; 但这样会产生onerror事件。 var audio = new Audio(); document.body.appendChild(audio); if (audio != null){ audio.src =...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值