Java IO

结构

字节流

输入字节流：读数据
-----|InputStream 所有输入字节流的基类。 抽象类。
----------|FileInputStream 读取文件的输入字节流。
----------|BufferedInputStream 缓冲输入字节流，为了提高读取文件数据的效率。
输出字节流: 写数据
-----|OutputStream 所有输出字节流的基类。 抽象类。
----------|FileOutputStream 向文件输出数据 的输出字节流。
----------|BufferedOutputStream 缓冲输出字节流，为了提高向文件写数据的效率

字符流

输入字符流：读数据
-----|Reader 所有输入字符流的基类。 抽象类。
----------|FileReader 读取文件字符的输入字符流。
----------|BufferedReader 缓冲输入字符流，提高读取文件字符的效率并且拓展了功能（readLine()）
输出字符流：写数据
-----|Writer 所有输出字符流的基类。 抽象类。
----------|FileWriter 向文件输出字符数据的输出字符流。
----------|BufferedWriter 缓冲输出字符流，提高写文件字符的效率并且拓展了功能（newLine()）。

File类

创建File

		File file = new File("a.txt");// 默认项目路径
		file.createNewFile();
		file = new File("aaa");
		file.mkdir();
		file = new File("aaa\bbb\ccc");
		file.mkdirs();// 创建多级目录
		file.delete();

File 判断功能

		File file = new File("a.txt");
		System.out.println("Create:" + file.createNewFile());
		System.out.println("exists():" + file.exists());// file对象是否存在
		System.out.println("ifFile():" + file.isFile());// 是否文件
		System.out.println("isDirectory():" + file.isDirectory());// 是否文件夹
		System.out.println("isAbsolute():" + file.isAbsolute());// 是否绝对路径
		System.out.println("canRead():" + file.canRead());// 可读
		System.out.println("canWrite():" + file.canWrite());
		System.out.println("isHidden():" + file.isHidden());// 是否隐藏
		System.out.println("delete():" + file.delete());

File获取属性

		File file2 = new File("hello\txt");
		File file = new File(file2, "a.txt");
		System.out.println("mkdris():  " + file2.mkdirs());
		System.out.println("createNewFile():  " + file.createNewFile());
		System.out.println("getName():  " + file.getName());
		System.out.println("getAbsolutePath():  " + file.getAbsolutePath());// 输出绝对路径
		System.out.println("getPath:  " + file.getPath());// 相对路径
		System.out.println("length():  " + file.length());// 文件大小，字节单位
		System.out.println("lastModified():  " + file.lastModified());// 上次修改时间毫秒值
		System.out.println("delete file and rec:  " + file.delete() + "   " + file2.delete());

Reader

FileReader 字符输入流

