IO流的详细概述和应用案例(值得推荐)

IO流的详细概述和应用案例(值得推荐)

一、阐述IO流的概述和分类

IO流概述:
处理设备间数据传输问题
IO流分类:
1、按流向(一定要站在Java程序这边看问题)
–>输入流
–>输出流
2、按类型
–>字节流(图片,视频,音频,等多媒体文件)
–>字符流(.txt结尾的文本文件)

图解:
在这里插入图片描述

API总汇:

1、IO【字节流】抽象类和具体类的关系图:适合任意类型的文件读写
在这里插入图片描述
2、IO【字符流】抽象类和具体类的关系图:只适合文本类型的文件读写
在这里插入图片描述

二、阐述FileOutputStream

1、字节流写数据:

  • OutputStream:此抽象类是表示输出字节流的所有类的超类

  • FileOutputStream:文件输出流是用于将数据写入 File

  • 构造方法:
    FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流。

2、字节流写数据的步骤:
—A:创建字节输出流对象
—B:调用写数据的方法
—C:释放资源

首先我写一个Demo让大家看看:
编写使用FileOutputStream写数据的案例

public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("a.txt");
		/*
		 * 创建字节输出流对象做了这样的三件事情:
		 * A:调用系统功能创建了文件
		 * B:创建字节输出流对象
		 * C:让fos这个对象指向a.txt这个文件
		 */
		
		//write(int b) 
		fos.write(65);
		fos.write(66);
		
		//最后我们还要做一个事情
		//close() 关闭此文件输出流并释放与此流有关的所有系统资源。
		fos.close();
	}
}

三、FileOutputStream写数据的三种方式【应用】

1、构造方法:

  • FileOutputStream(String name)
  • FileOutputStream(File file)

  • public void write(int b):一次写一个字节

  • public void write(byte[] b):一次写一个字节数组
    String类中的getByes(),返回值为byte[]数组

  • public void write(byte[] b,int off,int len):一次写一个字节数组的一部分


2、字节流写数据的步骤:
—A:创建字节输出流对象
—B:调用写数据的方法
—C:释放资源

public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		//FileOutputStream(String name) 
		FileOutputStream fos = new FileOutputStream("b.txt");
		//new File(name)
//		FileOutputStream fos = new FileOutputStream(new File("b.txt"));
		
		//FileOutputStream(File file) 
//		File file = new File("b.txt");
//		FileOutputStream fos = new FileOutputStream(file);
//		FileOutputStream fos = new FileOutputStream(new File("b.txt"));
		
		//public void write(int b):一次写一个字节
//		fos.write(65);
		
		//public void write(byte[] b):一次写一个字节数组
//		byte[] bys = {65,66,67,68,69};
//		fos.write(bys);
		//需求:我如果是一个字符串的数据,能写吗?
		//String -- byte[]
		//String类中有一个方法:public byte[] getBytes()
//		byte[] bys = "ABCDE".getBytes();
//		fos.write(bys);
//		fos.write("ABCDE".getBytes());
		
		//public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
		fos.write("ABCDE".getBytes(),0,3);
		
		//释放资源
		fos.close();
	}
}

四、FileOutputStream如何实现换行和追加写数据【应用】

1、如何实现数据的换行?

  • 不同的操作系统,针对换行的符号识别是不一样的。
  • windows:\r\n
  • linux:\n
  • mac:\r

2、如何实现数据的追加写入?

  • 用构造方法带第二个参数是true的情况即可
例如:FileOutputStream fos = new FileOutputStream("c.txt",true);
public class FileOutputStreamDemo3 {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		//FileOutputStream fos = new FileOutputStream("c.txt");
		//FileOutputStream(String name, boolean append) 
		//如果第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处
		FileOutputStream fos = new FileOutputStream("c.txt",true);
		
		//调用写数据的方法
		for(int x=0; x<10; x++) {
			fos.write("hello".getBytes());
			//加入换行符号
			fos.write("\r\n".getBytes());
		}
		
		//释放资源
		fos.close();
	}
}

五、FileOutputStream写数据加入异常处理【应用】

