JavaIO的常用方法

使用io的目的是想要 读写文件内部的内容，读写的方案就是流，既创建管道，让数据以流动的形式，先入先出的方式进行传输；
数据从数据源流向目的地；
java提供了IO包供用户使用；
流的分类
流向分: (以程序为中心)
输入流
输出流
操作单元分:
字节流:任何数据都可以传输
字符流: 文本
功能分:
节点流: 操作基本功能的,实现读入写出的,数据从数据源头到目的地的
功能流: 增强功能,提高性能,操作与节点流之上的
节点流:
1.字节流 :任意类型的数据都能读写
字节输入流 InputStream
字节输出流 OutputSream
字节输入流的方法：

字节输出流的方法：

字节输入流 InputStream例：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class IODemo01 {
	public static void main(String[] args) throws IOException {
		//1.建立联系		
		File file=new File("D:/haha.txt");
		//2.选择流 
		//FileInputStream is=new FileInputStream(file);
		FileInputStream is=new FileInputStream("D:/haha.txt");
		//3.读 
		//read() 读取一个字节数据 返回读取到的字节数|没读到的-1
		int num=is.read();
		System.out.println((char)num);
		int num2=is.read();
		System.out.println((char)num2);
		int num3=is.read();
		System.out.println((char)num3);		
		System.out.println(is.read());
		//4.关闭
		is.close();
	}
}

字节输出流 OutputSream例：

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class IODemo04 {
	public static void main(String[] args) throws IOException {
		//注意:目标文件如果不存在,系统会自动为你创建,但是目录不会
		//1.选择流  boolean append ->true追加  ,false->不追加覆盖
		OutputStream os=new FileOutputStream("D:/lalala.txt",true);
		//2.写出
		byte[] str="不吃饭修仙哈哈哈".getBytes();
//		os.write(str);
		os.write(str,0,3);
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
	}
}

使用字节流实现输入输出的时候，我们就可以实现文件的拷贝，将文件转换为字节的形式然后以字节的形式读取出来，实现文件的还原
字节流文件拷贝：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;



public class CopyUtils {
	public static void main(String[] args) {
		copyFile("D:/haha.txt","D:/hehe.txt");
	}
	 
	//文件拷贝方法的重载用来接收字符串形式的文件绝对路径
	public static void copyFile(String src,String dest){
		copyFile(new File(src),new File(dest));
	}
	
        //文件的拷贝  返回值:没有      参数:数据源路径  目的地路径
	public static void copyFile(File src,File dest){
		//1.选择流
		InputStream is = null;
		OutputStream os= null;
		try {
			is = new FileInputStream(src);
			os= new FileOutputStream(dest);
			//2.读写
			byte[] car= new byte[1024];
			int len = -1; //读入到数组中的字节个数
			while((len=is.read(car))!=-1){
				os.write(car, 0, len);
			}
			//3.刷出
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			//4.后打开的先关闭
			try {
				if(os!=null){
					os.close();
				}
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}		
	}
}

2.字符流 :只度写纯文本
字符输入流： Reader FileReader
字符输出流： Writer FileWriter
例：

public class CharIO01 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		Reader rd=new FileReader("D:/haha.txt");
		Writer rt=new FileWriter("D:/cc.txt");
		//2.读写
		char[] car=new char[1024];
		int len=-1; //存储数据的个数
		
		while((len=rd.read(car))!=-1){
			rt.write(car, 0, len);
		}
		//3.刷出
		rt.flush();
		//4.关闭
		rt.close();
		rd.close();
	}
}

功能流:作用与节点流
3.缓冲流:增加功能,提高性能,提高读写效率
字节缓冲输入流：BufferedInputStream
字节缓冲输出流：BufferedOutputStream
字符缓冲输入流：BufferedReader
字符缓冲输出流：BufferedWriter
字节缓冲输入流：BufferedInputStream
方法：

字节缓冲输出流：BufferedOutputStream
方法：

例：

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

public class BufferedDemo01 {
	public static void main(String[] args) throws IOException {
		//1.流
		InputStream is = new BufferedInputStream(new FileInputStream("D:/haha.txt"));
		OutputStream os=new BufferedOutputStream( new FileOutputStream("D:/dd.txt"));
		//2.读写
		byte[] car = new byte[1024];
		int len=-1;
		while(-1!=(len=is.read(car))){
			os.write(car,0,len);
		}
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
		is.close();
	}

}

字符缓冲输入流：BufferedReader
方法：

字符缓冲输出流：BufferedWriter
方法：

