Day18，19笔记--IO

JavaSE基础

一、File

1.1 概述

• 文件和目录路径名的抽象表示形式。
  • 把文件管理系统中的字符串路径创建称为Java中的对象
  • 具备了一些属性和方法，方便在程序中操作文件

1.2 创建对象

package com.javastudy;

import java.io.File;

public class TestIO01{
	public static void main(String[] args) {
		/**
		 * 构造方法摘要 
			File(String pathname) 
			          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 
			File(String parent, String child) 
			          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。 
			File(File parent, String child) 
			          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 
		 */
		// 创建File对象,绝对路径
		File file = new File("E:\\JavaStudy");
		System.out.println(file);
		
		// 资料文件夹根目录
		String pathname = "E:\\JavaStudy";
		
		// 路径拼接
		File file2 = new File(pathname, "Day01");
		System.out.println(file2);
        // 文件是否存在
		System.out.println(file2.exists());
		
		File file3 = new File(file, "Day01");
		System.out.println(file3);
		System.out.println(file3.exists());
	}
}

路径的写法

package com.javastudy;

import java.io.File;

public class TestIO02 {
	public static void main(String[] args) {
		/**
		 * D:\Files\JavaFiles\Java2306
		 * 	\	表示文件夹的层级
		 * 	\\	需要偶数次出现
		 * 	/	一根就行
		 */
		String pathName = "E:\\JavaStudy/Day01\\\\Java";
		System.out.println();
		
		File file = new File(pathName);
		//此函数返回由抽象路径名表示的分区的未分配大小
		System.out.println(file.getFreeSpace());
		//此函数返回由抽象路径名表示的分区的总大小
		System.out.println(file.getTotalSpace());
		System.out.println(file.exists());
		
		/**
		 * 	绝对路径
		 *		https://www.baidu.com/
		 *		D:\\Files/JavaFiles\\\\Java2306
		 *		把文件或者连接的全部路径都书写出来
		 *		需要带有协议或者盘符，绝对路径是唯一的
		 *	相对路径
		 *		相对于当前的位置中的一个路径
		 *		hello.txt
		 *		world.txt
		 *		不用书写盘符，不是惟一的【其他路径中也可能存在】
		 */
		
		File file2 = new File("hello.txt");
		System.out.println(file2.exists());
		//该函数返回给定文件对象的绝对路径名
		System.out.println(file2.getAbsolutePath());
		
	}

}

1.3 常用方法

增删改

package com.javastudy;

import java.io.File;
import java.io.IOException;

public class TestIO03 {
	public static void main(String[] args) throws IOException, InterruptedException {
		/**
		 * 方法摘要 
		 * 增
			 boolean createNewFile() 
			          当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。 
			 boolean mkdir() 
			          创建此抽象路径名指定的目录。 
			 boolean mkdirs() 
			          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 
		 
		 * 删
			 boolean delete() 
			          删除此抽象路径名表示的文件或目录。 
			 void deleteOnExit() 
			          在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。 
		 
		 * 改
			 boolean renameTo(File dest) 
			          重新命名此抽象路径名表示的文件。 
		 */
		
		File file = new File("E:\\JavaStudy\\Day01");
		
		// 创建一级目录
		File file2 = new File(file, "Day02");
		System.out.println(file2.exists());
		boolean b = file2.mkdir();
		System.out.println(b);
		
		// 创建多级目录
		File file3 = new File(file, "Day03/笔记");
		System.out.println(file3.exists());
		b = file3.mkdirs();
		System.out.println(b);
		
		// 文件
		File file4 = new File(file, "hehe.txt");
		file4.createNewFile();
		
		// 不经过回收站,慎用
		// file4.delete();
		
		// 程序结束时候删除
		// file4.deleteOnExit();
		System.out.println("10S后删除...");
		
		Thread.sleep(10000);
		System.out.println("OVER");
		
		//删除文件
		//如果文件夹不为空则无法删除
		File file5 = new File(file, "Day03");
		b = file5.delete();
		System.out.println(b);
		
		// 修改文件名
		File dest = new File(file, "hehehe.txt");
		b = file4.renameTo(dest);
		System.out.println(b);
	}
}

