Java IO

Java Io抽象基类

• 字节输入流 inputStream
• 字节输出流：outputStream
• 字符输入流:Reader
• 字符输出流：Writer

字节流(XxxStream):直接处理二进制，一个一个字节的处理，适用于一切数据，包含纯文本，doc，xls,图片，音频，视频等
字符流（XxxReader/ XxxWriter):一个字符一个字符的处理，只能处理纯文本类型。

inputStream

int read():读取一个字节，返回0-255之间整数，失败返回-1
int read(byte[] b)：最多读取b.length个字节，失败返回-1
int read(byte[] b,int offset, int len):从offset处开始，接收len个字节，失败返回-1；
public void close() throws IOException：关闭输入流并释放资源。

outputStream

void write(int b):向输出流输出一个字节。范围0-255
void write(byte[] b):从b字节数组中写入输出流，最多写b.length个字节
void write(byte[], int offset,int len):从指定数组byte[] 中从offset中写入len个数组到输出流
public void flush()throws IOException: 刷新字节流，并强制写出所有缓冲的输出字节
public void close() throws IOException：关闭此输出流并释放资源

Reader

int read():读取单个字符，读取的字符范围在0-65535之间，末尾返回-1
int read(char[] cbuf):将字符读入数组，末尾，返回-1，否则返回本次读取的字符数
int read(char[] cbuf,int offset, int len):从offset处开始，读取len个长度字符，失败返回-1
public void close() throws IOException：关闭输入流并释放资源

Writer

（1）void write(int c)、Writer append(char c)
写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。 即写入0 到 65535 之间的Unicode码。
（2）void write(char[] cbuf)、Writer append(CharSequence csq)
写入字符数组。 
（3）void write(char[] cbuf,int off,int len)、Writer append(CharSequence csq, int start, int end)
写入字符数组的某一部分。从off开始，写入len个字符
（4）void write(String str)
写入字符串。 
（5）void write(String str,int off,int len)
写入字符串的某一部分。
（6）void flush()
刷新该流的缓冲，则立即将它们写入预期目标。
（7）public void close() throws IOException关闭此输出流并释放与该流关联的所有系统资源。

IO流选择流程

• 读或写
• 是否是纯文本
• 写到哪里/从哪里读
• 关闭输入输出流

按行读取文本

/*
 * 按行读取纯文本:
 * BufferedReader 
 * 
 */
public class TestReadLine {
	public static void main(String[] args) {
		BufferedReader bufferedReader = null;
		try {
			 bufferedReader = new BufferedReader(new FileReader("message.txt"));//使用匿名对象进行bufferedReader的初始化
			while(true){
				String string = bufferedReader.readLine();
				if(string == null){
					break;
				}
				System.out.println(string);
			}	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				bufferedReader.close(); //字节流关闭顺序，先关闭外面的，在关闭里面的，有依赖顺序
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
}

try…with…resource

 语法格式:
 try(资源对象的初始化){
 }
 catch(exception){
 }//不在需要finaly中关闭资源，资源自动关闭

复制文件①

既要读还要写
读:Inputstream 和Reader
写：OutputStream 和Writer
从哪里读写到哪里：从src写到dest

public class TestCopyFile {
	public static void main(String[] args) {
		try {
			long start = System.currentTimeMillis();
			copyFile(new File("D:/java/JDK/jdk-8u141-windows-i586.exe"), new File("D:/1.zip")); //dest注意是一个文件，不能是一个路径
			long end = System.currentTimeMillis();
			System.out.println("复制成功:"+(end-start));
			
		} catch (IOException e) {
			System.out.println("复制失败");
			e.printStackTrace();
		}
	}
	public static void copyFile(File src, File dest) throws IOException{
		FileInputStream fInputStream = new FileInputStream(src);//FileInputStream对应src
		FileOutputStream fOutputStream =new FileOutputStream(dest);//FileOutPutStream对应dest
		byte[] data = new byte[1024];
		while(true){
			int len = fInputStream.read(data);
			if(len == -1){
				break;
			}
			fOutputStream.write(data, 0, len);
		}
		fInputStream.close();
		fOutputStream.close();
	}
}

复制文件②

效率相对于①来说，更加迅速，使用了bufferedInputStream和BufferedOutputStream
/*
 * 对复制速度有要求，所以使用缓存IO流：
 * BufferedInputStream
 * BufferedOutputStream
 * 
 */
public class TestCopyFileFast {
	public static void main(String[] args) {
		try {
			long start = System.currentTimeMillis();
			copyFile(new File("D:/java/JDK/jdk-8u141-windows-i586.exe"), new File("D:/1.zip")); //dest注意是一个文件，不能是一个路径
			long end = System.currentTimeMillis();
			System.out.println("复制成功:"+(end-start));
			
		} catch (IOException e) {
			System.out.println("复制失败");
			e.printStackTrace();
		}
	}
	public static void copyFile(File src, File dest) throws IOException{
		BufferedInputStream fInputStream = new BufferedInputStream(new FileInputStream(src));//FileInputStream对应src
		BufferedOutputStream fOutputStream =new BufferedOutputStream(new FileOutputStream(dest));//FileOutPutStream对应dest
		byte[] data = new byte[1024]; //搬运数据的容器
		while(true){
			int len = fInputStream.read(data);
			if(len == -1){
				break;
			}
			fOutputStream.write(data, 0, len);
		}
		fInputStream.close();
		fOutputStream.close();
	}
}

输入数据并解码

//解码
//InputStreamReader作用：把一个字节流 解码成 一个 字符流
public class TestDecode {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("utf-8.txt");
		InputStreamReader isr = new InputStreamReader(fis,"utf-8");
		BufferedReader br = new BufferedReader(isr);
		
		while(true){
			String line = br.readLine();
			if(line == null){
				break;
			}
			System.out.println(line);
		}
		br.close();
		isr.close();
		fis.close();
	}
}

编码

/*
 * OutputStreamWriter:把字符流转成字节流，可以指定编码方式
 * 
 */
public interface TestEncode {
	public static void main(String[] args) throws IOException {
		Scanner input = new Scanner(System.in);
		FileOutputStream fos = new FileOutputStream("utf-8.txt");
		OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
		while (true) {
			System.out.println("请输入");
			String string=  input.nextLine();
			osw.write(string+"\r\n");
			System.out.println("是否继续(y/n)");
			char confirm = input.nextLine().charAt(0);
			if(confirm == 'n' || confirm == 'N'){
				break;
			}
		}
		osw.close();
		fos.close();
		input.close();
	}
}

保存对象

DataOutputStream

序列化与反序列化

ObjectOutputStream 可以将对象输出，使用writeObject(obj)

反序列化，借助ObjectInputStream,使用readObject()方法可以读取对象

序列化条件

1. 实现java.io.Serializable接口
2. 引用数据类型的的属性也要实现序列化，否则会报异常
3. 子类对象序列化时，涉及到父类的属性，父类没有实现java.io.Serializable接口，父类必须包含无参构造。

那些属性不能序列化

1. static属性
2. transient 标记的属性

序列化版本ID

实现java.io.Serializable接口时，增加一个Long类型的静态常量

private static final long serialVersionUID =1L;