Java基础中的IO流

一、IO流

IO：上传下载，写入写出
	流: 一连串流动的数据，以先入先出的方式进行流动，管道，以程序为中心、程序与网络|文件|服务器|数组..

1.分类

1)按照流向: 
		输入流：
		输出流：
2)操作单元分:
		字节流 (万能流):任何内容都可以转为字节,可以传输文本,图片,音频...
		字符流 :只能操作纯文本数据
3)按照功能:
		节点流 : 包裹源头,实现基本功能
		功能流 : 对节点流增强性能,提高效率
4)各个分类之间是相辅相成的

2.字节流:

1)节点流
	(1)字节输入流 : InputStream 	此抽象类是表示字节输入流的所有类的超类
			FileInputStream		从文件系统中的某个文件中获得输入字节

//字节流输入 InputStream 
//导包	导包快捷键: ctrl+shift+o
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo01 {
	public static void main(String[] args) throws IOException {
		//FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
		//FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定
		InputStream is=new FileInputStream(new File("D:/test.txt"));//创建D盘符的根目录下的文件
		System.out.println(is);
		//方式1： int read() 读入数据 一个字节一个字节读入
		/*int num=is.read();
		System.out.println((char)num);
		num=is.read();
		System.out.println((char)num);
		System.out.println((char)(is.read()));*/
		//方式2：使用循环,循环读入，可以简化代码,重复代码只写一次,但还是一个字节一个字节的读入
		/*int num=-1;
		while((num=is.read())!=-1){
			System.out.println((char)num);
		}*/
		//方式3：int read(byte[] b) 一个字节数组一个字节数组的读入
		//返回值: 返回读入到字节数组中数据的个数,没有读到返回-1
		byte[] car=new byte[1];
		//int len=is.read(car); 
		int len=-1;
		while((len=is.read(car))!=-1){
			System.out.println(new String(car,0,len));
		}
		//关闭
		is.close();
	}
}

	(2)字节输出流： OutputStream   	此抽象类是表示输出字节流的所有类的超类
			FileOutputStream  		文件输出流是用于将数据写入 File 的输出流