查询

package com.javastudy;

import java.io.File;

public class TestIO04 {
	public static void main(String[] args) {
		/**
		 * 查
			 boolean exists() 
			          测试此抽象路径名表示的文件或目录是否存在。 
			 boolean isAbsolute() 
			          测试此抽象路径名是否为绝对路径名。 
			 boolean isDirectory() 
			          测试此抽象路径名表示的文件是否是一个目录。 
			 boolean isFile() 
			          测试此抽象路径名表示的文件是否是一个标准文件。 
			 boolean isHidden() 
			          测试此抽象路径名指定的文件是否是一个隐藏文件。 
			          
			 File getAbsoluteFile() 
			          返回此抽象路径名的绝对路径名形式。 
			 String getAbsolutePath() 
			          返回此抽象路径名的绝对路径名字符串。 
			 String getName() 
			          返回由此抽象路径名表示的文件或目录的名称。 
			 String getParent() 
			          返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 
			          
			 long length() 
			          返回由此抽象路径名表示的文件的长度。 
			 long getFreeSpace() 
			          返回此抽象路径名指定的分区中未分配的字节数。 
			 long getTotalSpace() 
			          返回此抽象路径名指定的分区大小。 
			 long getUsableSpace() 
			          返回此抽象路径名指定的分区上可用于此虚拟机的字节数。 

			 File[] listFiles() 【重点】
			          返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。 
			 File[] listFiles(FileFilter filter) 
			          返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
		 */
		
		File file = new File("E:\\JavaStudy\\Day01");
		File file2 = new File(file, "hehehe.txt");
		System.out.println(file2.exists());
		System.out.println(file2.isDirectory());
		System.out.println(file2.isFile());
		System.out.println(file2.isHidden());
		System.out.println(file2.getName());
		System.out.println(file2.getParent());
		
		// 文件大小,字节
		System.out.println(file2.length());
		// 获取目录中所有的文件和文件夹
		File[] files = file.listFiles();
		for (File file3 : files) {
			System.out.println(file3);
		}
	}
	
}

二、文件过滤器

2.1 概述

• 筛选符合要求的文件或者文件夹

2.2 案例

package com.javastudy;

import java.io.File;
import java.io.FileFilter;

public class TestIO05 {
	public static void main(String[] args) {
		/**
		 * 文件过滤器
		 */
		
		File file = new File("E:\\JavaStudy\\Day01");
		
		// 创建文件过滤器
		FileFilter filter = new FileFilter() {
			@Override
			public boolean accept(File filters) {
				return filters.getName().endsWith(".docx");
			}
		};
		// 获取目录中所有符合过滤器要求的文件和文件夹
		File[] files = file.listFiles(filter);
		for (File f : files) {
			System.out.println(f);
		}
	}
}

2.3 递归获取文件和文件夹【考题】

package com.javastudy;

import java.io.File;

public class TestFile02 {
	public static void main(String[] args) {
		/**
		 * 获取指定目录和子级目录中所有的文件和文件夹【阶段考试题目】
		 */
		File file = new File("E:\\JavaStudy\\Day01");
		getFiles(file);
	}
	
	/**
	 * 获取指定文件对象中所有的文件和文件夹
	 * @param file	目标路径
	 */
	public static void getFiles(File file) {
		// 获取file中所有的文件和文件夹
		File[] files = file.listFiles();
		
		// 遍历files
		for (File f : files) {
			// 判定f是文件还是文件夹
			if (f.isFile()) {
				System.out.println("\t文件:" + f);
			} else {
				System.out.println("文件夹:" + f);
				// 文件夹,调用方法查看所有文件和文件夹
				getFiles(f);
			}
		}
	}
}

三、字节输入流

3.1 概述

• 以字节为单位读取数据的流

3.2 继承体系

InputStream

• 抽象类
• 所有字节输入流对象的父类

FileInputStream

• 可以以字节为单位读取任意类型文件的输入流

3.3 FileInputStream

1、创建流对象，指定读取的文件
2、读取数据
	read(byte[] b)
3、关闭流

package com.javastudy;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

