学习JavaEE的日子 Day37 各种流

这篇具有很好参考价值的文章主要介绍了学习JavaEE的日子 Day37 各种流。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

各种流

1.对象流

class ObjectInputStream – 对象输入流

class ObjectOutputStream – 对象输出流

理解:

​ 将程序中的对象写入到文件

​ 并且从文件中读取出对象到程序里

序列化(钝化):将程序里的对象写入到文件

反序列化(活化):将文件里的对象读取到程序中

注意:

  1. 如果对象想写入文件,对象所属的类就必须实现序列化接口(Serializable)
  2. Serializable序列化接口没有任何的属性和方法,这种接口称之为标记型接口
  3. 对象所属的类实现了序列化接口一定要添加序列化ID(serialVersionUID)
  4. 属性使用transient修饰,该属性不会随着对象而写入到文件中
1.1 利用对象输出流 向文件写入数据ObjectOutputStream
public class Test01 {
	public static void main(String[] args) throws FileNotFoundException, IOException {
		
		//1.创建流对象
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io.txt"));
		
		//2.写入数据
		oos.writeInt(100);//写入int值
		oos.writeDouble(123.123);//写入double值
		oos.writeUTF("用良心做教育");//写入字符串
		oos.writeObject(new Date());//写入对象
		
		//3.关闭资源
		oos.close();
	}
}
1.2 利用对象输入流 读取文件里的数据ObjectInputStream
public class Test02 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		
		//1.创建流对象
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io.txt"));
		
		//2.读取数据(读取顺序必须和写入顺序一致)
		int readInt = ois.readInt();
		double readDouble = ois.readDouble();
		String str = ois.readUTF();
		Date date = (Date) ois.readObject();
		
		System.out.println(readInt);
		System.out.println(readDouble);
		System.out.println(str);
		System.out.println(date);
		
		//3.关闭资源
		ois.close();
		
	}
}
1.3 利用对象输出流 向文件写入自定义对象ObjectOutputStream
public class Test03 {
	/**
	 * 知识点:利用对象输出流 向文件写入自定义对象
	 */
	public static void main(String[] args) throws FileNotFoundException, IOException {
		
		//1.创建流对象
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io.txt"));
		
		//2.写入自定义对象
		oos.writeObject(new User("1445584980", "123123"));
		oos.writeObject(new User("1534534534", "111222"));
		oos.writeObject(new User("5345356683", "123456"));
		oos.writeObject(null);
		
		//3.关闭资源
		oos.close();
		
	}
}

User类

public class User implements Serializable{//要实现序列化接口(Serializable)
	
	private static final long serialVersionUID = 4907921883130742331L;
	
	private String username;
	private transient String password;
	
    //无参构造,有参构造,get,set方法省略
1.4 利用对象输入流 读取文件中的自定义对象ObjectInputStream
public class Test04 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		
		//1.创建流对象
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io.txt"));
		
		//2.读取自定义对象
		User user;
		while((user = (User)ois.readObject()) != null){
			System.out.println(user);
		}
		
		//3.关闭资源
		ois.close();
	}
}

2.内存流

class ByteArrayInputStream – 内存输入流

class ByteArrayOutputStream – 内存输出流

注意:

  1. 内存流是程序和内存交互,跟文件无关
  2. 内存流是程序到内存的通道,是关闭不掉的

应用场景:项目中频繁使用的数据可以使用内存流备份一份

2.1 内存输出流ByteArrayOutputStream
public class Test01 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		
		//关闭资源(内存流是程序到内存的通道,是关闭不掉的)
		//baos.close();
		
		//2.写入数据 -- 将数据写入到baos对象中的byte数组里
		baos.write("123abc木头人".getBytes());
		
		//获取流对象里的数据
		System.out.println(new String(baos.toByteArray()));
		System.out.println(baos.toString());
	}
}
2.2 内存输入流ByteArrayInputStream
public class Test02 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		ByteArrayInputStream bais = new ByteArrayInputStream("123abc木头人".getBytes());
		
		//关闭资源(内存流是程序到内存的通道,是关闭不掉的)
		//bais.close();
		
		//2.读取数据
		byte[] bs = new byte[1024];
		int len;
		while((len = bais.read(bs)) != -1){
			System.out.println(new String(bs, 0,len));
		}		
		
	}
}

