JAVA 复习(Think In Java, 4th) -- File I/O -- Part 1

File 类的 list() 方法，会将该路径下的所有档案(file)、文件夹(directory)等都列出来，比如说下面的代码便是用递归（recursive）的方式，在特定路径下，去列出包含特定字符串的档名。(後来看了下，其实用 File类的 listFiles() 去实现会更方便些 Orz ) 

	private static void searchFiles(String filePath, String keyword) {
		File f = new File(filePath);
		String[] files = f.list();
		if (files == null) {
			return;
		}
		for (String file : files) {
			StringBuilder sb = new StringBuilder(filePath);
			sb.append('/').append(file);
			String newPath = sb.toString();
			File g = new File(newPath);
			if (g.isDirectory()) {
				searchFiles(newPath, keyword);
			} else {
				if (file.contains(keyword)) {
					System.out.println(newPath);
				}
			}

		}
	}

设计 Reader和 Writer等类主要就是为了支持国际化，旧的 I/O 流结构只支持８位字节流。由於 Unicode用於字符国际化( Java 本身的 char也是 16位 Unicode，和 C语言的 8位元Char并不同，详阅http://www.kuqin.com/shuoit/20141102/343002.html)大多数情况下，我们一般采用面向字符的方式读写，但是也有例外的情况，比如说 zip相关的读写。我们可以使用 FileReader 类来读取档案内容，然後使用 BufferedReader 来做缓冲，这样能提高 I/O 的效率，下面这例子便是将一个档案的内容打印出来的方法。同时，我们为了确保每次能将 BufferedReader 类关闭，避免因为发生异常，而没有关闭（调用 close()），导致内存泄漏的情况，所以我们在范例中做了如下的処理：

	private static void cat(String filePath) {
		if (filePath == null || filePath.isEmpty()) {
			System.out.println("No file path specified");
			return;
		}
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(filePath));
			StringBuilder sb = new StringBuilder();
			String s;
			while ((s = br.readLine()) != null) {
				s = s.toUpperCase();
				sb.append(s + '\n');
			}
			System.out.print(sb.toString());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			closeReader(br);
		}
	}

	private static void closeReader(Closeable reader) {
		if (reader == null)
			return;

		try {
			reader.close();
		} catch (IOException e) {
			// do nothing
		}
	}

从内存输入

我们用 StringReader将档案内容读入到内存中，再用 StringReader 一一自内存中读出

下面是个简单范例：

	private static void catWithString(final String filePath) {
		StringReader sr = new StringReader(cat(filePath));
		int in;
		try {
			while ((in = sr.read()) != -1) {
				System.out.print((char) in);
			}
		} catch (IOException e) {
			// do nothing
		}

	}

	private static String cat(String filePath) {
		String result = "";
		if (filePath == null || filePath.isEmpty()) {
			System.out.println("No file path specified");
			return result;
		}
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(filePath));
			StringBuilder sb = new StringBuilder();
			String s;
			while ((s = br.readLine()) != null) {
				sb.append(s + '\n');
			}
			result = sb.toString();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			closeClosable(br);
		}
		return result;
	}

	private static void closeClosable(Closeable reader) {
		if (reader == null)
			return;

		try {
			reader.close();
		} catch (IOException e) {
			// do nothing
		}
	}

我们也能将字符串转成 byte以後，导入 ByteArrayInputStream，再使用 DataInputStream 去读取，范例如下：

	private static void catWithByte(final String filePath) {
		DataInputStream dis = new DataInputStream(new ByteArrayInputStream(cat(filePath).getBytes()));
		char c = 0;
		try {
			while (dis.available() > 0) {
				c = (char) dis.readByte();
				System.out.print(c);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

储存文件，有分成二种，以 Binary 的方式或者是以可读字符串内容的方式，先介绍用可读字符串内容的写入档案的方式，从下面的范例可以看出，首先是用 FileWriter开启一个新档案准备写入，再使用 BufferWriter 来作缓存，最後再使用 PrintWriter 以可读性较佳的方式一一写入。PrintWriter有一个很方便的构造函数，就是将缓存及写入档案的这二个过程封装起来了，如下：

	private static void saveFile(final String oldFilePath, final String newFilePath) {
		BufferedReader br = null;
		PrintWriter pw = null;

		try {
			String s = "";
			br = new BufferedReader(new FileReader(oldFilePath));
			// pw = new PrintWriter(new BufferedWriter(new
			// FileWriter(newFilePath)));
			pw = new PrintWriter(newFilePath); // 这样写也行
			int lineNum = 0;
			while ((s = br.readLine()) != null) {
				lineNum++;
				pw.println(lineNum + " " + s);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			closeClosable(br);
			closeClosable(pw);
			System.out.println("Save File Finished!");
		}
	}

以 Binary 的方式写入的话，就需要用到 “Stream” 的方式，从 FileOutputStream，BufferedOutputStream, 一直到将数据写入的 DataOutputStream。

这边需要注意的是，写入和读取的类型顺序一致很重要，如下，如果不一致的话，便会有 EOFException。

	private static void saveFile2(final String newfilePath) {
		DataOutputStream out = null;
		DataInputStream in = null;
		try {
			out = new DataOutputStream(new BufferedOutputStream(
					new FileOutputStream(newfilePath)));
			out.writeUTF("===Test Content===");
			out.writeInt(123);
			out.writeFloat(1.0f);
			out.writeDouble(1.1232);
			out.close();

			in = new DataInputStream(new BufferedInputStream(new FileInputStream(newfilePath)));
			System.out.println(in.readUTF()); // 顺序一换，就会有 EOFException
			System.out.println(in.readInt());
			System.out.println(in.readFloat());
			System.out.println(in.readDouble());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			closeClosable(out);
		}
	}

System.in 和 System.out

标准输入(Standard input)即为程序(Program)所使用的数据流，所有程序的输入来自於标准输入；而所有程序的输出，可以导致标准输出(Standard output)；
所有错误讯息可以导致 Standard Error。一个程序的 Standard output 可以成为另一个程序的 Standard input 这是一个很强大的工具。
比如说下面是将输入存至某路径的涵数：

	public static void getInputAndSave(final String newFilePath) {
		BufferedReader br = null;
		PrintWriter pw = null;
		br = new BufferedReader(new InputStreamReader(System.in));
		String s = "";
		try {
			pw = new PrintWriter(newFilePath);
			while ((s = br.readLine()) != null) {
				pw.println(s);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			closeClosable(br);
			closeClosable(pw);
		}
	}