例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedDemo02 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		BufferedReader rd=new BufferedReader(new FileReader("D:/haha.txt"));
		BufferedWriter rt=new BufferedWriter(new FileWriter("D:/aaa.txt"));
		//2.读入
		String msg=null;
		while((msg = rd.readLine())!=null){
			rt.write(msg);
			rt.newLine(); //换行
		}
		//3.刷出
		rt.flush();
		//4.关闭
		rt.close();
		rd.close();
	}
}

4.转换流:字节转字符

字节转换字符输入流：InputStreamReader
字节转换字符输出流：OutputStreamWriter
字节转换字符输入流：InputStreamReader
方法：

字节转换字符输出流：OutputStreamWriter
方法：

例：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
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;
import java.io.Reader;


public class ChangeDemo02 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		BufferedReader rd=new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream("D:/haha.txt"))));
		BufferedWriter rt=new BufferedWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream("D:/bbb.txt"))));
		String msg=null;
		//2.读入写出
		while((msg=rd.readLine())!=null){
			rt.write(msg);
			rt.newLine();
		}
		//3.刷出
		rt.flush();
		//4.关闭
		rt.close();
	}
}

5.Data流:基本数据类型|String+数据 ：数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型
DataInputStream
DataOutputStream
实例：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 基本数据类型流:字节流的功能流
 * 	读写带有基本数据类型|字符串类型的数据
 *  DataInputStream 
 *  	新增方法: ReadXxx()
 *  DataOutputStream
 *  	新增方法: writeXxx()
 *  	不能发生多态
 */
public class DataDemo03 {
	public static void main(String[] args) throws IOException {
		write("D:/eee.txt");
		read("D:/eee.txt");
	}
	//写入
	public static void read(String src) throws IOException{
		//1.输入流
		DataInputStream in=new DataInputStream(new FileInputStream(src));
		//2.读入  读入和写出的顺序要保持一致
		boolean b=in.readBoolean();
		int i=in.readInt();
		String s=in.readUTF(); 
		System.out.println(b+"-->"+i+"-->"+s);
		//3.关闭
		in.close();
	}
	
	//写出
	public static void write(String dest) throws IOException{
		//1.输出流
		DataOutputStream out=new DataOutputStream(new FileOutputStream(dest));
		//2.准备数据
		boolean flag=false;
		int i=100;
		String s="哈哈";
		//3.写出
		out.writeBoolean(flag);
		out.writeInt(i);
		out.writeUTF(s);
		//4.刷出
		out.flush();
		//5.关闭
		out.close();
	}
}

6.对象流:任意类型,包括对象+数据：一个ObjectInputStream反序列化的原始数据和对象之前使用一个ObjectOutputStream写的
ObjectInputStream
ObjectOutputStream
对象流:数据+数据类型
序列化和反序列化:序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程
序列化输出流 : ObjectOutputStream
反序列化输入流: ObjectInputStream
先序列化后反序列化
不是所有的类都能序列化 实现java.io.Serializable接口
不是所有的属性都需要序列化 transient
静态的内容不能序列化
如果父类有实现序列化,子类没有,子类中所有的内容都能序列化
如果父类中没有实现序列化,子类有实现序列化,子类只能序列化自己的内容
实例：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;

public class ObjectDemo04 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		write();
		read();
	}
	//序列化输出
		public static void read() throws FileNotFoundException, IOException, ClassNotFoundException{
			//1.流
			ObjectInputStream is=new ObjectInputStream(new FileInputStream("D:/object.txt"));
			//2.读入写出读入的顺序保持一致
			Object p=is.readObject();
			System.out.println(p);
			if(p instanceof Person){
				Person p1=(Person)p;
				System.out.println(p1);
			}
			System.out.println(Arrays.toString((int[])is.readObject()));
			//3.关闭
			is.close();
		}
	//序列化输出
	public static void write() throws FileNotFoundException, IOException{
		//1.流
		ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("D:/object.txt"));
		//2.写出
		Person p=new Person("lisi",20);
		int[] arr=new int[]{1,2,3,4,5};
		//写出读入的顺序保持一致
		out.writeObject(p);
		out.writeObject(arr);
		//3.刷出
		out.flush();
		//4.关闭
		out.close();
		
		p.setAge(100);
		p.setName("王五");
	}
}

class Person implements Serializable{
	private String name;
//	private transient int age;
	private static int age;
	
	public Person() {
		// TODO Auto-generated constructor stub
	}

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

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

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