输入和输出（IO流）

一、File类的常用方法

1）boolean exists( ) 判断文件或目录是否存在
2）boolean isFile( ) 判断是否是文件
3）boolean isDirectory( ) 判断是否是目录
4）String getPath( ) 返回此对象表示的文件的相对路径名
5）String getAbsolutePath( ) 返回此对象表示的文件的绝对路径名
6）String getName( ) 返回此对象表示的文件或目录的名称
7）boolean delete( ) 删除此对象指定的文件或目录
8）boolean createNewFile( ) 创建名称的空文件，不创建文件夹
9）long length() 返回文件的长度，单位为字节, 如果文件不存在，则返回 0
10）boolean mkdir() 返回boolean值，只能创建当前目录下的文件夹，若找不到目录，则false
11）boolean mkdirs() 返回boolean值，可创建多级目录文件夹

	File file = new File("E:\\myDoc\\myFile.txt");
	System.out.println("文件是否存在" + file.exists());
	System.out.println("是不是文件夹" + file.isDirectory());
	System.out.println("是不是文件" + file.isFile());
	System.out.println("文件名" + file.getName());
	System.out.println("文件大小" + file.length());
	String suffix = file.getName().substring(file.getName().lastIndexOf(".") + 1);
	System.out.println("文件的后缀是" + suffix);

		File file = new File("E:\\myDoc\\prim");
		File file1 = new File("E:\\myDoc\\prim\\prim.txt");
		if (!file.exists()) {
			try {
				//没有myDoc文件夹，mkdirs依然是true，会依次创建myDoc文件夹和prim文件夹
				boolean mkdirs = file.mkdirs();
				//若没有myDoc目录文件夹，则mkdir为false，只会创建最后一层文件夹，找不到路径
				boolean mkdir = file.mkdir();  
				if (mkdirs) {
					System.out.println("prim文件夹已创建");
					file1.createNewFile();
					System.out.println("prim.tet文件已创建");
				}			
			} catch (Throwable e) {
				e.printStackTrace();
			}
		}
		if (file.exists()) {
			file.delete();
			System.out.println("文件夹已删除");
		}

二、IO流的分类

流是一组有序的数据序列，以先进先出方式发送信息的通道

按流向划分：
输入流 -->从数据节点输入到内存中（input）
输出流 -->从内存输出到数据节点中（output）

按数据类型划分：
字节流 -->InputStream–>字节输入流 OutputStream–>字节输出流
字符流 --> Writer 字符输出流 Reader 字符输入流

四、字节流常用方法

1、InputStream 常用方法
1）int read( )：读一个下次就自动到下一个,如果碰到-1说明没有值了.
2）int read(byte[] b)：字节流读取
3）int read(byte[] b,int off,int len) ：从读取流读取一定数量的字节,
4）void close( ) ：关闭流
5）int available()：可以从输入流中读取的字节数目

2、子类FileInputStream常用的构造方法
1）FileInputStream(File file)
2）FileInputStream(String name)

3、OutputStream类常用方法
1）void write(int c) 写
2）void write(byte[] buf) 以字节数组的形式写入
3）void write(byte[] b,int off,int len)
4）void close() 关闭流
5）void flush()：强制把缓冲区的数据写到输出流中

4、子类FileOutputStream常用的构造方法
1）FileOutputStream (File file)
2）FileOutputStream(String name)
3）FileOutputStream(String name,boolean append)

五、字符流常用方法

1、Reader类
1）int read( )
2）int read(char[] c)
3）read(char[] c,int off,int len)
4）void close( )

2、子类InputStreamReader常用的构造方法
1）InputStreamReader(InputStream in)
2）InputStreamReader(InputStream in,String charsetName)

3、FileReader类
FileReader类是InputStreamReader的子类

1）FileReader(File file)
2）FileReader(String name)
3）System.out.println(System.getProperty(“file.encoding”)); //获得本地平台的字符编码类型

4、Writer类
1）write(String str)
2）write(String str,int off,int len)
3）void close()
4）void flush()

5、子类OutputStreamWriter常用的构造方法
1）OutputStreamWriter(OutputStream out)
2）OutputStreamWriter(OutputStream out,String charsetName)

6、FileWriter类
1）FileWriter (File file) 对象参数，可以存放对象，并操作对象相关
2）FileWriter (String name) 参数为字符串， 我们一般放文件路径