public class FileOutputStreamDemo4 {
	public static void main(String[] args) {
//		FileOutputStream fos = new FileOutputStream("d.txt");
//		fos.write("hello".getBytes());
//		fos.close();
		
		//分开做异常处理
//		FileOutputStream fos = null;
//		try {
//			fos = new FileOutputStream("d.txt");
//		} catch (FileNotFoundException e) {
//			e.printStackTrace();
//		}
//		try {
//			fos.write("hello".getBytes());
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
//		try {
//			fos.close();
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
		
		//放在一起做异常处理
//		try{
//			FileOutputStream fos = new FileOutputStream("d.txt");
//			fos.write("hello".getBytes());
//			fos.close();
//		}catch(IOException e) {
//			e.printStackTrace();
//		}
		//这种方式代码虽然简洁了,但是释放资源的动作可能未执行到
		//try...catch...finally
		FileOutputStream fos = null;
		try{
			//FileOutputStream fos = new FileOutputStream("d.txt");
//			fos = new FileOutputStream("z:\\d.txt");
			fos = new FileOutputStream("d.txt");
			fos.write("hello".getBytes());
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			if(fos!=null) {
				//释放资源
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

六、FileInputStream读数据方式

1、一次读一个字节

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("a.txt");
		
		/*
		//调用读数据的方法
		//public int read():读取一个字节的数据,如果已到达文件末尾,则返回 -1。 
		int by = fis.read();
		System.out.println(by);
		System.out.println((char)by);
		
		//再来读取一次
		by = fis.read();
		System.out.println(by);
		System.out.println((char)by);
		
		//发现读数据的代码的重复度很高,想用循环改进
		//但是我们不知道循环的结束条件
		//再来读取两次
		by = fis.read();
		System.out.println(by);
		by = fis.read();
		System.out.println(by);
		*/
		
//		int by = fis.read();
//		while(by != -1) {
//			System.out.print((char)by);
//			by = fis.read();
//		}
		
		//改进版本
		int by;
		//fis.read()
		//by=fis.read()
		//by != -1
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		
		//释放资源
		fis.close();
	}
}

2、一次读取一个字节数组

public class FileInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("b.txt");
		
		/*
		//调用读数据的方法
		//定义一个数组
		byte[] bys = new byte[5];
		
		//第一次读取
		int len = fis.read(bys);
		System.out.println(len);
		//byte[] -- String
		//String(byte[] bytes) 
		//String(byte[] bytes, int offset, int length) 
		System.out.println(new String(bys));
		
		//第二次读取
		len = fis.read(bys);
		System.out.println(len);
		System.out.println(new String(bys));
		
		//第三次读取
		len = fis.read(bys);
		System.out.println(len);
//		System.out.println(new String(bys));
		System.out.println(new String(bys,0,len));
		
		//第四次读取
		len = fis.read(bys);
		System.out.println(len);
		//第五次读取
		len = fis.read(bys);
		System.out.println(len);
		*/
		
		/*
		 * hello\r\n
		 * world\r\n
		 * 
		 * hello
		 * \r\nwor
  		 * ld\r\nr
		 */
		
		/*
		byte[] bys = new byte[5];
		int len = fis.read(bys);
		while(len != -1) {
			System.out.print(new String(bys,0,len));
			len = fis.read(bys);
		}
		*/
		
		//最终版代码
		byte[] bys = new byte[1024]; //1024或者1024的整数倍
		//1G = 1024MB
		//1MB = 1024KB
		//...
		int len;
		while((len=fis.read(bys))!=-1) {
			System.out.print(new String(bys,0,len));
		}
		
		//释放资源
		fis.close();
	}
}

七、字节流练习之复制图片【应用】

/*
 * 把d:\\mn.jpg内容复制到当前项目目录下的mn.jpg中
 * 
 * 数据源:
 * 		d:\\mn.jpg---读数据---FileInputStream
 * 目的地:
 * 		mn.jpg---写数据---FileOutputStream
 */
public class CopyJpgTest {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("d:\\mn.jpg");
		//封装目的地
		FileOutputStream fos = new FileOutputStream("mn.jpg");
		