public class TestInputStream {
	public static void main(String[] args) throws IOException {
		/**
		 *	1、创建流对象
		 *	2、读取数据
		 *	3、关闭流
		 */
		
		FileInputStream fis = new 		
            FileInputStream("E:\\JavaStudy\\Day19\\src\\com\\javastudy\\hello.txt");
		
		byte[] b = new byte[4];
		
		/**
		 * 读取数据，把读取得到的数据放入byte数组，返回读取字节的数量
		 */
		int len = fis.read(b);
		System.out.println("读取内容的数量:" + len);
		System.out.println("第一次读取的数据:" + Arrays.toString(b));
		
		len = fis.read(b);
		System.out.println("读取内容的数量:" + len);
		System.out.println("第二次读取的数据:" + Arrays.toString(b));
		
		len = fis.read(b);
		System.out.println("读取内容的数量:" + len);
		System.out.println("第三次读取的数据:" + Arrays.toString(b));
		
		len = fis.read(b);
		System.out.println("读取内容的数量:" + len);
		System.out.println("第四次读取的数据:" + Arrays.toString(b));
		
		// 关闭流
		fis.close();
	}

}

四、字节输出流

4.1 概述

• 以字节为单位输出【写入】数据的流

4.2 继承体系

OutputStream

• 此抽象类是表示输出字节流的所有类的超类。

FileOutputStream

• 文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
• FileOutputStream 用于写入诸如图像数据之类的原始字节的流。

4.3 FileOutputStream

1、创建流对象，指明数据写入的文件
2、写入数据
3、关闭流

package com.javastudy;

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

public class TestOutPutStream {
	public static void main(String[] args) throws IOException {
		/**
		 * 构造方法摘要 
			FileOutputStream(String name) 
			          创建一个向具有指定名称的文件中写入数据的输出文件流。 
			FileOutputStream(String name, boolean append) 
			          创建一个向具有指定 name 的文件中写入数据的输出文件流。 
		 */
		/**
		 * 创建字节输出流,指向Hello.txt
		 * 		1、文件名不区分大小写
		 * 		2、如果文件不存在，创建新的文件并写入数据
		 * 		3、boolean append
		 * 			如果布尔值是false	原文件中的内容被覆盖
		 * 			如果布尔值是true	在原文件内容后面追加新的内容
		 */
		FileOutputStream fop = new FileOutputStream("hello.txt",true);
		
		/**
			 void write(int b) 
			          将指定字节写入此文件输出流。 
			 void write(byte[] b) 
			          将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
			 void write(byte[] b, int off, int len) 
			          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
		
		fos.write(65);
		fos.write(66);
		fos.write(67);
		fos.write(68);
		fos.write(69);
		fos.write(70);
		fos.write(71);
		 */
		
		byte[] b = new byte[] {72,73,74,75,76,77,78};
		fop.write(b, 3, 4);
		
		// 关闭流
		fop.close();
	}

}

4.4 复制文件

第一版

package com.javastudy;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestCopy03 {
	public static void main(String[] args) throws IOException {
		/**
		 * 	1、创建流对象
		 * 		输入流	源文件
		 * 		输出流	目标位置和文件
		 * 	2、循环读写
		 * 	3、关闭流
		 */
		long startTime = System.currentTimeMillis();
        
		// 创建流对象
		FileInputStream fip = new FileInputStream("D:\\Hello.txt");
		FileOutputStream fop = new FileOutputStream("E:\\Hello.txt");
        
		// 循环读写 
		int len = -1;
		while((len = fip.read(b))!= -1) {
			fop.write(b,0,len);
		}
		// 关闭流
		fip.close();
		fop.close();
        
		long endTime = System.currentTimeMillis();
        
		System.out.println(endTime - startTime);
	}
}

第二版【数组】

