I/O框架、对象序列化

最新推荐文章于 2023-09-06 09:22:14 发布
最新推荐文章于 2023-09-06 09:22:14 发布
阅读量166 收藏
点赞数
分类专栏： 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"));
		
	}
}
放气
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot中如何使用RedisTemplate存储实体对象
z1094219402的专栏
08-02 1万+
RedisTemplate是spring封装的操作redis的接口，使用起来很方便，但也有很多坑，比如存储javabean类。 网上找了很多资料，很多都语焉不详，几乎毫无作用。 redis存储对象需要对实体类进行序列化，也就是写成javabean，而不是pojo类。 其次，在存储对象的操作中，需要对实体类进行流化读写操作，就像文件的字节流的序列化操作一样，因为序列化本身就是流的转化的过程。而...
RedisTemplate存取数据
qq_46940224的博客
12-19 1409
RedisTemplate存取数据
Redis 存,取
y18735657013的博客
05-08 394
缺点，序列化和反序列化会消耗时间，如果修改，在并发下可能会有问题，因为是对整个对象进行的，可能覆盖前一次操作。3.使用hash存储，key依旧是需要查询的唯一性字段，value是一个Map，这个Map的key是成员的属性名，value是属性值，这样对数据的修改和存取都可以直接通过其内部Map的Key。2.key->表名_主键值_列名 value->列的值，这种方式是每一列数据都采用key-value这种方式，这种方式避免了上面的问题，由于key的重复存储，消耗的内存非常可观。2、redis连接配置。
redis数据操作封装（RedisTemplate）可存取对象
qq_39897814的博客
02-11 4541
以下是redis数据的操作封装 大概为（redsi对数据的增删查）几乎封装的大部分的方法 只有一小部分的方法没有写进来 序列化方法SerializeUtil请去这里拿（https://mp.csdn.net/postedit/88244655） package com.graduation.common; import java.util.Collection; import java.u...
video或audio标签加载本地资源不能播放问题
6块腹肌的博客
09-24 5990
因为安全性的问题，js是没有权限直接访问本地资源的，所以直接将资源的相对路径或者绝对路径给src都不能播放视频音频。可以使用URL.createObjectURL来进行处理，如下vue实例： <input type="file" @change="upload"> <video controls :src="mp4URL"></video> <scr...
从Thrift服务框架思考服务器框架-真的很有收获
01-08
TProtocol：这个就是协议模块，因为对Message的传输需要统一，否则就乱了，也就是对Message进行序列化的模块，常见协议入json、xml等。 TServer：这个模块主要负责TClient的请求，然后将请求转发给Processor处理，...
Java的学习之路，学习JavaEE以及框架时候的一些项目，结合博客和源码，让你受益匪浅，适合Java初学者和刚入门开始学框架者
最新发布
05-16
- **输入输出（I/O）**：文件读写、序列化、NIO（New I/O）。 推荐资源： - **书籍**：《Java编程思想》 (Thinking in Java) by Bruce Eckel - **在线教程**：Codecademy的Java课程，Java 官方教程
免费开源！！有用的 Java 框架、库、软件和 hello worlds 示例的列表
11-08
序列化和 I/O 记录 Bean 映射和验证 7. 图像和视频 8. 代码生成和改变字节码 9. 分布式应用程序 10. 科学 11.OSGI 二. 数据库、搜索引擎、大数据和机器学习 1. 数据库和存储 ——分布式数据库 2. 数据结构 3、搜索...
精通C# 5.0和.NET 4.5框架应用开发 英文版
09-27
工作与I / O服务和对象序列化21。第一部分：ADO.NET连接层22。ADO.NET第二部分：断开层23。第三部分：ADO.NET实体框架24。LINQ到XML 25。Windows通信基础26。Windows Workflow Foundation的27。介绍WPF和XAML 28。...
PL/SQL Developer8.04官网程序_keygen_汉化
12-15
该统计信息包括CPU使用情况、块I/O、记录I/O、表格扫描、分类等。 HTML指南 　Oracle目前支持HTML格式的在线指南。您可以将其集成到PL/SQL Developer工作环境中，以便在编辑、编译出错或运行时出错时提供内容敏感...
Vue使用audio标签动态绑定路径无效
CZT704265085的博客
04-19 1298
问题 // 没啥东西，src就是prop属性，值是"/resource/Audio.G711U.wav?ran=" + Math.random()，此处加一个ran是为了更新音频文件后前端可以及时重新加载 <audio :src="src" controls preload="auto"> </audio> 然而发现前端没有效果，看图看上去是没有加载成功，但是控制台也没报错 调试 我们在标签里加上ref属性，然后在vue钩子函数mounted中把他的src打出来看看 <au
redis获取Map对象
qq_40001822的博客
02-07 770
redis获取Map对象
Springboot-Redis - 5.通过 RedisTemplate 处理对象
yueerba126的博客
09-06 629
这些操作提供了一种绑定到特定 key 的方法，使得操作更为简洁。例如，对于绑定操作，你不需要为每个操作提供 key，因为 key 已经预先绑定。这些“绑定操作”提供了一种直接方式在特定 key 上执行操作，使代码更简洁，因为不需要为每个操作提供 key 参数。
VUE，vue-cli项目结构，以及在vue-cli脚手架原始项目框架引入模块
NI_computer的博客
10-12 266
一、项目结构： 初始化一个vue-cli之后，我们可以在目录中看到以下结构。 app.vue src下的app.vue是项目的根组件，可以包含其他的子组件。在项目运行时进入的首页即为app.vue。子组件写在src文件夹下的components内。根组件和子组件组成组件树。 main.js mian.js是vue应用的入口文件，可以创建一个新的vue实例并挂载再根节点下。Vue插件也从这里引入。 二、添加引入新模块 1.在components文件夹下新建一个vue文件 模块内基本组件： templ
python 属性，变量，实例属性
qq_37002116的博客
10-10 493
1，访问一个对象的属性时，先从对象的命名空间寻找。如果找到了这个属性，就返回这个属性的值；如果没有找到的话，则从类的命名空间中寻找，找到了就返回这个属性的值，找不到则抛出异常。 2，Python是动态语言，根据类创建的实例可以任意绑定属性通过实例变量，或者通过self变量实例属性就是绑定在 self 上的属性。对象属性是指定义在方法的内部的属性 3，类变量是类的一个属性，而不是一个对象的属性。 类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归类所有。类属性是指定义在类的内部而且
redis redistemplate序列化对象配置
qq_35568099的博客
10-29 2161
  @Configuration public class RedisConfig { /** * 重写Redis序列化方式，使用Json方式: * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisS...
Maven中Spring-Data-Redis存储对象(redisTemplate)
常敲代码手不生
04-22 2901
Redis是一种nosql数据库，在开发中常用做缓存。Jedis是Redis在Java中的redis- client.在此之前，希望已经了解redis的基本使用和Maven的使用。建立Maven Project之后，在POM.xml中添加jedis和spring-data-redis的依赖如下： redis.clients jedis 2.0.0
RediesUntil
weixin_44822477的博客
10-21 219
RedisUntil 借鉴他人整理 依赖 <!-- 整合redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</ar...
对象序列化是指将一个Java对象转换成一个I/O流中的字节序列的过程
05-30
是的，对象序列化是指将一个Java对象转换成一个I/O流中的字节序列的过程。 在Java中，对象序列化可以通过实现Serializable接口实现。当一个类实现了Serializable接口后，就可以将该类的对象序列化为一个字节序列，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值