IO流

你若不想做，会找一个或无数个借口；你若想做，会想一个或无数个办法

本讲内容：文件流

     

一、File类（没有读写能力）

File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问
重要方法：
exists(): 判断文件/文件夹是否存在
delete():删除文件/文件夹
mkdir():创建文件夹
createNewFile():创建文件
separator():设置分隔符
isDirectory():是否是一个目录(文件夹)，如果是目录返回true，如果不是目录or目录不存在返回false。
isFile():是否是一个文件
getAbsolutePath():获取绝对路径(E:\java\imooc)
getName():获取目录最后的名字（imooc）
getParent():获取父目录（E:\java）

二、RandomAccessFile类

RandomAccessFile 是java提供的对文件内容的访问，既可以读文件，也可以写文件。

三、IO流（输入流，输出流）

输入流：数据在文件到程序（内存）的路径

输出流：数据从程序（内存）到文件的路径

即：以内存为参照，如果数据向内存流动，则是输入流，反之是输出流。

1、字节流
InputStream：OutputStream这俩个是抽象类，这俩个子类分别为FileInputStream、FileOutputStream实现类
InputStream ： 抽象了应用程序读取数据的方式
OutputStream：抽象了应用程序写出数据的方式

FileInputStream：具体实现了在文件上的读取数据

FileOutputStream：具体实现了向文件中写出byte数据的方法
输入流常用方法：
int b=in.read();读取一个字节无符号填充到int低八位。读到-1就读到结尾了。
in.read(byte[] buf);读取数据到字节数组buf
in.read(byte[] buf,int start,int size);读取数据到字节数组buf里，从buf的start位置开始存放size长度的数据。
输出流常用方法
out.write(int b)写出一个byte到流，b的低8柆
out.write(byte[] buf)将buf字节数组写入到流
out.write(byte[] buf,int start,int size)

四、扩展

1、DataInputStream/DataOutputStream对流功能的扩展，可以更加方便地读取int,long,字符等类型数据
writeInt()/writeDouble()/writeUTF()

2、BufferedInputStream/BufferedOutputStream
这俩个流类提供了带缓冲区的操作，一般打开文件进入写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
FileOutputStream:write()方法相当于一滴一滴地把水转移到缸中（一个字节一个字节转移）
DataInputStream：writeXxx()方法相当于一瓢一瓢把水转移到缸中（int 四个字节转移过去）
BufferedOutputStream：write()方法相当于一瓢一瓢先放入桶中（缓冲区）,现从桶中倒入到另一个缸中。

五、字符流

Reader 与InputStream类似都是抽象类

Writer 与OutputStream类似都是抽象类

InputStreamReader   完成byte流解析为char流,按照编码解析
OutputStreamWriter  提供char流到byte流，按照编码处理  

FileReader :FileReader继承了InputStreamReader，但并没有实现父类中带字符集参数的构造函数。所以FileReader只能按系统默认的字符集来解码

FileWriter :同上

 字符流的过滤器
 BufferedReader   ---->readLine 一次读一行
 BufferedWriter/PrintWriter   ---->写一行   

六、对象的序列化，反序列化

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。
1)对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化 
2)序列化流(ObjectOutputStream)是过滤流----writeObject()方法
   反序列化流(ObjectInputStream)---readObject()方法
3)序列化接口(Serializable)
   对象必须实现序列化接口 ，才能进行序列化，否则将出现异常，这个接口，没有任何方法，只是一个标准

transient :关键字

private transient int age;  //该元素不会进行jvm默认的序列化,也可以自己完成这个元素的序列化

注意：

Flush（） 是清空缓冲区数据，就是说你用读写流的时候，其实数据是先被读到了内存中，然后用数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了 Close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先Flush()，先清空数据。

示例一：FileInputStream类的使用    把文件读入到计算机内存中

public class FileDemo {
	public static void main(String[] args) {
		//创建一个文件对象  
		File file=new File("D:\\a.txt");
		
		FileInputStream in=null;
		try {
			in=new FileInputStream(file);
			byte[] buf=new byte[8*1024];
			int n=0;//读取的第几个字节  
			//从in中批量读取字节，放入buf字节数组中，从第0个位置开始放，最多放buf.length个，返回的是读到的字节的个数
			 while((n=in.read(buf,0,buf.length))!=-1){  
				//把字节数组中的内容转换成字符串  
                String s=new String(buf,0,n);  
                //输出字符串中的内容  
                System.out.println(s); 
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try { //关闭文件流
				in.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
}

打印：

hello 你好！

示例 二：FileOutputStream类的使用    从计算机内存输出到文件中

public class FileDemo {
	public static void main(String[] args) {
		File file=new File("D:\\b.txt");
		
		FileOutputStream out=null;
		if(!file.exists()){
			try {
				out = new FileOutputStream(file);
				String s1 = "hello 阳西一中！\r\n";
				String s2 = "hello 溪坎中学！";
				
				out.write(s1.getBytes());
				out.write(s2.getBytes());
			} catch (Exception e) {
				e.printStackTrace();
			}finally{
				try {
					out.close();
				} catch (Exception e2) {
					e2.printStackTrace();
				}
			}
		}else{
			 System.out.println("文件已经存在");  
		}
	}
}

示例三： 文件的拷贝（ d:/a.txt向f:aa.txt拷贝）

public class FileDemo {
	public static void main(String[] args) {
		BufferedReader br=null;
		BufferedWriter bw=null;
		
		try {
			FileReader fr=new FileReader("d:/a.txt");
			br=new BufferedReader(fr);//不能简写（不能直接写"e:aa.txt"） 
			
			//创建FileWriter对象  
            FileWriter fw=new FileWriter("f:/aa.txt");  
            bw=new BufferedWriter(fw);  
            //循环读取文件  
            String s="";  
            //包含该行内容的字符串，不包含任何终止符，如果已到达流末尾，则返回null  
            while((s=br.readLine())!=null){  
                bw.write(s+"\r\n");  
            }  
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				br.close();//后开先关闭  
                bw.close(); 
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
}

示例四：

public class Student implements Serializable{
	private int age;
	private String name;

	public Student() {
	}

	public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}

}

public class FileDemo {
	public static void main(String[] args) throws Exception{
		String file="D:/d.txt";
		//1.对象的序列化
		/*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));
		Student stu = new Student(2, "张三");
		oos.writeObject(stu);
		oos.flush();
		oos.close();*/
		
		//1.对象的反序列化
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
		Student stu = (Student)ois.readObject();
		System.out.println(stu);
		ois.close();
	}
}

打印：

Student [age=2, name=张三]