IO流

IO流

一、字符流

只能操作纯文本的数据。本质其实就是基于字节流读取时，去查找指定的码表

方法有：

• read();//读取单个字符。
• close();//关闭该流并释放与之关联的所有资源。
• flush();//

• char[] car=new char[1024];
  int len=-1; //存储读取到数组中的数据个数
  while((len=read.read(car))!=-1){
  	write.write(car, 0, len);
  }
  //3.刷出
  write.flush();
  //4.关闭
  write.close();
  read.close();
  

  1)字符输入流

  • Reader用于读取字符流的抽象类
  • FileReader 用来读取字符文件的便捷类。

  Reader read=new FileReader("D:/hehe.txt");
  

  2)字符输出流

  • Writer写入字符流的抽象类。
  • FileWriter 用来写入字符文件的便捷类。

  Writer write=new FileWriter("D:/hengheng.txt",true);
  

  二、缓冲流

• 作用：提高性能
• 用法：缓冲流（节点流）

• 1)字节缓冲流

• BufferedInputStream
• BufferedOutputStream
• 没有新增方法,可以多态调用

• 案例

  public class BufferedInputStream02 {
  	public static void main(String[] args) {
  		//1.选择流
  		InputStream is=null;
  		OutputStream os=null;
  		
  		try {
  			is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
  			os=new BufferedOutputStream(new FileOutputStream("D:/H.txt"));
  			//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) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		} catch (IOException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		} finally{
  			try {
  				if(os!=null){
  					os.close();
  				}
  				if(is!=null){
  					is.close();
  				}
  			} catch (IOException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
  	}
  }
  

  1)字符缓冲流

• BufferedReader
• BufferedWriter
• 新增方法：readLine(),newLine() 不可以多态调用

• 案例

  public class BufferedReader03 {
  	public static void main(String[] args) {
  		//1.选择流
  		BufferedReader is=null;
  		BufferedWriter os=null;
  		
  		try {
  			is=new BufferedReader(new FileReader("D:/hehe.txt"));
  			os=new BufferedWriter(new FileWriter("D:/B.txt"));
  			//2.读入写出
  			 /*char[] car=new char[1024];
  			 int len=-1;
  			 while((len=is.read(car))!=-1){
  				 os.write(car, 0, len);
  			 }*/
  			
  			//新增方法,每次读取一行
  			String str=null;
  			while((str=is.readLine())!=null){
  				os.write(str);
  				os.newLine();
  			}
  			 //3.刷出
  			 os.flush();
  		} catch (FileNotFoundException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		} catch (IOException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		} finally{
  			try {
  				if(os!=null){
  					os.close();
  				}
  				if(is!=null){
  					is.close();
  				}
  			} catch (IOException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
  	}
  }
  

  三、转换流

• 字节流-->字符流
• InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符
• 字符流-->字节流
• OutputStreamWriter是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节

• 案例

  public class ConvertDemo04 {
  	public static void main(String[] args) throws IOException {
  		//1.选择流
  		BufferedReader rs= new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream("D:/hehe.txt"))));
  		BufferedWriter rw=new BufferedWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream("D:/D.txt"))));
  		//2.选择流
  		String str=null;
  		while((str=rs.readLine())!=null){
  			rw.append(str);
  		}
  		//3.刷出
  		rw.flush();
  		//4.关闭
  		rw.close();
  		rs.close();
  	}
  }
  

  四、基本数据类型流(基本数据类型+字符串类型的数据)

  是字节流的一个功能流

• DataInputStream:定义用来从输入流读取基本数据类型的方法，以便解组自定义值类型
• DataOutputStream:定义用来将基本数据类型写入输出流的方法，以便编组自定义值类型。
• 新增方法   readXxx()   WriteXxx()
• 先写出-->再读入 (读入源文件才有效)
• EOFException:文件有,但是内容读取不到

• public class DataDemo05 {
  	public static void main(String[] args) throws IOException {
  		//write("D:/E.txt");
  		read("D:/EEE.txt");
  	}
  	
  	//读入带有基本数据类型的数据
  	public static void read(String path) throws IOException{
  		//1.选择流
  		DataInputStream is=new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
  		//2.读入 写出与读入的顺序要相同
  		int i=is.readInt();
  		String s=is.readUTF();
  		boolean b=is.readBoolean();
  		System.out.println(i+"-->"+s+"-->"+b);
  		//3.关闭
  		is.close();
  	}
  	
  	//写出带有基本类型的数据
  	public static void write(String path) throws IOException{
  		//1.选择输出流
  		DataOutputStream os=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
  		//2.写出
  		int i=101;
  		String s="哈哈";
  		boolean b=false;
  		os.writeInt(i);
  		os.writeUTF(s);
  		os.writeBoolean(b);
  		//3.刷出
  		os.flush();
  		//4.关闭
  		os.close();
  	}
  }
  

  五、对象流（基本数据类型+字符串+对象类型）

• 序列化：把对象类型数据的状态转为可以存储或者传输的过程
• 序列化输出流 ObjectOutputStream
• 反序列化输入流 ObjectInputStream
• 新增方法: writeObject()   readObject()
• 先序列化后反序列化，实现空接口，java.io.Serializable

• 案例

  public class ObjectDemo06 {
  	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
  		out("D:/f.txt");
  		in("D:/f.txt");
  	}
  	
  	//反序列化
  	public static void in(String path) throws IOException, ClassNotFoundException{
  		//1.流
  		ObjectInputStream is=new ObjectInputStream(new FileInputStream(path));
  		//2.读入
  		Object obj1=is.readObject();
  		System.out.println(obj1);
  		/*if(obj1 instanceof Person){
  			Person obj=(Person)obj1;
  			System.out.println(obj);
  		}*/
  		int[] obj2=(int[]) is.readObject();
  		System.out.println(Arrays.toString(obj2));
  		//3.关闭
  		is.close();
  		
  	}
  	
  	//序列化
  	public static void out(String path) throws FileNotFoundException, IOException{
  		//1.流
  		ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream(path));
  		//2.写出
  		Person p=new Person("路飞",16,01);
  		int[] arr={1,2,3,4};
  		os.writeObject(p);
  		os.writeObject(arr);
  		
  		p.setName("香克斯");
  		p.id=100;
  		//3.刷出
  		os.flush();
  		//4.关闭
  		os.close();
  	}
  
  }
  

  注：

  1. 不是所有类都能序列化
  2. 不是所有的属性都需要序列化 transient
  3. 静态的内容不能被序列化
  4. 如果父类实现了序列化,子类对象的所有内容都可以被序列化
  5. 如果子类实现序列化,父类没有实现,子类对象只能序列化子类中的内容