Java - IO输入输出流

Ps：流就是指一连串流动的字符，以先进先出的方式发送信息的通道。

Ps：文件输入——读、文件输出——写。

package com.imooc.file;

import java.io.File;
import java.io.IOException;

public class FileDemo {

	public static void main(String[] args) {
		// 创建 File 对象
		File file1=new File("c:\\imooc\\io\\score.txt"); // 方法1
		File file2=new File("c:\\imooc","io\\score.txt"); // 方法2
		File file3=new File("c:\\imooc"); // 方法3
		File file4=new File(file3,"c:\\imooc");
		
		// 判断是文件 or 目录，返回 false 的两种情况：
		// 1、字面意思，非我族类
		// 2、路径不存在
		System.out.println("is 目录："+file4.isDirectory());
		System.out.println("is 文件："+file4.isFile());
		
		// 创建目录
		File file5=new File("c:\\imooc\\set\\HashSet");
		File file6=new File("c:\\imooc\\set\\HashSet\\asd.txt");
		if(!file5.exists()) 
		{
//			file5.mkdir(); // 失败，只能创建单级目录
			file5.mkdirs(); // 可创建多级目录
			file6.mkdirs(); // asd.txt 是目录不是文件
		}
		
		// 创建文件
		File file7=new File("c:\\imooc\\set\\HashSet\\abc");
		if(!file7.exists())
		{
			try {
				file7.createNewFile(); // abc 是一个无后缀名的文件
			} 
			catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Ps：Windows目录“\\”（因为“\”转义字符，所以多加一个）；Linux目录“/”即可。

Ps：主要关注文件、缓冲、对象 IO流。

// 文件内容：Hello,imooc!

public class FileInputDemo1 {

	public static void main(String[] args) {
		// 创建一个FileInputStream对象
		try {
			FileInputStream fis=new FileInputStream("imooc.txt");
			// 常规写
//			int n=fis.read();
//			while(n!=-1){
//				System.out.print((char)n);
//				n=fis.read();
//			}
			
			// 简写
			int n=0;
			while((n=fis.read())!=-1){
				System.out.print((char)n);
			}
			
			fis.close();
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		} 
		catch(IOException e){
			e.printStackTrace();
		}
	}
}

public class FileInputDemo2 {

	public static void main(String[] args) {
		// 创建一个FileInputStream对象
		try {
			FileInputStream fis = new FileInputStream("imooc.txt");
			byte[] b=new byte[100];
			fis.read(b,0,5); // 从下标为0位置开始存储，一共存储5个字符
			System.out.println(new String(b)); // Hello
			fis.close();
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
	}
}

public class FileOutputDemo {

	public static void main(String[] args) {
		FileOutputStream fos;
		FileInputStream fis;
		try {
			fos = new FileOutputStream("imooc.txt",true); // 第二参数，是否追加，默认为重新覆盖
			fis = new FileInputStream("imooc.txt");
			// 可能有编码问题，但是不影响写入读取的最终结果
			fos.write(50); // 每次写一个字节
			fos.write('a');
			System.out.println(fis.read()); // 每次读一个字节
			System.out.println((char)fis.read());
			fos.close();
			fis.close();
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
	}
}

/* 图片Copy */
public class FileOutputDemo1 {

	public static void main(String[] args) {
		// 文件拷贝
		try {
			FileInputStream fis=new FileInputStream("happy.gif");
			FileOutputStream fos=new FileOutputStream("happycopy.gif");
			
			int n=0;
			byte[] b=new byte[1024];
			while((n=fis.read(b))!=-1){
//				fos.write(b); // 之前都会填充满，最后一次会在实际大小中增加了 （1024 - 最后一次实际内容） 的大小，所以可能会比原先大个 1 KB
				fos.write(b,0,n); // 第三个参数 n 代表：实际大小，这样就不会造成空间的浪费
			}
			fis.close();
			fos.close();
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		catch(IOException e){
			e.printStackTrace();
		}
	}
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedDemo {

	public static void main(String[] args) {
		try {
			FileOutputStream fos=new FileOutputStream("imooc.txt");
			BufferedOutputStream bos=new BufferedOutputStream(fos);
			FileInputStream fis=new FileInputStream("imooc.txt");
			BufferedInputStream bis=new BufferedInputStream(fis);
			
			// 测试使用BufferedIO效率更高
			long startTime=System.currentTimeMillis();
			
			bos.write(50);
			bos.write('a');
			bos.flush();
			
			System.out.println(bis.read());
			System.out.println((char)bis.read());
			long endTime=System.currentTimeMillis();
			System.out.println(endTime-startTime);
			
			fos.close();
			bos.close();
			fis.close();
			bis.close();
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Ps1：如果是边读边写，就会很慢，也伤硬盘。缓冲区就是内存里的一块区域，把数据先存内存里，然后一次性写入，类似数据库的批量操作，这样效率比较高。

Ps2：flush() 和 close() 都可以对写入缓冲（内存）的数据写进硬盘，如果没这两个方法，或者也没达到缓冲区满（满了不用 flush 也会自动进硬盘的），那么硬盘上的数据还是没有的。

缓冲字符流

/* 字节字符转换流 + 缓冲区 */
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

	public static void main(String[] args) {
		try {
			FileInputStream fis=new FileInputStream("imooc.txt");
			InputStreamReader isr=new InputStreamReader(fis,"GBK"); // 不写编码方式，默认为IDE的编码；用什么编码方式读取，下面就对应用什么编码方式写入
			BufferedReader br=new BufferedReader(isr);
			FileOutputStream fos=new FileOutputStream("imooc1.txt");
			OutputStreamWriter osw=new OutputStreamWriter(fos,"GBK");
			BufferedWriter bw=new BufferedWriter(osw);
			
			int n=0;
			char[] cbuf=new char[10];
			
//		    while((n=isr.read())!=-1){ // 这里的 n 代表实际内容
//		    	   System.out.print((char)n);
//		    }
			
//			while((n=isr.read(cbuf))!=-1){ // 这里的 n 代表实际内容大小
//				String s=new String(cbuf,0,n);
//				System.out.print(s);
//			}
			
			while((n=br.read(cbuf))!=-1){
				//String s=new String(cbuf,0,n);
				bw.write(cbuf, 0, n);
			}
			bw.flush();
			
			// 注意关闭顺序
			br.close();
			bw.close();
			isr.close();
			osw.close();
			fis.close();
			fos.close();
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Ps：FileInputStream + InputStreamReader == FileReader，依此类推。

• 序列化：把Java对象转换为字节序列的过程。
• 反序列化：把字节序列恢复为Java对象的过程。

import java.io.Serializable;

public class Goods implements Serializable{
	private String goodsId;
	private String goodsName;
	private double price;
	
	public Goods(String goodsId,String goodsName,double price){
		this.goodsId=goodsId;
		this.goodsName=goodsName;
		this.price=price;
	}
	// getters/setters...
	
	@Override
	public String toString() {
		return "商品信息 [编号：" + goodsId + ", 名称：" + goodsName 
				+ ", 价格：" + price + "]";
	}
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class GoodsTest {

	public static void main(String[] args) {
		// 定义Goods类的对象
		Goods goods1 = new Goods("gd001", "电脑", 3000);
		try {
			FileOutputStream fos = new FileOutputStream("imooc.txt"); 
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			FileInputStream fis = new FileInputStream("imooc.txt");
			ObjectInputStream ois = new ObjectInputStream(fis);
			
			// 将Goods对象信息写入文件，如果文件里面是乱码不要紧，只要读出来显示正常即可
			oos.writeObject(goods1);
			oos.writeBoolean(true);
			oos.flush();
			
			// 读对象信息
			// 注意：读顺序和写顺序符合先进先出规则，如果把readBoolean方法放首先会RE，因为第一个是对象而不是boolean
			Goods goods = (Goods) ois.readObject();
			System.out.println(goods);
			System.out.println(ois.readBoolean());

			fos.close();
			oos.close();
			fis.close();
			ois.close();
		} 
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
	}
}

• 序列化时，只对对象的状态进行保存，而不管对象的方法；
• 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
• 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
• 并非所有的对象都可以序列化，至于为什么不可以，有很多原因。