Java基础第十四课（I/O）

今天讲一个比较重要的知识就是I/O
Java中I/O操作主要是指使用Java进行输入，输出操作.
Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。
I/O流比较常见的是用来进行读取文件和输出文件的操作

一、字节流和字符流的演示

直接上代码吧
代码上写的注释就已经写的清清楚楚了

package com.baidu.demo.test9;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;

public class Demo1 {

	public static void main(String[] args) {
		
		//声明一个文件对象 括号里的是文件路径
		File f = new File("d:/Demo.txt");
		//调用判断文件是否存在的方法，不存在则自动创建文件
		fileCreate(f);
		System.out.println("==========================");
		//调用字节流的输出
		bSOut(f);
		System.out.println("Hi的ASCII码是：");
		//调用字节流的输入
		bSInput(f);
		System.out.println("===========================");
		//调用字符流的输出
		cSWriter(f, "随便");
		//调用字符流的输入
		cSReader(f);
		
	}
	
	//判断文件是否存在 如果不存在则自动创建
	public static void fileCreate(File f) {
		try {
			//判断文件是否存在
			if (f.exists()) {
				System.out.println("文件存在");
			} else {
				//如果文件不存在则自动创建
				f.createNewFile();
				System.out.println("文件创建成功");
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//以字节流的形式读取文件的所有内容 字节流读取到的内容会以ASCII码对应的十进制数字表示
	public static void bSInput(File f) {
		//声明一个字节输入流 在try外面声明是为了后面的关闭流
		FileInputStream fis = null;
		try {
			//获取到文件的字节输入流
			fis = new FileInputStream(f);
			//声明一个字节数组 字节长度为文件的长度
			byte[] all = new byte[(int)f.length()];
			//获取这个字节流到all字节数组中
			fis.read(all);
			//遍历并打印
			for(byte b : all) {
				System.out.println(b);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				//如果这个流不为空则关闭 下同
				if(fis != null) {
					fis.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
	
	
	//以字节流的形式向文件写入数据 写入时需要对应ASCII码表来写 这里我写入一个“Hi” 对应的ASCII码就是 “72，105” 输出时我们需要用字节数组的形式
	public static void bSOut(File f) {
		//声明一个字节输出流 在try外面声明是为了后面的关闭流
		FileOutputStream fos = null;
		try {
			//获取到文件的字节输出流
			fos = new FileOutputStream(f);
			//声明一个字节数组 数组内容就是要输出的内容
			byte[] all = {72,105};
			//从all字节数组读取到字节输出流中
			fos.write(all);
			System.out.println("文件写出“Hi”");
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				if(fos != null) {
					fos.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}

	
	//字符流和字节流很相似 我就不一一讲解了
	
	//使用字符流读取文件
	public static void cSReader(File f) {
		FileReader fr = null;
		try {
			fr = new FileReader(f);
			char[] all = new char[(int)f.length()];
			fr.read(all);
			for(char c : all) {
				System.out.print(c);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	//使用字符流把字符串写入到文件
	public static void cSWriter(File f,String s) {
		FileWriter fw = null;
		try {
			fw = new FileWriter(f);
			char[] all = s.toCharArray();
			fw.write(all);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				if(fw != null) {
					fw.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		
	}
	
}

运行结果：

上面提到的ASCII（American Standard Code for Information Interchange:美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现今最通用的信息交换标准，并等同于国际标准ISO/IEC 646。
下面是一张ASCII码参考表

二、输入输出缓存流

以介质是硬盘为例，字节流和字符流的弊端：
在每一次读写的时候，都会访问硬盘。 如果读写的频率比较高的时候，其性能表现不佳。
为了解决以上弊端，采用缓存流。
缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。
就好比吃饭，不用缓存就是每吃一口都到锅里去铲。用缓存就是先把饭盛到碗里，碗里的吃完了，再到锅里去铲
缓存流在写入数据的时候，会先把数据写入到缓存区，直到缓存区达到一定的量，才把这些数据，一起写入到硬盘中去。按照这种操作模式，就不会像字节流，字符流那样每写一个字节都访问硬盘，从而减少了IO操作

代码演示：

package com.baidu.demo.test9;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;

import javax.swing.text.AbstractDocument.BranchElement;

public class Demo2 {

	public static void main(String[] args) {
		
		//声明一个文件对象 括号里的是文件路径
		File f = new File("d:/Demo.txt");
		//声明字符输出流
		FileWriter fw = null;
		//声明输入字符流
		FileReader fr = null; 
		//声明输出缓存流
		PrintWriter pw = null;
		//声明输入缓存流
		BufferedReader br = null;
		
		try {
			
			//我们使用输出缓存流的形式写到文件一个字符串
			fw = new FileWriter(f);
			pw = new PrintWriter(fw);
			pw.println("你好");
			//强制把缓存中的数据写入硬盘，无论缓存是否已满
			pw.flush();
			pw.println(true);
			//强制把缓存中的数据写入硬盘，无论缓存是否已满
			pw.flush();
			pw.println(10);
			//强制把缓存中的数据写入硬盘，无论缓存是否已满
			pw.flush();
			System.out.println("写出完毕");
			System.out.println("========================");
			//下面是使用输入缓存流的形式一行行读取文件的字符串
			fr = new FileReader(f);
			br = new BufferedReader(fr);
			//使用while循环进行一行行读取
			while (true) {
				String p = br.readLine();
				//如果读取完了则结束循环
				if(p == null) {
					break;
				}
				System.out.println(p);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//依次关闭流
			try {
				if(br != null) {
					br.close();
				}
				if(fr != null) {
					fr.close();
				}
				if(pw != null) {
					pw.close();
				}
				if(fw != null) {
					fw.close();
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}

	}

}

运行结果：

三、数据流和对象流

使用数据流的readUTF() 和writeUTF()可以进行数据的格式化顺序读写
数据流声明方式

DataInputStream dis =new DataInputStream(fis);

对象流指的是可以直接把一个对象以流的形式传输给其他的介质，比如硬盘
一个对象以流的形式进行传输，叫做序列化。 该对象所对应的类，必须是实现Serializable接口
对象流使用readObject()和writeObject()进行读写
对象流声明方式

ObjectOutputStream oos =new ObjectOutputStream(fos);

由于数据流、对象流的使用方法和缓存流极为相似
我这里就不想一一举例子了 你们自己下去试一下哦

四、关于System. in

System.out 是常用的在控制台输出数据的
System. in 可以从控制台输入数据
这个其实我们之前就用过了
这里再复习一下吧
代码示例：

package com.baidu.demo.test9;

import java.util.Scanner;

public class Demo3 {

	public static void main(String[] args) {
		//获取输入的数字并进行打印
		Scanner s = new Scanner(System.in);
		int a = s.nextInt();
		System.out.println("第一个整数：" + a);
		int b = s.nextInt();
		System.out.println("第二个整数：" + b);

	}

}

运行结果：

---

好啦 I/O流大概就这样吧
今天的代码有点儿多
大家细心点儿看
不懂的还是老样子
联系我QQ497099936
24小时不定时在线回答
欢迎来撩骚
b（￣▽￣）d　
好啦
顾得白