3.打印流

class PrintStream – 字节打印流

class PrintWriter – 字符打印流

注意:打印流实际上就是输出流,只有一个方向(程序->文件)

PrintStream vs PrintWriter

区别1:PrintStream是以字节为单位,PrintWriter是以字符为单位

区别2:

​ PrintStream:将字节流转换为字节打印流

​ PrintWriter:将字节流和字符流转换为字符打印流

3.1 字节打印流PrintStream
public class Test01 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		//PrintStream ps = new PrintStream("io.txt");
		
		//1.创建流对象(字节流 -> 字节打印流)
		//PrintStream ps = new PrintStream(new FileOutputStream("io.txt"));
		
		//1.创建流对象(字节流 -> 字节打印流) + 在末尾追加
		PrintStream ps = new PrintStream(new FileOutputStream("io.txt",true));
		
		//2.写入数据
		ps.write("好好学习".getBytes());
		
		//3.关闭资源
		ps.close();		
		
	}
}
3.2 字符打印流PrintWriter
public class Test02 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		//PrintWriter pw = new PrintWriter("io.txt");
		
		//1.创建流对象(字节流 -> 字节打印流)
		//PrintWriter pw = new PrintWriter(new FileOutputStream("io.txt"));
		
		//1.创建流对象(字节流 -> 字节打印流) + 在末尾追加
		//PrintWriter pw = new PrintWriter(new FileOutputStream("io.txt",true));
		
		//1.创建流对象(字符流 -> 字符打印流)
		//PrintWriter pw = new PrintWriter(new FileWriter("io.txt"));
		
		//1.创建流对象(字符流 -> 字符打印流) + 在末尾追加
		//PrintWriter pw = new PrintWriter(new FileWriter("io.txt",true));
		
		//1.创建流对象(设置编码格式 + 在末尾追加 + 考虑到效率)
		PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream("io.txt",true), "GBK")));
		
		//2.写入数据
		pw.write("好好学习");
		
		//3.关闭资源
		pw.close();		
		
	}
}

4.扩展:重定向

理解:重新定义系统标准的输入流、输出流、错误输出流的方向

System.in:获取系统标准输入流的方向(控制台->程序)
System.out:获取系统标准输出流的方向(程序->控制台)
System.err:获取系统标准错误输出流的方向(程序->控制台)

//重定向:重新定义系统标准输入流的方向(文件->程序)
System.setIn(new FileInputStream(“io.txt”));

//重定向:重新定义系统标准输出流的方向(程序->文件)
System.setOut(new PrintStream(new FileOutputStream(“io.txt”,true)));

//重定向:重新定义系统标准错误输出流的方向(程序->文件)
System.setErr(new PrintStream(new FileOutputStream(“io.txt”,true)));

4.1 System.in
public class Test03 {
	public static void main(String[] args) throws FileNotFoundException {
		
		//重定向:重新定义系统标准输入流的方向(文件->程序)
		System.setIn(new FileInputStream("io.txt"));
		
		InputStream in = System.in;
		
		Scanner scan = new Scanner(in);
		String str = scan.next();
		System.out.println(str);
		scan.close();
	}
	
}
4.2 System.out
public class Test04 {
	public static void main(String[] args) throws FileNotFoundException {
		
		//重定向:重新定义系统标准输出流的方向(程序->文件)
		System.setOut(new PrintStream(new FileOutputStream("io.txt",true)));
		
		PrintStream ps = System.out;
		ps.println("好好学习");
	}
	
}
4.3 System.err
public class Test05 {
	public static void main(String[] args) throws FileNotFoundException {
		
		//重定向:重新定义系统标准错误输出流的方向(程序->文件)
		System.setErr(new PrintStream(new FileOutputStream("io.txt",true)));
		
		PrintStream ps = System.err;
		ps.println("好好学习");
	}
	
}