		//读写数据
		//方式1:一次读取一个字节,一次写一个字节(自己练习)
		//方式2:一次读取一个字节数组,一次写一个字节数组的一部分
		byte[] bys = new byte[1024];
		int len;
		while((len=fis.read(bys))!=-1) {
			fos.write(bys,0,len);
		}
		
		//释放资源
		fos.close();
		fis.close();
	}
}

八、字节缓冲区流的概述和使用【应用】

字节缓冲区流:

  • BufferedOutputStream:字节缓冲输出流
  • BufferedInputStream:字节缓冲输入流
  • BufferedOutputStream(OutputStream out)
    使用这种构造方法,它提供了一个默认的缓冲区大小,所以一般我们使用默认的缓冲区就可以了。

  • 为什么构造方法传递的是一个:OutputStream,而不是具体的文件或者路径呢?
    —》字节缓冲区流仅仅提供缓冲区,而真正的底层的读写数据还得需要基本的流对象进行操作。
public class BufferedStreamDemo {
	public static void main(String[] args) throws IOException {
		// BufferedOutputStream(OutputStream out)
		// FileOutputStream fos = new FileOutputStream("a.txt");
		// BufferedOutputStream bos = new BufferedOutputStream(fos);
		// 上面的两句等价于下面的这一句
		// BufferedOutputStream bos = new BufferedOutputStream(new
		// FileOutputStream("a.txt"));
		// bos.write("hello".getBytes());
		// bos.close();

		// BufferedInputStream(InputStream in)
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
		//方式1:一次读取一个字节
//		int by;
//		while((by=bis.read())!=-1) {
//			System.out.print((char)by);
//		}
		
		//方式2:一次读取一个字节数组
		byte[] bys = new byte[1024];
		int len;
		while((len=bis.read(bys))!=-1) {
			System.out.print(new String(bys,0,len));
		}
		
		bis.close();
	}
}

九、字节流四种方式复制AVI并测试效率【应用】

1、把d:\复制图片.avi复制到当前项目目录下的copy.avi中

  • 数据源:d:\复制图片.avi
  • 目的地:copy.avi

2、四种方式比较复制效率

  • 基本字节流一次读写一个字节 共耗时:50233毫秒
  • 基本字节流一次读写一个字节数组 共耗时:79毫秒
  • 缓冲字节流一次读写一个字节 共耗时:197毫秒
  • 缓冲字节流一次读写一个字节数组 共耗时:30毫秒

  • 提示:
  • 复制文件的时间计算可以采用System类的方法实现
  • public static long currentTimeMillis():返回以毫秒为单位的当前时间。
public class CopyAviTest {
	public static void main(String[] args) throws IOException {
		//记录开始时间
		long start = System.currentTimeMillis();
		
//		method1();
//		method2();
//		method3();
		method4();
		
		//记录结束时间
		long end = System.currentTimeMillis();
		System.out.println("共耗时:"+(end-start)+"毫秒");
	}
	
	//缓冲字节流一次读写一个字节数组
	private static void method4() throws IOException {
		//封装数据源
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
		//封装目的地
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
		
		byte[] bys = new byte[1024];
		int len;
		while((len=bis.read(bys))!=-1) {
			bos.write(bys,0,len);
		}
		
		bos.close();
		bis.close();
	}


//缓冲字节流一次读写一个字节
	private static void method3() throws IOException {
		//封装数据源
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
		//封装目的地
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
		
		int by;
		while((by=bis.read())!=-1) {
			bos.write(by);
		}
		
		bos.close();
		bis.close();
	}
	
	//基本字节流一次读写一个字节数组
	private static void method2() throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
		//封装目的地
		FileOutputStream fos = new FileOutputStream("copy.avi");
		
		byte[] bys = new byte[1024];
		int len;
		while((len=fis.read(bys))!=-1) {
			fos.write(bys,0,len);
		}
		
		fos.close();
		fis.close();
	}

	//基本字节流一次读写一个字节
	private static void method1() throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
		//封装目的地
		FileOutputStream fos = new FileOutputStream("copy.avi");
		
		int by;
		while((by=fis.read())!=-1) {
			fos.write(by);
		}
		
		fos.close();
		fis.close();
	}
}

==>转换流出现的原因【理解】

