io流

字节流、

字节流的读取：
1.读取到缓冲区的总字节数，如果没有更多的数据，因为已经达到流末尾，那么返回-1，
2.有两种方案可以给地址，2.1：通过File给地址， 2.2采用字符串形式直接给地址；
如果是File对象，那可以在转换为流之前可以做相关的处理（增删改查）；
一个字母占一个字节，一个中文占两个字节

public static void InputStreamMethod(){
	//通过File 给地址
	File file = new File(f:/io.txt);
	InputStream is = new FileInputStream(file);
	//以字符串的形式给地址
	//也可以InputStream is = new FileInputStream(f:/io.txt);
	int temp = 0; //声明一个变量接收，不然循环重复调用read方法
	while((temp = is.read()) !=-1){//使用 read方法查看内容
		System.out.println((char)temp); //接收的是个int类型 可以强转为char类型
	}
	//流关闭
	is.close();
}
如果出现有中文的话可以使用缓冲区
//定义一个缓冲区,现将内容读取在缓冲区中
	byte []bcuf = new byte[1024];//一般使用1024字节
//is.available();拿到整个文档的大小 ， 种方法不合适byte []bcuf = new byte[is.available()];
	while(is.read(bcuf) != -1) {
		System.out.println(new String(bcuf));
}

字符流、

字符流的写：
给地址的方式同字节流相同

public static void WriterMethod(){
	//指定位置包装字符流对象，后面加true 是跟着内容后面接着写，否则是重写
	Writer writer = new FileWriter("f:/io.txt",true);
	//调用writer方法写
	writer.writer("hello");
	Writer.writer(1234);
	//写完之后需要调用flush刷新，
	writer.flush();
	//流关闭
	writer.close();
}

字符流的读取：

//单个字符的读取
public static void readMethod(){
	//指定位置包装字符流对象，
	Read read = new FileRead("f:/io.txt");
	int temp =0;//创建变量接收
	while((temp = read.read()) != -1) {
		//默认为int类型 需要强转为字符
		System.out.println((char)temp);
	}
	read.close();
}
----------------------------------------------------------
//使用缓冲池读取：使用字符数组作为缓冲池进行读取时，会出现显示多余或不完整的情况！！！
	char [] ar = new char[3];
	while(read.read(ar)!=-1) {
		System.out.println(ar);
	}

字符串缓冲池

String是一个字符串对象，是一个常量
StringBuilder(线程不安全) StringBuffer（线程安全）
两个缓冲池只有在是否安全上有区别，其他的都一样

---

String、StringBuilder、StringBuffer之间的区别；
String修饰的是常量，StringBuilder和StringBuffer修饰的是变量，
StringBuilder是线程不安全的（效率比Stringbuffer高），Stringbuffer是线程安全的（安全性比StringBuilder高），

字符串缓冲池；
StringBuilder sb = new StringBuilder();
char[]cr = new char[2];
while(read.read()!=-1){
	sb.append(cr); //append方法将参数附加到次序列中
}
System.out.println(sb);

字符流缓冲对象

1、字符流缓冲对象读取：

public static void bufferedReadMethod(){
	//创建字符流读取对象
	Reader read = new FileReader("F:/io.txt");//文件路径
	//创建字符流缓冲对象-需要字符流读对象
	BufferedReader br = new BuffeedReader(read);
	String result = null;
	whlie((result = br.readLine())!=null){ //按行读取
		System.out.println(result);
	}
	//关闭流对象 倒着关
	br.close();
	read.closer();
}

2、字符流写对象：

public static void bufferedWriterMethod(){
	//创建字符流写的对象
	Writer writer = new Writer("E:/io.txt");
	//创建字符流写的对象 -需要字符流写对象
	BufferedWriter bw = new bufferedWriter(writer);
	bw.writer("hellow");
	bw.close();
	writer.close();
}

流写、读取对象：
持久化存储：将数据进行本地存储，可以多次使用
默认序列化机制只能写入类/类签名、非瞬态及非静态字段
写对象：ObjectOutputStream，
读对象：ObjectInputStreatm，
需要实现 Serializable接口
实现Serializable的过程为序列化，进行读取的过程为反序列化
Serializable接口在进行写的过程中虚拟机会随机生成一个序列化版本号用于唯一标识，当类中内容发生了改变时，再进行自写入时序列化版本号也会重新生成，
想避免以上问题，让序列号一致即可（手动添加一个）；
private static final long serialVersionUID = 1L;
写对象：

public static void writerMethod(){
	//指定写入地址， 在进行写对象的时候，文件通常是以.Object为结尾的
	File file = new file("F:io.txt");//.txt方便查看，通常为.Object
	//创建一个用于写的流对象；
	OutputStream os = new FileOotputStream(file);
	//创建写对象的流
	ObjectOutputStream oos = new ObjectOutputStream(os);
	//创建储存的对象
	Shop shop = new shop("鞋子",150);
	//写对象
	oos.writeObject(shop);
	//关闭流
	oss.close();
	os.close();
}

读对象：

public static void readerMethod(){
	File file = new file("F:io.txt");
	InputStream is = new InputStream(file);
	ObjectInputStream ois = new ObjectInputStream(is);
	//读对象
	Object object = ois.readObject();
	Shop shop = (Shop)object; //类型为Object 需要强转
		try {
		Object obj = null;
		while((obj=ois.readObject())!=null) {
			System.out.println((Item)obj);
		}
	//EOFException 当读取到文件或流的末尾时抛出该异常
	}catch(EOFException e) {
		System.out.println("读取完毕");
	} finally {
		//关闭流
		ois.close();
		is.close();
		}
	//当需要循环输出的话 需要使用 try，catch方法捕捉异常
}

流转换

InputStreamReader 字节流转字符流
OutputStreamWriter 字符流转字节流

//拿到控制台的输入流对象
InputStream is = System.in
//将字节流对象转换为字符流对象进行读取操作
InputStreamReader isr = new InputStreamReader(is);
//使用字符缓冲流对象按行读取
BufferedReader br = new BufferedReader(isr);
//从控制台进行读取操作
String content = br.readLine();
//将读取的结果输出到控制台
OutputStreamWriter osw = new OutputStreamWriter(content);
while(true){
	String content = br.readLine();
	if("over".equals(content)){//当输入over时结束循环
	break;
	}
	osw.write(content);
	osw.flush();//加上刷新
}

//关闭流
osw.close();
os.close();
br.close();
isr.close();
is.close();