1. Toy模板网首页
  2. > Toy博客

学习JavaEE的日子 Day37 各种流

5月前 作者：A 北枝 分类：Toy博客 阅读(20) 违法举报

这篇具有很好参考价值的文章主要介绍了学习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补 深入类加载机制及底层

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

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

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

    学习JavaEE的日子 day13 封装 static private this 类加载机制

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

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

    【JavaEE基础学习打卡03】Java EE 平台有哪些内容？

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

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

    【JavaEE基础学习打卡02】是时候了解Java EE了！

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

    2024年02月12日
    浏览(33)

  • Java学习笔记37——网络编程01

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

    2024年02月07日
    浏览(39)

  • JDK1.8新特性（部分）【Lambda表达式、函数式接口】--学习JavaEE的day41

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

    2024年04月25日
    浏览(28)

  • Day 37 贪心算法 6

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

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

    day37_jdbc

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

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

    算法记录 | 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日
    浏览(22)

  • Day37 贪心算法part06

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

    2024年02月19日
    浏览(33)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包