5.随机访问流

class RandomAccessFile

理解:该流认为文件是一个大型的byte数组。有一个隐藏的指针(默认为0),其实就是下标,可以从指针的位置写入或读取,意味着该流两个方向

模式:r-读,rw-读写

5.1 利用随机访问流 向文件写入数据 RandomAccessFile

需求1:向文件写入 数字、英文、中文数据

public class Test01 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		RandomAccessFile w = new RandomAccessFile("io.txt", "rw");
		
		//2.写入数据
		w.write("123abc木头人".getBytes());
		
		//3.关闭资源
		w.close();
	}
}

需求2:在文件末尾追加

public class Test02 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		File file = new File("io.txt");
		RandomAccessFile w = new RandomAccessFile(file, "rw");
		
		//设置指针的位置
		w.seek(file.length());
		
		//2.写入数据
		w.write("123abc木头人".getBytes());
		
		//3.关闭资源
		w.close();
	}
}

5.2 利用随机访问流 读取文件里的数据 RandomAccessFile

需求1:读取数据

public class Test03 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		RandomAccessFile r = new RandomAccessFile("io.txt", "r");

		//2.读取数据
		byte[] bs = new byte[1024];
		int len;
		while((len = r.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		r.close();
	}
}
5.2 利用随机访问流 读取文件里的数据 RandomAccessFile

需求2:从英文处开始读取数据

public class Test04 {
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		RandomAccessFile r = new RandomAccessFile("io.txt", "r");

		//设置指针的位置
		r.seek(3);
		