7、BufferedWriter类
1）BufferedWriter类是Writer类的子类
2）BufferedWriter类带有缓冲区
3）BufferedWriter常用的构造方法
4）BufferedWriter(Writer out)

8、代码示例
输入流和输出流一般成对出现

public static void main(String[] args) {
		//被读取的文件位置
		String path = "D:\\prim\\demo3.txt";
		//被输出的文件位置
		String path2 = "D:\\prim\\demo4.txt";
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try{
			//创建输入流，从文件输入到内存中
			fis = new FileInputStream(path);
			//每次读取1024个字节
			byte[] data = new byte[1024];
			//int res = fis.read(data);
			//System.out.println("读取到了" + res +"个字节");
			//获取输出流,从内存中输出到文件中
			int len = -1;
			fos = new FileOutputStream(path2, false);
			//当读取到文件末尾时，返回值为-1
			while((len = fis.read(data)) != -1){
			//将内存中的数据放入对应的文件中
				fos.write(data);
			}
			fos.flush();
		}catch(IOException e){
			e.printStackTrace();
		}finally{
			try {
				if(fis != null){
					isr.close();
				}
				if(fos != null){
					is.close();
				}
			} catch (IOException e) {
					e.printStackTrace();
			}		
		}
	}

9、字符编码乱码问题
1）在保存文件时选定编码格式，改成ANSI

2）通过代码编译解决

public static void main(String[] args) {
		//输入字节流
		InputStream is = null;
		//输入字符流
		InputStreamReader isr = null;
		//输出字节流
		OutputStream os = null;
		//输出字符流
		OutputStreamWriter osw = null;
		try{
			//输入操作
			is = new FileInputStream("D\\prim\\demo3.txt");
			isr = new InputStreamReader(is, "utf-8");
			char[] data = new char[1024];
			//输出操作
			os = new FileOutputStream("D\\prim\\demo4.txt", false);
			osw = new OutputStreamWriter(os, "gbk");
			while(isr.read(data) != -1){
				System.out.println(new String(data));
				osw.write(data);
			}
			osw.flush();		
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try {
				if(isr != null){
					isr.close();
				}
				if(is != null){
					is.close();
				}
			} catch (IOException e) {
					e.printStackTrace();
			}
		}
	}

3）文件无法修改内容，一个是看路径对不对，二是文件属性有无设成只读

六、读写二进制文件

DataInputStream类 -->数据输入流允许应用程序以独立于机器的方式从底层输入流中读取原始 Java 数据类型
是FileInputStream的子类，与FileInputStream类结合使用读取二进制文件

DataOutputStream类 -->数据输出流允许应用程序以可移植的方式将原始 Java 数据类型写入输出流
是FileOutputStream的子类，与FileOutputStream类结合使用写二进制文件

七、序列化和反序列化

序列化是将对象的状态写入到特定的流中的过程
反序列化则是从特定的流中获取数据重新构建对象的过程

public class SerializableObj {
	public static void main(String[] args) {
		ObjectOutputStream oos = null;
		ObjectInputStream ois = null;
		try {
			oos = new ObjectOutputStream(new FileOutputStream("E:\\myDoc\\Test.txt"));
			Student stu = new Student("二哈", 18, "男", "123456");
			System.out.println("姓名：" + stu.getName());
			System.out.println("年龄：" + stu.getAge());
			System.out.println("性别：" + stu.getGender());
			System.out.println("密码：" + stu.getPassword());
			oos.writeObject(stu);
			oos.flush();
			System.out.println("*****************");
			// 创建ObjectInputStream输入流
			ois = new ObjectInputStream(new FileInputStream("E:\\myDoc\\Test.txt"));
			// 反序列化，类型强转
			try {
				Student stu1 = (Student) ois.readObject();
				// 输出生成后对象的信息
				System.out.println("姓名：" + stu1.getName());
				System.out.println("年龄：" + stu1.getAge());
				System.out.println("性别：" + stu1.getGender());
				System.out.println("密码：" + stu.getPassword());
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (oos != null) {
					oos.close();
				}
				if (ois != null) {
					ois.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Student类：

public class Student implements Serializable {
	/**
	 * 唯一的序列化ID
	 */
	private static final long serialVersionUID = -4753720424920054315L;
	private String name;
	private int age;
	private String gender;
	private String password;

	public Student(String name, int age, String gender, String password) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.password = password;
	}

	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;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
}