public static void main(String[] args) {
                // 1.一次读一个字符的方式
		FileReader read = null;
		try {
			read= new FileReader("a.txt");
			int c;
			try {
		                // 达到流末尾返回-1
		                // read()自动跳转到下一个字符
				while((c=read.read()) != -1){
					System.out.print((char)c);
				}
				read.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		
		method2();
	}


        // 2.一次读取一个字符数组
	private static void method2() {
		try {
			FileReader read=new FileReader("a.txt");
			char[] ch = new char[4];
			int len = 0; // 实际长度
			try {
				while((len=read.read(ch)) != -1){
					System.out.print(new String(ch, 0, len));
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

BufferedReader 缓冲字符输入流

• public String readLine():一次读取一行，但是不包含换行符

                BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		String line = "";

		while((line = br.readLine()) != null){
			System.out.println(line);
		}
		
		br.close();

Writer

FileWriter 字符输出流

换行Windows：
macOS：
Linux：

		FileWriter w = null;
		try {
			// 创建字符输出流对象
			w = new FileWriter("a.txt", false); // 默认：false覆盖，true追加
			w.write("xyg
");
			w.flush();// 字符流需要刷新缓存流
			w.close();// 释放
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (w != null) {
				try {
					w.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

BufferedWriter

• public void newLine():根据系统平台写入换行符
• BufferedWriter(Writer out):构造方法

		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

		for(int i=1;i<=5;i++){
			bw.write("this is "+i+" line.");  //底层调用Writer类写方法
			bw.newLine();
		}

		bw.close();//对一个文件不能同时读写操作

InputStream

FileInputStream 字节输入流，从文件中读取

		FileInputStream fis = new FileInputStream("a_copy.txt");
//              一次读一个字节
//		int by;
//		while((by =  fis.read())!=-1){
//			System.out.print((char)by);
//		}

                // 一次读一个字节数组
		byte[] by = new byte[2024];
		int len;
		while( (len = fis.read(by)) != -1 ){
			System.out.print(new String(by, 0, len));
		}
		fis.close();

BufferedInputStream 缓冲字节输入流

		//接收一个字节输入流对象，字节缓冲区流仅仅提供缓冲区,真正的读写操作还是依靠基本的流对象
		BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("a.txt"));
		
		byte[] bytes = new byte[1024];
		int len = 0;
		while((len = bufferedInputStream.read(bytes))!=-1){
			System.out.println(new String(bytes,0,len));
		}
		
		bufferedInputStream.close();

OutputStream

FileOutputStream 字节输出流，写入到文件

		FileOutputStream fos = new FileOutputStream("a_copy.txt");
		//字节数组
		byte[] by = {97,98,99,100};
		//字符串转字节数组
		byte[] byStr = "hello".getBytes();
		
		//写入字节数组的一部分
		fos.write(by, 0, 4);
		
		fos.write(byStr);
		fos.flush();
		fos.close();

BufferedOutputStream 缓冲字节输出流

		//接收一个字节输出流对象，字节缓冲区流仅仅提供缓冲区,真正的读写操作还是依靠基本的流对象
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("a.txt"));
		
		Scanner sc = new Scanner(System.in);
		String line = sc.nextLine();
		bufferedOutputStream.write(line.getBytes());
		
		bufferedOutputStream.close();

转换

InputStreamReader 输入字节流=>输入字符流

		FileInputStream fileInputStream = new FileInputStream("a.txt");
		// 字节输入转换流，指定编码
		InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "utf-8");
		int content=0;
		while((content=inputStreamReader.read())!=-1){
			System.out.print((char)content);
		}
		fileInputStream.close();

OutputStreamReader 输出字节流=>输出字符流

		// 字节输出流
		FileOutputStream fileOutputStream = new FileOutputStream("a.txt");
		// 字节输出转换流，指定编码
		OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
		outputStreamWriter.write("你好世界"); //转换为字符流即可写入字符数据
		outputStreamWriter.close(); // 关闭刷新

应用

遍历文件夹

                // 遍历盘符
		File[] rootArray = File.listRoots();
		for (File e : rootArray)
			System.out.println(e);

                // 返回指定目录下文件和文件夹名称数组
		File file = new File("D:\");
		String[] list = file.list();
		for (String e : list)
			System.out.println(e);

                // 返回指定目录下文件和文件夹对象数组
		File[] fList = file.listFiles();
		for (File e : fList)
			System.out.println(e.getName());

判断指定目录下指定后缀文件

		File file = new File("D:\");
		String[] list = file.list(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				File fTemp = new File(file, name);
				boolean flag = fTemp.isFile();// 判断是否是文件
				boolean flag2 = name.endsWith(".dll");// 判断是否指定后缀
				return flag2 && flag;
			}
		});
		for (String e : list)
			System.out.println(e);

拷贝文件

		FileInputStream fis = new FileInputStream("b.txt");
		FileOutputStream fos = new FileOutputStream("D:\b_copy.txt");
		
		byte[] by = new byte[1024];
		int len;
		while((len=(fis.read(by)))!=-1){
			fos.write(by, 0, len);
		}
		
		fis.close();
		fos.close();