		//2.读取数据
		byte[] bs = new byte[1024];
		int len;
		while((len = r.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		r.close();
	}
}
5.3 拷贝文件 – 断点续传
public class Copy {
	public static void main(String[] args) throws IOException {
		
		RandomAccessFile r = new RandomAccessFile("视频.mp4", "r");
		File targetFile = new File("copy.mp4");
		RandomAccessFile w = new RandomAccessFile(targetFile, "rw");
		
		//设置指针
		long fileLength = targetFile.length();
		r.seek(fileLength);
		w.seek(fileLength);
		
		byte[] bs = new byte[1024];
		int len;
		while((len = r.read(bs)) != -1){
			w.write(bs, 0, len);
		}
		
		r.close();
		w.close();
	}
}

简答题

什么是 java 序列化,如何实现 java 序列化?

序列化(钝化):将程序里的对象写入到文件

反序列化(活化):将文件里的对象读取到程序中

序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题;

序列化的实现:将需要被序列化的类实现 Serializable 接口,该接口没有需实现的方法,implements Serializable 只是为了标注该对象是可被序列化的,然 后使用一个输出流(如 FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象,接着,使用 ObjectOutputStream 对象的 writeObject(Object obj) 方法就可以将参数为 obj 的对象写出(即保存其状态),要恢复的话则用输入流。文章来源地址https://www.toymoban.com/news/detail-849859.html

到了这里,关于学习JavaEE的日子 Day37 各种流的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 学习JavaEE的日子 day13补 深入类加载机制及底层

    初识类加载过程 使用某个类时,如果该类的class文件没有加载到内存时,则系统会通过以下三个步骤来对该类进行初始化 1.类的加载(Load) → 2.类的连接(Link) → 3.类的初始化(Initialize) 类的加载(Load):将类的class文件读入内存,并为之创建一个java.lang.Class的对象,此

    2024年01月18日
    浏览(49)
  • 学习JavaEE的日子 day13 封装 static private this 类加载机制

    理解:private是访问修饰符的一种,访问修饰符规定了访问权限. 作用: ​ 1.private修饰属性:该属性只能在类的内部使用 ​ 2.private修饰方法:该方法只能在类的内部使用 应用场景:不让让外界访问的属性和方法就用private修饰 面向对象三大特征之一: 封装,继承,多态 理解:

    2024年01月18日
    浏览(45)
  • 【JavaEE基础学习打卡03】Java EE 平台有哪些内容?

    📜 本系列教程适用于Java Web初学者、爱好者,小白白。我们的天赋并不高,可贵在努力,坚持不放弃。坚信量最终引发质变,厚积薄发。 🚀 文中白话居多,尽量以小白视角呈现,帮助大家快速入门。 🎅 我是 蜗牛老师 ,之前网名是 Ongoing蜗牛 ,人如其名,干啥都慢,所以

    2024年02月12日
    浏览(45)
  • 【JavaEE基础学习打卡02】是时候了解Java EE了!

    📜 本系列教程适用于 Java Web 初学者、爱好者,小白白。我们的天赋并不高,可贵在努力,坚持不放弃。坚信量最终引发质变,厚积薄发。 🚀 文中白话居多,尽量以小白视角呈现,帮助大家快速入门。 🎅 我是 蜗牛老师 ,之前网名是 Ongoing蜗牛 ,人如其名,干啥都慢,所

    2024年02月12日
    浏览(46)
  • Java学习笔记37——网络编程01

    计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统 网络编程 在网络通信协议下,实现网络互连的不同计算机上运行的

    2024年02月07日
    浏览(48)
  • JDK1.8新特性(部分)【Lambda表达式、函数式接口】--学习JavaEE的day41

    day41 JDK1.8新特性简介 速度更快 - 优化底层源码,比如HashMap、ConcurrentHashMap 代码更少 - 添加新的语法Lambda表达式 强大的Stream API 便于并行 最大化减少空指针异常 - Optional Lambda表达式 简介 Lambda是一个匿名函数(方法), 允许把函数作为一个方法的参数 。利用Lambda表达式可以写出

    2024年04月25日
    浏览(36)
  • Day 37 贪心算法 6

    代码随想录  1. 思路 从后向前判断,如果不呈现单调递增的状态,后一位变成9,前一位-1。这里局部最优是每两位的最优解,从后向前线性遍历能得到全局最优。 但是有一点没有想清楚 。如果出现了上述的两位数倒序情况,之后的所有数字都应该变成9。例如52583,最小的递

    2024年02月01日
    浏览(38)
  • day37_jdbc

    上课同步视频:CuteN饕餮的个人空间_哔哩哔哩_bilibili 同步笔记沐沐霸的博客_CSDN博客-Java2301 零、 复习昨日 见晨考 用户输入的数据中有SQL,导致在执行SQL语句时出现一些不正常的情况.这就是SQL注入! 出现SQL注入是很危险 问题出现在用户输入数据时,里面有,再配合字

    2024年02月03日
    浏览(31)
  • 算法记录 | Day37 贪心算法

    思路: 1.一旦出现strNum[i - 1] strNum[i]的情况(非单调递增),首先想让strNum[i - 1]–,然后strNum[i]给为9,这样这个整数就是89,即小于98的最大的单调递增整数。 2.向后遍历 从前向后遍历的话,遇到strNum[i - 1] strNum[i]的情况,让strNum[i - 1]减一,但此时如果strNum[i - 1]减一了,可能

    2023年04月22日
    浏览(31)
  • Day37 贪心算法part06

    前面都想到了,结果最后n[i]给写错了直接写成9了,得把后面的全都改成9才行 摄像头的覆盖范围是上中下 遇到叶子结点,放到叶子结点的父节点 每隔两个空节点放一个摄像头 所以要用后序遍历 把结点分为三个状态:0无覆盖1有摄像头2有覆盖 空节点要设置为有覆盖的状态

    2024年02月19日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包