IO流

最新推荐文章于 2024-11-04 22:09:25 发布
最新推荐文章于 2024-11-04 22:09:25 发布
阅读量112 收藏
点赞数
分类专栏： java基础 文章标签： io IO流 字节流 字符流 缓冲流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39146914/article/details/100136729
版权

IO流 ：

一 流的分类
1.按操作数据单位不同分为：字节流(8 bit)(视频,音频,图片)，字符流(16 bit)(文本文件)
2.按数据流的流向不同分为：输入流，输出流
3.按流的角色的不同分为：节点流，处理流

	@Test
	public void test2(){
		FileInputStream fis = null;
		try {
			//1.创建File对像
			File file = new File("hello.txt");
			//2.创建流的对像
			fis = new FileInputStream(file);
			//3.读取文件内容
			byte[] b = new byte[5];
			int len = 0;
			while((len = fis.read(b)) != -1){
//				for (int i = 0; i < len; i++) {
//					System.out.print((char)b[i]);
//				}
				System.out.print(new String(b,0,len));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//4.关流
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

转换流

作用 ： 1.将字节流可以转成字符流
2.对文件内容进行转码（比如将GBK 转成 UTF-8）
注意：读取文件内容的时候 输入流的编码格式和文件的编码格式必须保持一致

/*
* InputStreamReader ： 将字节流转换成字符流
*/

@Test
	public void test() throws Exception{
		
		File file = new File("aaa.txt");
		FileInputStream fis = new FileInputStream(file);
		//创建一个转换流的对象 ： 将字节流转换成了字符流
		InputStreamReader isr = new InputStreamReader(fis);
		
		char[] c = new char[100];
		int len = 0;
		while((len = isr.read(c)) != -1){
			System.out.println(new String(c,0,len));
		}
		
		isr.close();
		fis.close();
	}

/*
* OutputStreamWriter : 将字符流转成字节流
*/

@Test
public void test2() throws Exception{
	FileOutputStream fos = new FileOutputStream("bbb.txt");
	OutputStreamWriter osw = new OutputStreamWriter(fos);
	osw.write("中国中国我爱你".toCharArray());
	FileInputStream fis = new FileInputStream("bbb.txt");
    byte[] b = new byte[2024];
    int len = 0;
    while((len = fis.read(b))!=-1){
    	System.out.println(new String(b, 0, len));
    }
	
System.out.println();
	osw.flush();
	osw.close();
	fos.close();
}

转码

 注意：读取文件内容的时候  输入流的编码格式和文件的编码格式必须保持一致

@Test
public void test3() throws Exception{
	FileInputStream fis = new FileInputStream("char8.txt");
	InputStreamReader isr = new InputStreamReader(fis,"gbk");
	FileOutputStream fos = new FileOutputStream("char9.txt");
	OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
	//读写内容
	char[] c = new char[500];
	int len = 0;
	while((len = isr.read(c)) != -1){
		osw.write(c, 0, len);
	}
	//关流
	osw.close();
	isr.close();
	fos.close();
	fis.close();
}



/*
 * FileOutputStream
 * 注意 ： 要写入到的文件可以不存在。
 * FileOutputStream(File file, boolean append) : 
 * append如果为true : 内容在原来的基础上进行追加
 * append如果为false : 内容会覆盖原来的内容
 * 默认是false
 */

@Test
public void test() throws Exception{
	//1.创建File对像
	File file = new File("aaa.txt");
	//2.创建流的对象
	FileOutputStream fos = new FileOutputStream(file,false);
	//3.写内容
	fos.write("fffff".getBytes());
	//4.关流
	fos.close();
}

一边读一边写

    @Test
    public void test2() throws Exception{
    	//1.创建File对像
    	File file = new File("hello.txt"); //读取的文件
    	File file2 = new File("ccc.txt"); //写入内容的的文件
    	//2.创建流
    	FileInputStream fis = new FileInputStream(file);
    	FileOutputStream fos = new FileOutputStream(file2);
    	//3.一边读一边写
    	byte[] b = new byte[1024];
    	int len = 0;
    	while((len = fis.read(b)) != -1){
    		//将内容写出去
    		fos.write(b, 0, len);
    	}
    	
    	//4.关流
    	fis.close();
    	fos.close();
    	
    }

实现复制的功能



	 
	@Test
	public void test3(){
		String desc = "C:\\Users\\Administrator\\Desktop\\bbb.avi";
		String src = "C:\\Users\\Administrator\\Desktop\\aaa.avi";
		long start = System.currentTimeMillis();
		copy(desc, src);
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}
	
	public void copy(String desc,String src){
		FileOutputStream fos = null;
		FileInputStream fis =  null;
		try {
			//1.创建File对象
			File file = new File(desc); //复制的文件的路径
			File file2 = new File(src); //被复制的文件的路径
			//2 创建流
			fis = new FileInputStream(file2);
			fos = new FileOutputStream(file);
			//3 一边读一边写
			byte[] b = new byte[1024];
			int len = 0;
			while((len = fis.read(b)) != -1){
				fos.write(b, 0, len);
			}
		
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//关流
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

打印流 （了解）

		FileOutputStream fos = new FileOutputStream("text.txt");
		
		// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
		PrintStream ps = new PrintStream(fos, true);
		
		// 把标准输出流(控制台输出)改成文件
		if (ps != null) { 
			System.setOut(ps);
		}
		
		for (int i = 0; i <= 10; i++) { // 输出ASCII字符
//			System.out.print((char) i);
//			if (i % 50 == 0) { // 每50个数据一行
//				System.out.println(); // 换行
//			}
			
			System.out.print("a");
		}
		
		ps.close();

缓冲流 : 提高读取和写入的效率

/*
	 *  new BufferedInputStream(InputStream in)
		
	 */
	@Test
	public void test() throws Exception{
		
		//创建节点流
		FileInputStream fis = new FileInputStream("aaa.txt");
		//创建缓冲流
		BufferedInputStream bis = new BufferedInputStream(fis);
		//读内容
		byte[] b = new byte[1024];
		int len = 0;
		while((len = bis.read(b)) != -1){
			System.out.println(new String(b,0,len));
		}
		//关流(从外向内关流)
		bis.close();
		fis.close();
		
	}
	
	/*
	 * new BufferedOutputStream(OutputStream out)
	 */
	@Test
	public void test2() throws Exception{
		//创建节点流
		FileOutputStream fos = new FileOutputStream("bbb.txt");
		//创建缓冲流
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		//写内容
		bos.write("cccccccccccccccccccccc".getBytes());
		//关流
		bos.close();
		fos.close();
	}
	
	/*
	 * 使用缓冲流进行文件的复制
	 */
	@Test
	public void test3(){
		String desc = "C:\\Users\\Administrator\\Desktop\\bbb.avi";
		String src = "C:\\Users\\Administrator\\Desktop\\aaa.avi";
		long start = System.currentTimeMillis();
		copy(desc, src);
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}
	
	public void copy(String desc,String src){
		FileOutputStream fos = null;
		FileInputStream fis =  null;
		BufferedOutputStream bos = null;
		BufferedInputStream bis =  null;
		try {
			//1.创建File对象
			File file = new File(desc); //复制的文件的路径
			File file2 = new File(src); //被复制的文件的路径
			//2 创建流
			fis = new FileInputStream(file2);
			fos = new FileOutputStream(file);
			//创建缓冲流
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(fos);
			
			//3 一边读一边写
			byte[] b = new byte[1024];
			int len = 0;
			while((len = bis.read(b)) != -1){
				bos.write(b, 0, len);
			}
		
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bis != null){
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(bos != null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			//关流
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

数据流（了解）

/*
 *  写入到文件的类型的顺序 应该和读取文件内容类型的 顺序保持一致  否则会导致内错，或者异常
 */
	@Test
	public void test() throws Exception{
		
		FileInputStream fis = new FileInputStream("faaa.txt");
		DataInputStream dis = new DataInputStream(fis);
	
		
		int readInt = dis.readInt();
		String readUTF = dis.readUTF();
		String readUTF2 = dis.readUTF();
		String readUTF3 = dis.readUTF();
		float readFloat = dis.readFloat();
		
		
		dis.close();
		fis.close();
	}
	
	
	@SuppressWarnings("resource")
	@Test
	public void test2() throws Exception{
		FileOutputStream fos = new FileOutputStream("faaa.txt");
		DataOutputStream dos = new DataOutputStream(fos);
		
		dos.writeInt(111);
		dos.writeUTF("?#====");
		dos.writeUTF("abcd");
		dos.writeUTF("defgg");
		dos.writeFloat(12.3f);
		
		
		dos.close();
		fos.close();
	}
}

字符流

  • 字节流和字符流使用场景：
  • 字节流 ： 如果需要复制一些文件我们会考虑使用字节流
  • 字符流 ： 如果需要读取一些中文那么这个时候会考虑使用字符流
/*
	 * FileReader
	 */
	@Test
	public void test() throws Exception{
		
		FileReader reader = new FileReader("hello.txt");
		
		char[] c = new char[1024];
		int len = 0;
		while((len = reader.read(c)) != -1){
			for (int i = 0; i < len; i++) {
				System.out.print(c[i]);
			}
//			System.out.println(new String(c,0,len));
		}
		
		reader.close();
	}
	
/*
* FileWriter
 */
   @Test
   public void test2() throws Exception{
	   //创建流
	   FileWriter writer = new FileWriter("abc.txt");
	   //写内容
	   writer.write("中国人中国啦啦啦啦".toCharArray());
	   //关流
	   writer.close();
   }


/*
    * 一边读一边写
    */
   @Test
   public void test3() throws Exception{
	   //创建流
	   FileReader reader = new FileReader("abc.txt");
	   FileWriter writer = new FileWriter("cba.txt");
	   //一边读一边写
	   char[] c = new char[100];
	   int len = 0;
	   while((len = reader.read(c)) != -1){
		   writer.write(c, 0, len);
	   }
	   //关流
	   writer.close();
	   reader.close();
   }

对象流

注意：
 * 		一  序列化的对象所在的类必须实现Serializable接口
 * 		二  所在类中的引用数据类型也必须实现Serializable接口
 * 		三  显示声明private static final long serialVersionUID = 10000000546546546L;
 * 			注意：
 * 				1.也可以不显示声明，但是如果不显示声明的话就不要修改原来的类中的内容。
 * 				如果需要修改建议大家显示的去声明且声明的版本号和序列化时的版本号保持一致。
 * 				2.如果没有显示的声明程序也会自动添一个版本号，但是如果序列化中的那个类进行修改了，那么版本号会发生改变。
 * 	            transient 修饰的属性不可序列化
 *              static修饰的属性也不可以序列化
 * 
 * 序列化 ： 将内存中的对象写到磁盘上
 * 反序列化 ： 将磁盘上的对象的内容进行读取，读取到内存		

@Test
	public void test() throws Exception{
		
		FileInputStream fis = new FileInputStream("object.txt");
		ObjectInputStream ois = new ObjectInputStream(fis);
		
		Object readObject = ois.readObject();
		Person person = (Person) readObject;
		person.show();
		System.out.println(person.aa);
		ois.close();
		fis.close();
	}
	
	
	@Test
	public void test2() throws Exception{
		
		FileOutputStream fos = new FileOutputStream("object.txt");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		
		Person person = new Person("aaa",18,new Address("国王街"));
		person.aa = "ccc";
		oos.writeObject(person);
		
		oos.close();
		fos.close();
	}

字符缓冲流

FileReader reader = new FileReader("cba.txt");
		BufferedReader br = new BufferedReader(reader);
		
		FileWriter writer = new FileWriter("dcc.txt");
		BufferedWriter bw = new BufferedWriter(writer);
		
		//一边读一边写
//		char[] c = new char[100];
//		int len = 0;
//		while((len = br.read(c)) != -1){
//			bw.write(c, 0, len);
//		}
		
//		String readLine = br.readLine(); //读一行 如果读完了返回null
		String str = "";
		while((str = br.readLine()) != null){
//			System.out.println(str);
			bw.write(str);
			bw.newLine(); //换行
		}
		
//		bw.flush(); //将内存中的数据刷到磁盘上
		
		//关流
		bw.close(); //在关闭流的同时调用了flush方法
		br.close();
		writer.close();
		reader.close();
	}

/*
	 * 总结
	 */
	@Test
	public void test() throws Exception{
		
		new FileOutputStream(new File("aaa.txt"), true); //true是追加 false是覆盖
		
		new FileWriter(new File("aaa.txt"), true); //true是追加 false是覆盖
		
//	    new PrintStream(fos, true); //true是否自动刷新
		
		new BufferedReader(new InputStreamReader(System.in),1); //1是指的在内存中缓存区域的大小
	}

随机存取文件流

	@Test
	public void test5() throws Exception{
		RandomAccessFile ra = new RandomAccessFile("acc.txt", "rw");
//		 * 1.先将指针移动到c的后面
		ra.seek(3);
//		 * 2.读取c后面的内容并保存
//		String str = ra.readLine();
		String str = "";
		byte[] b = new byte[1024];
		int len = 0;
		while((len = ra.read(b)) != -1){
//			str += new String(b,0,len);
			String s = new String(b,0,len);
			str +=  s;
		}
//		 * 3.回移指针移动到c的后面
		ra.seek(3);
//		 * 4.将AAA写入（写入后会进行覆盖 -- abcAAAg）
		ra.write("AAA".getBytes());
//		 * 5.继续将原来保存的内容向后写
		ra.write(str.getBytes());
		
		ra.close();
	}
	/*
	 * 文件中的内容   : abcdefg   
	 * 
	 * 需求:在c的后面插入AAA
	 * 
	 * 1.先将指针移动到c的后面
	 * 2.读取c后面的内容并保存
	 * 3.回移指针移动到c的后面
	 * 4.将AAA写入（写入后会进行覆盖 -- abcAAAg）
	 * 5.继续将原来保存的内容向后写
	 */
	@Test
	public void test4() throws Exception{
		RandomAccessFile ra = new RandomAccessFile("acc.txt", "rw");
		//移动指针
		ra.seek(3); //将指针移动到3的位置
		
		ra.write("AAA".getBytes());
		
		ra.close();
	}
	
	/*
	 * 从某个位置向后读
	 */
	@Test
	public void test3() throws Exception{
		
		RandomAccessFile ra = new RandomAccessFile("acc.txt", "rw");
		//移动指针
		ra.seek(3); //将指针移动到3的位置
		
		String readLine = ra.readLine();
		
		System.out.println(readLine); //defg
		
		ra.close();
		
	}
	
	/*
	 * 读
	 */
	@Test
	public void test() throws Exception{
		
		RandomAccessFile ra = new RandomAccessFile("acc.txt", "rw");
		byte[] b = new byte[1024];
		int len = 0;
		while((len = ra.read(b)) != -1){
			System.out.print(new String(b,0,len));
		}
		
		ra.close();
		
	}
	
	/*
	 * 写
	 */
	@Test
	public void test2() throws Exception{
		RandomAccessFile ra = new RandomAccessFile("acc.txt", "rw");
		
		ra.write("abcdefg".getBytes());
		
		ra.close();
	}
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
Java中文件IO流.pdf
07-11
Java 中文件 IO 流 Java 中文件 IO 流是指 Java 语言中对文件的输入输出操作，通过定义文件流来实现文件的读写操作。文件流是指在程序中用于文件输入输出的对象， Java 中提供了多种文件流类型，包括 InputStream ...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 16万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
javaIO流详解
weixin_46676497的博客
01-27 3573
java常用io流介绍
io流
qq_40977337的博客
05-09 3196
IO流 java.io包 1.什么是流？ io流就是java中运输数据的一种载体 它能够把数据从一个地方运输到另一个地方 2.流的分类 a 根据流运输数据的方向<以内存为参考物> 输入流 输出流 b 根据数据传输时转换的类型 字节流 byte 字符流 char ...
Java：IO流详解
游手好闲
01-06 9806
Java：IO流详解
java基础：IO流
最新发布
weixin_62944431的博客
11-04 1848
目录序一、IO流开篇1、概念2、流的分类3、IO流的作用4、IO流的使用场景二、字节流1、字节流抽象基类2、字节流写数据（1）基本步骤（2）三种方式（3）两个问题（4）异常处理3、字节缓冲流（1）基本分类&概述（2）构造方法（3）代码演示三、字符流1、概念2、分类（1）字符流体系图（2）字符输入流（Reader）（3）字符输出流（Writer）3、字符缓冲流（1）概念（2）构造方法（3）代码演示（4）字符缓冲流特有功能四、IO特殊操作流。
Java中的IO流-最全最基础的IO流概述和简介
是程序喵呀
08-23 3841
Java中的IO流是用于处理数据输入和输出的核心机制。通过应用IO流可以使Java程序能够与外部世界（如磁盘文件、网络、硬件设备等）进行数据交互。IO流的全称为输入/输出流（Input/Output Stream），它是Java编程语言中用于数据传输的一种抽象模型。流可以被想象为数据的连续流动，就像水通过管道一样，数据通过流从一个地方流向另一个地方。文件流是用来连接我们的程序与文件之间的"管道",用来读写文件中的数据。
Java io流 详解
m0_68987535的博客
06-11 5098
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
IO流的分类
小白学编程
05-11 1万+
IO流的分类可以分为以下三种： 第一种：输入流和输出流 按照流的流向来分，可以分为输入流和输出流。输入，输出都是从程序运行所在内存的角度来划分的。 输入流：只能从中读取数据，而不能向其写入数据，由InputStream和Reader作为基类。 输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类 第二种：字节流和字符流 字节流和字符流的用法几乎完全一样，区...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、...
equals和==的区别是什么
weixin_39146914的博客
09-13 5912
面试提问： equals和==的区别是什么？ == : 如果比较的是基本数据类型，那么比较的是变量的值 == ：如果比较的是引用数据类型，那么比较的是地址值（两个对象是否指向同一块内存） equals:如果没有重写equals方法比较的是两个对象的地址值。 如果重写了equals方法后我们往往比较的是对象中的属性的内容 具体解释 一 、 java.lang.Object ...
多肽
weixin_39146914的博客
08-30 408
多态性 ： 一种事物的多种形态 多态性的体现： 1.广义上 ： ①方法的重载和重写 ②子类对象的多态性 2.狭义上 ：①子类对象的多态 性 子类对象的多态性 ： 父类的引用指向子类的对象 （Person p = new Student()） 多态使用的前提 ： ①要有继承关系 ②要有方法的重写 一个对象的实例：Man m = new Man(); m就是这个对象的实例 public stati...
线程锁（synchronized）
weixin_39146914的博客
08-30 233
/* * 卖票的问题 ： 错票 ，重票 * * 问题的原因 ： 多个线程同时操作共享数据，当其中一个线程正在执行操作共享数据的代码时，其它的线程也进入了。 * * 解决问题的方案 ： 多个线程同时操作共享数据，只允许同时只有一个线程 对共享数据进行操作 * * 方式一 ： 同步代码块 * 格式 ： synchronized (监视器) { 操作共享数据的代...
Collection集合
weixin_39146914的博客
08-26 167
/* * * 一 集合 * * 二 数组的特点 ： * 1.数组一旦创建成功，长度不可变 * 2.数组声明的类型就决定了存储的元素的类型 * * 三 数组的缺点： * 1.数且的长度不可变。 * 2.数组的属性和方法比较少。比如缺少 添加，删除，插入等方法 * 3.数组存放元素是有序的，对于无序的无能为力。 * * 四 Collection * List : 存放的数据是...
深入理解Java IO流
"深入理解Java的IO流系统，包括字节流和字符流的各类实现" 在Java编程中，IO（Input/Output）流是处理数据输入和输出的关键机制。Java的IO流系统提供了丰富的类库，使开发者能够方便地进行文件读写、网络通信以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值