IO流（20210907）

最新推荐文章于 2024-07-11 17:24:34 发布
最新推荐文章于 2024-07-11 17:24:34 发布
阅读量71 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44572001/article/details/120159619
版权
操作流的基本步骤

1.创建源 2.选择流 3.操作（读入） 4.释放资源

一.节点流

从一个特定的数据源（节点）读写数据（如：文件、内存）的类叫做节点流类。在这里插入图片描述

1.文件字节流
  • 1.1字节输入流 FileInputStream
    步骤：1.创建源 ；2.选择流； 3.操作（读入）；4.释放资源
	public static void main(String[] args) {
		// 1.创建源
		File src = new File("D:/workspace/stsworkspace/IO_study02/src/abc.txt");
		// 2.选择流
		InputStream is = null;
		try {
			is = new FileInputStream(src);
			// 3.操作
			// 缓冲容器-字节数组
			byte[] flush = new byte[1024 * 10];
			// 接收长度
			int len = -1;

			while ((len = is.read(flush)) != -1) {
				// 字节数组-->字符串(解码)
				String str = new String(flush, 0, len);
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if (null != is) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
  • 1.2字节输出流 FileOutputStream
    1.创建源 2.选择流 3.操作（写出内容） 4.释放资源
	public static void main(String[] args) {
		// 1.创建源
		File dest = new File("dest.txt");
		// 2.选择流
		OutputStream os = null;
		try {
			//true:在原来的数据后面是追加写入
			//false:将原来的数据删掉，重写写入
			os = new FileOutputStream(dest,true);
			
			//3.操作(写出)
			String msg = "IO is so easy";
			//字符串-->字节数组（编码）
			byte[] datas = msg.getBytes();
			os.write(datas,0,datas.length);
			os.flush();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != os) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
  • 1.3文件copy
	public static void main(String[] args) {

		// 1.创建源
		//输入源
		File inputSrc = new File("abc.txt");
		//输出源
		File outputSrc = new File("abc_cop.txt");
		
		// 2.选择流
		InputStream is = null;
		OutputStream os = null;
		
		try {
			is = new FileInputStream(inputSrc);
			os = new FileOutputStream(outputSrc,true);
			
			// 3.操作
		
			// 缓冲容器-字节数组(分段读取)
			byte[] flush = new byte[1024 * 10];
			// 接收长度
			int len = -1;

			while ((len = is.read(flush)) != -1) {
				
//				// 字节数组-->字符串(解码)
//				String str = new String(flush, 0, len);
//				
//				// 字符串-->字节数组(编码)
//				byte[] datas = str.getBytes();
//				以上代码可以省略,由于is.read(flush)方法执行结束后,
//				不仅返回接受长度,还会将内容存入字节数组(更新fulsh),
//				所以在write方法中直接使用即可;
				
				os.write(flush,0,len);
				os.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//4.释放资源 分别关闭 先打开的后关闭
			try {
				if (null != os) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if (null != is) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
2.文件字符流
  • 2.1字符输入流 FileReader
	public static void main(String[] args) {
		// 1.创建源
		File src = new File("D:/workspace/stsworkspace/IO_study02/abc.txt");
		// 2.选择流
		Reader reader = null;
		try {
			reader = new FileReader(src);
			// 3.操作
			// 缓冲容器-字节数组
			char[] flush = new char[1024];
			// 接收长度
			int len = -1;

			while ((len = reader.read(flush)) != -1) {
				// 字节数组-->字符串
				String str = new String(flush, 0, len);
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if(null!=reader) {
					reader.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}
  • 2.2字符输出流 FileWriter
	public static void main(String[] args) {
		// 1.创建源
		File dest = new File("dest.txt");
		// 2.选择流
		Writer writer = null;
		try {
			
			writer = new FileWriter(dest);
			
			//3.操作(写出)
			String msg = "IO is so easy 文件字符输出流aaa";
			//写法一
			//字符串-->字节数组
//			char[] datas = msg.toCharArray();
//			
//			writer.write(datas,0,datas.length);
//			writer.flush();
			
			//写法二
			writer.write(msg);
			writer.write("append");
			writer.flush();
			
			//写法三
			writer.append(msg).append("append");
			writer.flush();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != writer) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
3.文件字节数组流
  • 3.1字节数组输入流 ByteArrayInputStream
    步骤： 1.创建源:字节数组； 2.选择流； 3.操作； 4.释放资源:可以不处理
	public static void main(String[] args) {
		// 1.创建源
		byte[] src = "talk is cheap show me the code".getBytes();
		// 2.选择流
		InputStream is = null;
		try {
			is = new ByteArrayInputStream(src);
			// 3.操作(分段读取)
			// 缓冲容器-字节数组
			byte[] flush = new byte[5];
			// 接收长度
			int len = -1;

			while ((len = is.read(flush)) != -1) {
				// 字节数组-->字符串
				String str = new String(flush, 0, len);
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//字节数组可以不释放内存
			try {
				if (null != is) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
  • 3.2字节数组输出流 ByteArrayOutputStream
    步骤： 1.创建源:内部维护； 2.选择流:不关联源； 3.操作:（写出内容）；4.释放资源:可以不处理
	public static void main(String[] args) {
		// 1.创建源
		byte[] dest = null;
		// 2.选择流
		ByteArrayOutputStream baos = null;
		try {
			baos = new ByteArrayOutputStream();
			
			//3.操作(写出)
			String msg = "show me the code";
			//字符串-->字节数组（编码）
			byte[] datas = msg.getBytes();
			baos.write(datas,0,datas.length);
			baos.flush();
			//获取数据
			dest = baos.toByteArray();
			System.out.println(dest.length
					+ "-->" + new String(dest,0,baos.size()));
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != baos) {
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
二.处理流

只用字节或是字符为单位来对数据做输入输出是不够的，有时候我们需要一行一行的读数据，有时我们需要读取特定格式的数据，因此Java提供了这样的机制，能把数据流作连接(chain)，让原本没有特殊访问方法的流，通过连接到特殊的流后，变成可以用特定的方法来访问数据。
在这里插入图片描述

1.字节缓冲流

提升性能，建议在所有流外面都套一个。

  • 1.1字节缓冲输入流 BufferedInputStream
	public static void main(String[] args) {
		// 1.创建源
		File src = new File("abc.txt");
		// 2.选择流
		InputStream is = null;
		try {
			is = new BufferedInputStream(new FileInputStream(src));
			// 3.操作(分段读取)
			// 缓冲容器-字节数组
			byte[] flush = new byte[1024];
			// 接收长度
			int len = -1;

			while ((len = is.read(flush)) != -1) {
				// 字节数组-->字符串
				String str = new String(flush, 0, len);
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//字节数组可以不释放内存
			try {
				if (null != is) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
  • 1.2字节缓冲输出流 BufferedOutputStream
	public static void main(String[] args) {
		// 1.创建源
		File dest = new File("destbuffer.txt");
		// 2.选择流
		OutputStream os = null;
		try {
			os = new BufferedOutputStream(new FileOutputStream(dest)) ;
			
			//3.操作(写出)
			String msg = "IO is so easy ,BufferedOutputStream";
			//字符串-->字节数组（编码）
			byte[] datas = msg.getBytes();
			os.write(datas,0,datas.length);
			os.flush();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != os) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
2.字符缓冲流
  • 2.1 字符缓冲输入流 BufferedReader
	public static void main(String[] args) {
		// 1.创建源
		File src = new File("D:/workspace/stsworkspace/IO_study02/abc.txt");
		// 2.选择流
		BufferedReader reader = null;
		try {
			reader = new BufferedReader(new FileReader(src)) ;
			// 3.操作
			String line = null;
			//readLine():BufferedReader新方法,所以第20行不能使用多态
			while ((line = reader.readLine()) != null) {
				System.out.println(line);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if(null!=reader) {
					reader.close();
				}
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}
  • 2.2 字符缓冲输出流 BufferedWriter
	public static void main(String[] args) {
		// 1.创建源
		File dest = new File("dest.txt");
		// 2.选择流
		BufferedWriter writer = null;
		try {
			
			writer = new BufferedWriter(new FileWriter(dest)) ;
			
			//3.操作(写出)
			String msg = " 文件字符输出流";
			writer.append("IO is so easy");
			writer.newLine();
			writer.append("测试新方法newLine()");
			writer.flush();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (null != writer) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
3.转换流

转换流特点：以字符流的形式操作字节流（纯文本），可以指定字符集；

  • 3.1输入流 InputStreamReader
  • 3.2输出流 OutputStreamWriter
	public static void main(String[] args) {
		//操作System.in和System.out
		try(
		//括号中可以写多行语句，会自动关闭括号中的资源
			//将字节流(System.in)转换为字符流
			//"UTF-8"指定字符集
		BufferedReader reader = new BufferedReader (new InputStreamReader(System.in,"UTF-8"));
			//将字节流(System.out)转换为字符流
		BufferedWriter writer = new BufferedWriter (new OutputStreamWriter(System.out));
		){
			//循环获取键盘的输入（exit退出），输出此内容
			String msg = "";
			while(!msg.equals("exit")) {
				msg = reader.readLine();
				writer.write(msg);
				writer.newLine();
				writer.flush();//强制刷新
			}
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
4.数据流 DataOutputStream DataInputStream

特点：保留了数据类型
要求：1.写出后读取；2.读取的顺序与写出保持一致

	public static void main(String[] args) throws IOException {
		//写出
		//声明字节流对象，以便使用其新增方法
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(baos));
		//操作数据类型 + 数据
		dos.writeUTF("编码心酸泪,谁解其中味");
		dos.writeInt(18);
		dos.writeBoolean(false);
		dos.writeChar('a');
		dos.flush();
		
		//任何数据都可以转换为字节数组
		byte[] datas = baos.toByteArray();
		//读取
		DataInputStream dis = new DataInputStream(
				new BufferedInputStream(new ByteArrayInputStream(datas)));
		//顺序与写出一致
		String msg = dis.readUTF();
		int age = dis.readInt();
		boolean flag = dis.readBoolean();
		char ch = dis.readChar();
		
		System.out.println(flag);
	}
5.对象流 ObjectOutputStream ObjectInputStream
  • 5.1对象流特点
    1.写出后读取；2.读取的顺序与写出保持一致；3.不是所有的对象都可以序列化，必须实现Serializable接口或Externalizable接口；
  • 5.2序列化
    对象(Object)序列化是指将对象转换为字节序列的过程；
    反序列化则是根据字节序列恢复对象的过程；
  • 5.3序列化一般用于以下场景
    ①永久性保存对象，保存对象的字节序列到本地文件中；
    ②通过序列化对象在网络中传递对象；
    ③通过序列化在进程间传递对象；
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//写出
		//声明字节流对象，以便使用其新增方法
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(baos));
		
		//操作对象
		oos.writeObject("编码心酸泪,谁解其中味");
		oos.writeObject(new Date());
		Emlpoyee emp = new Emlpoyee("马云",400);
		oos.writeObject(emp);
		oos.flush();
		
		//任何数据都可以转换为字节数组
		byte[] datas = baos.toByteArray();
		//读取
		ObjectInputStream ois = new ObjectInputStream(
				new BufferedInputStream(new ByteArrayInputStream(datas)));
		//顺序与写出一致
		Object str = ois.readObject();
		Object date = ois.readObject();
		Object emlpoyee = ois.readObject();
		
		if(str instanceof String){
			String strObj = (String)str;
			System.out.println(strObj);
		}
		
		if(date instanceof Date){
			Date dateObj = (Date)date;
			System.out.println(dateObj);
		}
		
		if(emlpoyee instanceof Emlpoyee){
			Emlpoyee empObj = ((Emlpoyee) emlpoyee);
			System.out.println(empObj.getName());
			System.out.println(empObj.getSalary());
		}
		
	}

被transient修饰的属性不会被序列化

class Emlpoyee implements java.io.Serializable{
	
	//transient指该数据不需要序列化
	private transient String name;
	private double salary;

	public Emlpoyee() {
		super();
	}
	
	public Emlpoyee(String name, double salary) {
		super();
		this.name = name;
		this.salary = salary;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}
	
}
6.打印流

	public static void main(String[] args) throws FileNotFoundException {
		PrintStream ps = System.out;
		ps.println("打印流");
		ps.println(true);
		
		ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("print.txt")),true);
		ps.println("打印流");
		ps.println(true);
		ps.flush();
		ps.close();
		
		//重定向输出端
		System.setOut(ps);
		System.out.println("change");
		//重定向回控制台
		System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));
		System.out.println("I am backing");
	}
Ichitei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java---File类以及字节流
airar的博客
11-18 953
1.文件操作 文件---把数据持久化到磁盘的载体 文件的组成:1.文件的基本属性【文件命名，文件类型，文件的创建时间，文件的大小.......】 2.文件中的数据 2.File类的创建对象和常用方法 File类的定义：public class File 1.File类的静态成员变量： static String----pathSeparator与系统相关的路径分隔符，为方便起见，表示为字符串 static char----path...
记：百度秋招20210907笔试题
小卜妞的博客
09-08 368
百度-正式批 笔试-0907 选择题占60分，编程题占40分 选择题 基本是Java、计算机网络、操作系统、数据结构类的题目，考研408，emmmm list.stream().map(d->1).reduce(0,(a,b)->a+b)：本题关于Java1.8的新特性stream的功能进行考察，stream是用来管理集合数据的，可以看作高级的迭代器；map用来归类；reduce用来计算值。本句代码表示计算流中元素个数，换成count()也可计数。 计网：GBN协议，发送0-10帧，计时器超时
六、MySQL数据库面试题（2021最新版）20210907
杏子与鸡腿
09-07 409
数据库基础知识 为什么要使用数据库 数据保存在内存 优点： 存取速度快 缺点： 数据不能永久保存 数据保存在文件 优点： 数据永久保存 缺点：1）速度比内存操作慢，频繁的IO操作。2）查询数据不方便 数据保存在数据库 1）数据永久保存 2）使用SQL语句，查询方便效率高。 3）管理数据方便 什么是SQL？ 结构化查询语言(Structured Query Language)简称SQL，是一种数据库查询语言。 作用：用于存取数据、查询、更新和管理关系数据库系统。 什么是M...
五、java并发编程面试题（2021最新版）20210907
杏子与鸡腿
09-07 243
罗列，并没有系统化整理 基础知识 并发编程的优缺点 为什么要使用并发编程（并发编程的优点） 充分利用多核CPU的计算能力：通过并发编程的形式可以将多核CPU的计算能力发挥到极致，性能得到提升 方便进行业务拆分，提升系统并发能力和性能：在特殊的业务场景下，先天的就适合于并发编程。现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。面对复杂业务模型，并行程序会比串行程序更适应业务需求，而并发编..
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
IO流自用模板
12-17
在Java编程中，IO流（Input/Output Stream）是用来处理数据输入和输出的重要工具。它允许程序与外部设备，如硬盘、网络、内存等进行数据交互。IO流分为两大类：字节流（处理字节数据）和字符流（处理字符数据）。...
IO流工具组件
08-02
IO流工具组件 1 1 1 1 1 1
java IO流详细笔记
07-12
Java IO流详解
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
配置Java开发环境
Broken_x的博客
07-10 1067
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 274
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1769
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1178
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 349
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
Java方法练习-双色球彩票系统
最新发布
T1798218285的博客
07-11 46
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2995
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
qq_44304677的博客
07-09 808
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 609
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
javaio流电子书整理面试必考io流帮助你入职阿里腾讯
03-12
"Java IO流是Java编程中用于处理输入输出操作的重要概念，涉及数据的持久化、存储介质和各种应用场景。本电子书主要讲解了IO流的基础知识，包括流的概念、分类、IO流体系，以及InputStream和OutputStream的使用。书...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值