package com.javastudy;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestCopy02 {
	public static void main(String[] args) throws IOException {
		/**
		 *	1、创建流对象
		 *		输入流
		 *		输出流
		 *	2、循环读写
		 *		创建byte数组
		 *		创建计数器int len
		 *	3、关闭流
		 */
		long startTime = System.currentTimeMillis();
        
		// 创建流对象
		FileInputStream fip = new FileInputStream("D:\\Hello.txt");
		FileOutputStream fop = new FileOutputStream("E:\\Hello.txt");
        
		// 循环读写 
		byte[] b = new byte[1024*8];
		int len = -1;
		while((len = fip.read(b))!= -1) {
			fop.write(b,0,len);
		}
        
		// 关闭流
		fip.close();
		fop.close();
        
		long endTime = System.currentTimeMillis();
        
		System.out.println(endTime - startTime);
    }
}

第三版【异常处理】【重点】【掌握】

package com.javastudy;

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


public class TestCopy {
	public static void main(String[] args) {
		/**
		 *	1、创建流对象
		 *		输入流
		 *		输出流
		 *	2、循环读写
		 *		创建byte数组
		 *		创建计数器int len
		 *	3、关闭流
		 */
		// 声明流变量
		FileInputStream fis = null;
		FileOutputStream fio =null;
		
		try {
			// 创建对象
			fis = new FileInputStream("E:\\JavaStudy\\Day19\\src\\com\\javastudy\\hello.txt");
			fio = new FileOutputStream("E:\\JavaStudy\\hello.txt");
			// 循环读写
			int len = -1 ; 
			byte[] b = new byte[1024*8];
			while((len = fis.read(b)) != -1) {
				fio.write(b, 0, len);
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				// 关闭流,关闭之前判定是否为null
				if(fis != null) {
					fis.close();
				} 
				if(fio != null) {
					fio.close();
				}
			}
			catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	
	}
		System.out.println("OVER");
	}
}

五、缓冲流

5.1 概述

• 减少IO的次数，提高IO性能
• 在字节流基础上进行包装

5.2 案例代码

package com.javastudy;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestBuffCopy {
	public static void main(String[] args) throws IOException {
		
		
		BufferedInputStream bin = new BufferedInputStream(new FileInputStream("E:\\JavaStudy\\Day19\\src\\com\\javastudy\\hello.txt"));
		BufferedOutputStream bou = new BufferedOutputStream(new FileOutputStream("E:\\JavaStudy\\hello.txt"));
		
		// 循环读写
		byte[] b = new byte[1024 * 8];
		int len = -1;
		while ((len = bin.read(b)) != -1) {
			bou.write(b, 0, len);	
		} 
		
		
		// 清空缓冲区
		bou.flush();
		
		// 关闭流
		bin.close();
		bou.close();
				
	}
}

六、字符流

6.1 字符流概述

• 字节流能读写任意类型的文件
• 一个字符可能是一个或者多个字节组成
  • a占用一个字节
  • 床占用2个字节
  • 嬴占用3个字节
• 使用字节流每次读取一个字节可能会造成读取半个文字
• 需要一种能按照个数读取数据的流–字符流

6.2 字符输入流

抽象类reader

• 用于读取字符流的抽象类。

实现类InputStreamReader

FileReader

• 用来读取字符文件的便捷类。

创建对象

FileReader(String fileName) 
          在给定从中读取数据的文件名的情况下创建一个新 FileReader。

读取数据

package com.javastudy;

import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;

public class TestInputStreamReader {
	public static void main(String[] args) throws IOException {
		/**
			 int read() 
			          读取单个字符。 
			 int read(char[] cbuf) 
			          将字符读入数组。 
			 int read(char[] cbuf, int off, int len) 
			          将字符读入数组的某一部分。 
		*/
		
		FileReader reader = new FileReader("D:\\Hello.txt");
		
		char[] c = new char[4];
		int len;
		len = reader.read(c);
		System.out.println(len);
		System.out.println(Arrays.toString(c));
		
		len = reader.read(c);
		System.out.println(len);
		System.out.println(Arrays.toString(c));
		
		len = reader.read(c); //读取完毕后len 为 -1
		System.out.println(len);
		System.out.println(Arrays.toString(c));
				
		reader.close();
	}

}

6.3 字符输出流

抽象类Writer

• 写入字符流的抽象类。

实现类OutputStreamWriter

FileWriter

• 用来写入字符文件的便捷类。

创建对象和写入数据

package com.javastudy;