原因:
字节流一次读取一个字节的方式读取带有汉字的文件是有问题的,因为你读取到一个字节后就转为字符在控制台输出了,而汉字是由2个字节组成的,所以这里会出问题。
文件复制的时候,字节流读取一个字节,写入一个字节,这个没有出现问题,是因为最终底层会根据字节做拼接,得到汉字。
汉字存储的规则:
左边的字节数据肯定是负数,右边的字节数据可能是负数,也可能是正数,大部分	情况下是负数。	
如:	String s1 = "hello";
		//[104, 101, 108, 108, 111]
		String s2 = "你好";
		//[-60, -29, -70, -61]

&&下面开始阐述字符流的相关知识和应用

十、OutputStreamWriter写数据的5种方式

===》OutputStreamWriter写数据方法

  • public void write(int c):写一个字符
  • public void write(char[] cbuf):写一个字符数组
  • public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
  • public void write(String str):写一个字符串
  • public void write(String str,int off,int len):写一个字符串的一部分
public class OutputStreamWriterDemo {
	public static void main(String[] args) throws IOException {
		//创建字符输出流对象
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
		
		//public void write(int c):写一个字符
//		osw.write(97);
//		osw.write('a');
		//写完数据后,没有发现数据,为什么呢?
		//1字符=2字节
		//文件中的数据存储的基本单位是字节
		
		//public void write(char[] cbuf):写一个字符数组
//		char[] chs = {'a','b','c','d','e'};
//		osw.write(chs);
		
		//public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
//		char[] chs = {'a','b','c','d','e'};
//		osw.write(chs, 1, 3);
		
		//public void write(String str):写一个字符串
//		osw.write("hello");
		
		//public void write(String str,int off,int len):写一个字符串的一部分
		osw.write("hello", 0, 3);
		
//		//void flush():刷新该流的缓冲
//		osw.flush();
//		
//		//释放资源
		osw.close(); //关闭此流,但要先刷新它
	}
}

十一、InputStreamReader读数据的2种方式

===》InputStreamReader读数据方法

  • public int read():一次读取一个字符
  • public int read(char[] cbuf):一次读取一个字符数组
public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
		//创建字符输入流对象
//		InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
		InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriterDemo.java"));
		
		//public int read():一次读取一个字符
//		int ch;
//		while((ch=isr.read())!=-1) {
//			System.out.print((char)ch);
//		}
		
		//public int read(char[] cbuf):一次读取一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=isr.read(chs))!=-1) {
			System.out.print(new String(chs,0,len));
		}
		
		//释放资源
		isr.close();
	}
}

十二、字符流的练习之复制Java文件改进版

把当前项目目录下的StringDemo.java内容复制到当前项目目录下的Copy.java中(改进版)

转换流的名字比较长,而我们常见的操作都是按照本地默认编码实现的,所以,为了简化我们的书写,转换流提供了对应的子类。

  • FileWriter:用来写入字符文件的便捷类:
  •  OutputStreamWriter
    
  • FileReader:用来读取字符文件的便捷类:
  •  InputStreamReader
    

  • OutputStreamWriter = FileOutputStream + 编码表(GBK)
  • FileWriter = FileOutputStream + 编码表(GBK)
  • 构造方法:
  • FileWriter(String fileName)

  • InputStreamReader = FileInputStream + 编码表(GBK)
  • FileReader = FileInputStream + 编码表(GBK)
  • 构造方法:
  • FileReader(String fileName)

  • 数据源:
  •  StringDemo.java---读数据---字符流---InputStreamReader---FileReader
    
  • 目的地:
  •  Copy.java---写数据---字符流---OutputStreamWriter---FileWriter
    
public class CopyJavaTest2 {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileReader fr = new FileReader("StringDemo.java");
		//封装目的地
		FileWriter fw = new FileWriter("Copy.java");
		
		//读写数据
		//一次读写一个字符
//		int ch;
//		while((ch=fr.read())!=-1) {
//			fw.write(ch);
//		}
		
		//一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=fr.read(chs))!=-1) {
			fw.write(chs, 0, len);
		}
		
		//释放资源
		fw.close();
		fr.close();
	}
}

十三、字符缓冲区流的概述和使用【应用】