//字节输出流 OutputStream
//导包	导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo02 {
	public static void main(String[] args) {
		//FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流
		//FileOutputStream(String name,boolean append)  创建一个向具有指定 name 的文件中写入数据的输出文件流
		//FileOutputStream(File file,boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流
		//boolean append	返回值：true追加,false不追加(默认false)
		OutputStream os=null;
		//try...catch(){}	捕捉异常，处理异常
		try {
			//1.选择流
			os=new FileOutputStream("D:/hhh.txt",hhtrue); //文件不存在,系统会自动帮我们创建,但文件夹不会
			//2.准备数据
			String str="要好好学习，天天向上..."; 
			byte[] c和=str.getBytes();
			//3.写出 void write(byte[] b)  
			os.write(ch);
			//4.刷出
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//5.关闭
			try {//预防空指针异常
				if(os!=null){
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3.字符流:

只能操作纯文本
1)节点流:
	(1)字符输入流：Reader 	读取字符流的抽象类
			FileReader 		用来读取字符文件的便捷类

//字符输入流 Reader
//导包	导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo03 {
	public static void main(String[] args) {
		//FileReader(String fileName) 
		Reader rd=null;
		try {
			//1.选择流
			rd=new FileReader("D:/hehe.txt");//创建D盘符的根目录下的文件
			//2.读入
			//方法1：int read() 读取单个字符。 
			/*System.out.println((char)rd.read());
			System.out.println((char)rd.read());
			System.out.println((char)rd.read());
			System.out.println((char)rd.read());*/
			int len=-1;  //存储读到的数据  如果为-1,证明已达到末尾
			//方法2:
			/*while(-1!=(len=rd.read())){
				System.out.println((char)len);
			}*/
			//方法3：int read(char[] cbuf)  将字符读入数组。
			char[] car=new char[1024];
			while((len=rd.read(car))!=-1){
				System.out.println(new String(car,0,len));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			if(rd!=null){
				try {
					//关闭功能
					rd.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}
}

	(2)字符输出流: Writer 	写入字符流的抽象类
			FileWriter		用来写入字符文件的便捷类

//字符输出流：Writer
//导包	导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class CharDemo02 {
	public static void main(String[] args) {
		//FileWriter(File file) 								//默认不追加
		//FileWriter(File file, boolean append)  	
		//FileWriter(String file)  
		//FileWriter(String file, boolean append)  
		Writer rt=null;
		try {
			//1.选择流
			rt=new FileWriter("D:/houhou.txt",true);
			//2.写出
			/*	void write(char[] cbuf)  写入字符数组 
				void write(char[] cbuf, int off, int len) 写入字符数组的某一部分
				void write(int c) 写入单个字符
				void write(String str)  写入字符串 
				void write(String str, int off, int len) 写入字符串的某一部分 
			*/
			rt.write(97);
			rt.write("\r\n");  								//换行
			rt.write("你真好看!!!!");
			rt.write("\r\n");
			rt.write("你真好看!!!!",2,2);
			rt.write("\r\n");
			char[] ch={'a','b','c','d','e'};
			rt.write(ch);
			rt.write("\r\n");
			rt.write(ch,2,3);
			//3.刷出
			rt.flush();		
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//4.关闭
			if(null!=rt){
				try {
					rt.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

4.功能流(节点流):

	缓冲流: 增强功能，提高性能，加快读写效率
1）字节流：
	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 BufferedInputStream01 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		//BufferedInputStream(InputStream in) 
		InputStream is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
		OutputStream os=new BufferedOutputStream(new FileOutputStream("E:/hengheng.txt") );
		//2.读写
		byte[] car=new byte[1024];
		int len=-1;
		while((len=is.read(car))!=-1){
			os.write(car,0,len);
		}
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
		is.close();
	}
}

2）字符流:	
	BufferedReader	字符输入流缓冲流			
			新增方法:	String readLine()	读取一个文本行
	BufferedWriter	字符输出流缓冲流
			新增方法:	void newLine()		写入一个行分隔符 

//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedReader02 {
	public static void main(String[] args) throws IOException {
		//1.选择流  导包快捷键: ctrl+shift+o
		BufferedReader br=new BufferedReader(new FileReader("D:/hehe.txt"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("D:/ccc.txt"));
		//2.读写
		String msg=null;
		while((msg=br.readLine())!=null){
			bw.write(msg);
			bw.newLine();
		}
		//3.刷出
		bw.flush();
		//4.关闭
		bw.close();
		br.close();
	}
}

5.Data流(字节节点流)

Data流(字节节点流)：
	读写基本数据类型+String类型数据，是字节流功能流的一种
		DataInputStream		新增方法: readXxx()
		DataOutputStream 	新增方法: writeXxx()
	存在新增方法不能发生多态，先写出再写入
可能碰到的异常：EOFException 文件有,内容读入不到,必须读入的是写出的源文件

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Data01 {
	public static void main(String[] args) throws IOException {
		//调用方法
		write("D:/data.txt");
		read("D:/data1.txt");
	}
	//读入
	public static void read(String path) throws IOException{
		//1.输入流 数据类型+数据
		DataInputStream in=new DataInputStream(new  BufferedInputStream(new FileInputStream(path)));
		//2.读入
		int i=in.readInt();
		boolean b=in.readBoolean();
		String s=in.readUTF();
		System.out.println(i+"-->"+b+"-->"+s);
		//3.关闭
		in.close();
	}
	//写出
	public static void write(String path) throws IOException{
		//1.输出流
		DataOutputStream out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
		//2.准备数据
		int i=101;
		boolean f=false;
		String s="哈哈";
		//3.写出  写出和读入的顺序要保持一致
		out.writeInt(i);
		out.writeBoolean(f);
		out.writeUTF(s);
		//4.刷出
		out.flush();
		//5.关闭
		out.close();
	}
}

6.对象流:

Object 保存数据类型+数据
	字节的功能流:当想要传输|读写对象类型数据的时候,可以使用一个对象流
	序列化: 把对象类型的数据转化为可存储|可传输的状态的过程
		ObjectInputStream()    反序列化输入流   新增方法: readObject()
		ObjectOutputStream()   序列化输出流       新增方法: writeObject()
注意:
	1)先序列化后反序列化
	2)序列化反序列读写顺序一致
	3)不是所有的类都能序列化 		java.io.Serializable 空接口
	4)不是所有的属性都需要序列化 		transient
	5)static内容不会被序列化
	6)如果父类实现Serializable接口,子类中可以序列化所有内容
如果子类实现Serializable接口,但是父类没有实现,子类只能序列化子类独有的内容

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
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 ObjectDemo02 {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		write("D:/object.txt");
		read("D:/object.txt");
	}
	//反序列化输入
	public static void read(String path) throws IOException, ClassNotFoundException{
		//1.输入流
		ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
		//2.读入
		Object p= is.readObject();
		int[] arr= (int[]) is.readObject();
		if(p instanceof Person){
			Person person=(Person)p;
			System.out.println(person.getName());
		}
		System.out.println(p);
		System.out.println(Arrays.toString(arr));
		//3,关闭
		is.close();
	}
	//序列化输出
	public static void write(String path) throws IOException{
		//1.输出对象信息
		ObjectOutputStream os=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
		//2.准备数据
		Person p=new Person("aaa",18);
		int[] arr={1,2,3,4};
		//3.输出
		os.writeObject(p);
		os.writeObject(arr);
		//4.刷出
		os.flush();
		//5.关闭
		os.close();
	}
}
//接口
class Person implements Serializable{
	private  String name;
	private static int age;
	public Person() {
	}
	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 + "]";
	}
}

二、File 类

File 类：文件和目录路径名的抽象表示形式
	提供的功能：操作文件外部的能力,不能操作文件内部的内容
	能够定义真实存在的路径|文件,不在的也可以定义,所以抽象表现形式
	构造器：	File(File parent, String child)   根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例 
	  		File(String pathname)  通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例 
	 		File(String parent, String child)   根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例