import java.io.FileWriter;
import java.io.IOException;

public class TestOutputStreamWriter {
	public static void main(String[] args) throws IOException {
		/**
		FileWriter(String fileName) 
		          根据给定的文件名构造一个 FileWriter 对象。 
		FileWriter(String fileName, boolean append) 
		          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。 
	 */
	
	FileWriter writer = new FileWriter("E://hehe.txt");
	
	
	/**
		 void write(char[] cbuf, int off, int len) 
		          写入字符数组的某一部分。 
		 void write(int c) 
		          写入单个字符。 
		 void write(String str, int off, int len) 
		          写入字符串的某一部分。 
	 */
	writer.write("斯是陋室惟吾德馨。");
	
	writer.close();
	}

}

6.4 使用字符流复制小说

1、创建字符流镀锡
2、循环读写数据
3、关闭流

package com.javastudy;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestCopy {
	public static void main(String[] args) throws IOException {
		/**
		 * 复制小说
		 * 	1、创建流对象
		 * 	2、读写数据
		 * 	3、关闭流
		 */
		// 创建流对象
		FileReader read = new FileReader("E:\\threeCountry.txt");
		
		FileWriter write = new FileWriter("C:\\Users\\Administrator\\Desktop\\threeCountry.txt");
		// 循环读写
		char[] c = new char[1024];
		int len = -1;
		while((len = read.read(c)) != -1) {
			write.write(c, 0, len);
		}
		
		// 关闭流
		write.close();
		read.close();
	}

}

七、转换流

7.1 概述

• 解决乱码问题

package com.javastudy;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class TestErrorCode {
	public static void main(String[] args) throws IOException {
		/**
		 *	解决乱码
		 *		--UTF-8的格式读取内容
		 *		--GBK的格式写入内容
		 */
		// 创建转换流对象
		InputStreamReader isr = new InputStreamReader(new FileInputStream("D:/hello.txt"), "UTF-8");
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:/hello.txt"), "GBK");
		
		// 循环读写
		char[] c = new char[1024];
		int len = -1;
		
		while ((len = isr.read(c)) != -1) {
			System.out.println(len);
			osw.write(c, 0, len);
		}
		
		// 关闭流
		osw.close();
		isr.close();
		System.out.println("OVER");
	}
}

八、对象流

8.1 概述

• 传输对象
• 发送数据【序列化】
• 接收数据【反序列化】

8.2 案例

收发JDK内置类型

package com.javastudy;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class TestObjectIO01 {
	public static void main(String[] args) throws IOException {
		/**
		 * 写入数据
		 */
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file"));
		
		oos.writeObject(1000);
		oos.writeObject(3.14);
		oos.writeObject("Hello");
		oos.writeObject(true);
		oos.writeObject(new int[] {11,22,33,44,55});
		
		oos.close();
		
		System.out.println("OVER");
	}
}

package com.javastudy;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class TestObjectIO02 {
	public static void main(String[] args) throws ClassNotFoundException, IOException {
		/**
		 * 读取数据
		 */
		// 创建对象流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("file"));
		
		// 读取数据
		System.out.println(ois.readObject());
		System.out.println(ois.readObject());
		System.out.println(ois.readObject());
		System.out.println(ois.readObject());
		System.out.println(ois.readObject());
		
		// 关闭流
		ois.close();
	}

}

收发自定义类型

• 自定义类型需要实现序列化接口

package com.javastudy;

import java.io.Serializable;

public class Student implements Serializable{
	String name;
	int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

package com.javastudy;

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

public class Main01 {
	public static void main(String[] args) throws FileNotFoundException, IOException {
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/hello.txt"));
		
		// 发送数据:对象需要实现序列化接口 && 对象中的每一个属性都必须实现序列化接口
		oos.writeObject(new Student("张三", 12));
		
		oos.close();
		
		System.out.println("OVER");
	}
}

package com.javastudy;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Main02 {
	 public static void main(String[] args) throws ClassNotFoundException, IOException {
		// 创建输入流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/hello.txt"));
		
		// 读取对象
		Object obj = ois.readObject();
		System.out.println(obj);
		
		ois.close();
	}
}