===》字符缓冲区流:
1、BufferedWriter:

  • 将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。
  • 可以指定缓冲区的大小,或者接受默认的大小。在大多数情况下,默认值就足够大了。
  • 构造方法:
  •  BufferedWriter(Writer out) 
    

2、BufferedReader:

  • 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
  • 可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。
  • 构造方法:
  •  BufferedReader(Reader in) 
    
public class BufferedStreamDemo {
	public static void main(String[] args) throws IOException {
//		//创建字符缓冲输出流对象
//		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
//		//调用写数据的方法
//		bw.write("hello");
//		//释放资源
//		bw.close();
		
		
		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader(new FileReader("BufferedStreamDemo.java"));
		
		//方式1:一次读取一个字符
//		int ch;
//		while((ch=br.read())!=-1) {
//			System.out.print((char)ch);
//		}
		
		//方式2:一次读取一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=br.read(chs))!=-1) {
			System.out.print(new String(chs,0,len));
		}
		
		//释放资源
		br.close();
	}
}

十四、字符缓冲区流的特殊功能【应用】

1、BufferedWriter特殊功能:
void newLine():写入一个行分隔符,这个行分隔符是由系统决定的
2、BufferedReader特殊功能:
String readLine():包含该行内容的字符串,不包含任何行终止符,
如果已到达流末尾,则返回 null

public class BufferedStreamDemo {
	public static void main(String[] args) throws IOException {
//		//创建字符缓冲输出流对象
//		BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
//		
//		//写数据
//		for(int x=0; x<3; x++) {
//			bw.write("hello");
			bw.write("\r\n");
//			bw.newLine();
//			bw.flush();
//		}
//		
//		//释放资源
//		bw.close();
		
		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
		
//		//读取一次
//		String line = br.readLine();
//		System.out.println(line);
//		//在读取一次
//		line = br.readLine();
//		System.out.println(line);
//		line = br.readLine();
//		System.out.println(line);
//		//多读取两次
//		line = br.readLine();
//		System.out.println(line);
//		line = br.readLine();
//		System.out.println(line);
		
		//最终版代码
		String line;
		while((line=br.readLine())!=null) {
			System.out.println(line);
		}
		
		//释放资源
		br.close();
	}
}

十五、字符流的练习之把集合中的学生对象数据存储到文本文件【应用】把ArrayList集合中的学生数据存储到文本文件

每一个学生数据作为文件中的一行数据
===>定义一个学生类。
学生:
学号,姓名,年龄,所在城市
it001,张曼玉,35,北京
it002,王祖贤,33,上海
it003,林青霞,30,西安

===>分析步骤:
A:创建集合对象
B:创建学生对象
C:把学生对象添加到集合中
D:创建字符缓冲输出流对象
E:遍历集合,得到每一个学生对象,然后把该对象的数据拼接成一个指定格式的字符串写到文本文件
F:释放资源

public class ArrayListToFileTest {
	public static void main(String[] args) throws IOException {
		// 创建集合对象
		ArrayList<Student> array = new ArrayList<Student>();

		// 创建学生对象
		Student s1 = new Student("it001", "张曼玉", 35, "北京");
		Student s2 = new Student("it002", "王祖贤", 33, "上海");
		Student s3 = new Student("it003", "林青霞", 30, "西安");

		// 把学生对象添加到集合中
		array.add(s1);
		array.add(s2);
		array.add(s3);

		// 创建字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));

		// 遍历集合,得到每一个学生对象,然后把该对象的数据拼接成一个指定格式的字符串写到文本文件
		for (Student s : array) {
			// it001,张曼玉,35,北京
			StringBuilder sb = new StringBuilder();
			sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",")
					.append(s.getCity());
			bw.write(sb.toString());
			bw.newLine();
			bw.flush();
		}
		
		//释放资源
		bw.close();
	}
}

十六、个人总结

===>学习IO流这块的话,最好是有一套完整的IO流体系框架图,再配上一些案例分析进行大量练习,一定要把所学的知识运用到实践上,这样才能有效地提升自己的技术,我写这篇博文是为了分享给大家,希望大家可以一步一步的构建自己的知识体系,祝大家可以拿到满意的offer!!!

  • 2
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值