Java I/O(一)--字节流，字符流

一、File类

File类既能代表一个特定文件的名称，又能代表一个目录下的一组文件的名称，它是java.io包下代表与平台无关的文件和目录，也就是说程序中操作文件和目录，都可以通过File类实现。如果指的是一个文件集，我们可以对此集合调用list()方法，这个方法将返回一共为字符串数组，注意这里返回的并不是一个泛型类，这里的元素个数是可以确定的。

需要说明的是删除非空文件夹需要从最内部递归删除，不能直接删除。

常见的文件操作代码：

import java.io.File;

public class FileDeleteDemo {
	/**
	 * window下文件删除需要进入最内层，从内向外删除
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		File dir = new File("D:\\JAVA2");
		removeall(dir);
	}

	/**
	 * 递归的进入文件夹内部
	 * @param dir
	 */
	private static void removeall(File dir) {
		File[] namesFiles = dir.listFiles();

		for (File name : namesFiles) {
			if (name.isDirectory()) {
				removeall(name);
			} else {
				System.out.println(name + " : " + name.delete());
			}
		}
		System.out.println(dir + " : " + dir.delete());
	}
}

二、字符流

Java 内用 默认采用Unicode 编码存储字符，字符流处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符流之间的转换。字符流只适合于文本数据流的传输，因为在传输过程中字符流会对数据进行编码与译码操作，非字符流数据会在这个转换过程中出错，因此不要采用字符流进行非文本文件的处理。

几乎所有的Java IO流类都有相应的Reader和Writer类来提供天然的Unicode操作。可见Reader和Writer类是针对字符流处理的，（其子类后缀名均为Reader或Writer，前缀为流对象的主要功能）。

Reader：读取字符流的抽象类。

|--BufferReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

|--LineNumberReader：跟踪行号的缓冲字符流。

|--InputStreamReader：字节流向字符流转换的桥梁。

|--FileReader：用来读取字符文件的类。

|--CharArrayReader:

|--StringReader:

Writer：写入字符流的抽象类。

|--BufferWriter：将文本写入字符输出流，缓冲各个字符，从而实现单个字符、数组、字符串的高效写入。

|--OutputStreamReader：字符流向字节流转换的桥梁，缓冲各个字符，从而实现字符、数组和行的高效写入。

|--FilerWriter：用来写入字符文件的类。

|--CharArrayWriter:

|--StringReader:

|--PrintWriter:

1、关于字符流的读写操作：

    写入字符流时必须要明确被操作的文件，目录下如果已有同名文件，在Writer方法不采用具有刷新功能时，则同名文件将被覆盖。Writer方法不采用具有刷新功能时，可调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。

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

public class FileWriteDemo {

	/**
	 * @param args
	 * @throws IOException
	 * @throws InterruptedException
	 */
	public static void main(String[] args) {
		FileReader fileReader = null;
		FileWriter fileWriter = null;
		try {
			fileReader = new FileReader(new File("Read.txt"));
			fileWriter = new FileWriter(new File("write.txt"));

			char[] buf = new char[1024];
			int key = 0;

			while ((key = fileReader.read(buf)) != -1) {
				fileWriter.write(buf, 0, key);
			}
		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		} finally {
			try {
				if (fileReader != null) {
					fileReader.close();
				}
				if (fileWriter != null) {
					fileWriter.flush();
					fileWriter.close();
				}

			} catch (Exception e) {
				throw new RuntimeException(e.toString());
			}
		}

		Runtime runtime = Runtime.getRuntime();
		try {
			Process p = runtime.exec("notepad.exe write.txt");
			Thread.sleep(2000);
		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		}
	}
}

但是当Writer方法采用自动刷新时，每次写入的内容将在原油内用的基础上进行添加，不会将原有内容覆盖。

流资源必须得到释放。调用close方法，关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。

2、字符流的性能改善：字符流缓冲区BufferedWriter和BufferedReader

缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象，即先将流对象初始化到构造函数中。数据写入时，可以先将数据缓冲到数组，将数据存入，在一次性取出（缓冲区的大小一般为1024的整数倍）。

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

public class FileBufferWriterDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new FileReader("Read.txt"));
			bufferedWriter = new BufferedWriter(new FileWriter("write.txt"));

			String str = null;

			while ((str = bufferedReader.readLine()) != null) {
				bufferedWriter.write(str);
				bufferedWriter.newLine();
				bufferedWriter.flush();
			}

		} catch (IOException e) {
			throw new RuntimeException(e.toString());
		} finally {
			try {
				if (bufferedReader != null) {
					bufferedReader.close();
				}
				if (bufferedWriter != null) {
					bufferedWriter.close();
				}
			} catch (Exception e) {
				throw new RuntimeException(e.toString());
			}
		}

		Runtime runtime = Runtime.getRuntime();
		try {
			Process p = runtime.exec("notepad.exe write.txt");
			Thread.sleep(2000);
		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		}
	}
}

当数据读取时可以一次性读取一行，即采用readline方法，当采用该方法返回null时即读取结束。

三、字节流

字节流适合任意类型数据的处理，因为字节流本身是按照按位处理的思想，因此在处理过程中不会对数据进行更改。InputStream和 OutputStream是针对字节流处理的，（其子类后缀名均为Reader或Writer，前缀为流对象的主要功能）。

由于字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。可直接将字节写入到指定文件中，因此字节流的处理过程中不存在刷新的问题。

InputStream：

|--FileOutputStream

|--FileterOutputStream

1、关于字节流的读写操作：

字节流不存在译码编码操作，也不存在刷新问题，因此直接进行文件处理即可。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileInputDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream = null;
		try {
			fileInputStream = new FileInputStream(new File("Read.txt"));
			fileOutputStream = new FileOutputStream(new File("write.txt"));

			int key = 0;

			while ((key = fileInputStream.read()) != -1) {
				fileOutputStream.write(key);
			}

		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		} finally {
			try {
				if (fileInputStream != null) {
					fileInputStream.close();
				}
				if (fileOutputStream != null) {
					fileOutputStream.close();
				}
			} catch (Exception e) {
				throw new RuntimeException(e.toString());
			}
		}

		Runtime runtime = Runtime.getRuntime();
		try {
			Process p = runtime.exec("notepad.exe write.txt");
			Thread.sleep(2000);
		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		}
	}
}

2、字节流的性能改善--字节流缓冲区： 

定义一个固定长度的byte数组（长度一般为1024的整数倍），read方法返回的是读取到的数据长度，直到返回值为0时读取操作结束。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileByteArrayInputDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream = null;
		try {
			fileInputStream = new FileInputStream(new File("Read.txt"));
			fileOutputStream = new FileOutputStream(new File("write.txt"));

			int key = 0;
			byte[] buffer = new byte[1024];

			while ((key = fileInputStream.read(buffer)) != -1) {
				fileOutputStream.write(buffer, 0, key);
			}

		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		} finally {
			try {
				if (fileInputStream != null) {
					fileInputStream.close();
				}
				if (fileOutputStream != null) {
					fileOutputStream.close();
				}
			} catch (Exception e) {
				throw new RuntimeException(e.toString());
			}
		}

		Runtime runtime = Runtime.getRuntime();
		try {
			Process p = runtime.exec("notepad.exe write.txt");
			Thread.sleep(2000);
		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		}

	}

}

    3、 字节流的性能改善：字节流缓冲区B ufferedInputStream和BufferedOutputStream

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

public class FileBufferInputDemo {
	public static void main(String[] args) {

		BufferedInputStream buInputStream = null;
		BufferedOutputStream bufferedOutputStream = null;
		try {

			buInputStream = new BufferedInputStream(new FileInputStream(
					"Read.txt"));
			bufferedOutputStream = new BufferedOutputStream(
					new FileOutputStream("write.txt"));

			byte[] buffer = new byte[1024];

			int len = 0;

			while ((len = buInputStream.read(buffer)) != -1) {
				bufferedOutputStream.write(buffer, 0, len);
			}
		} catch (Exception e) {
			throw new RuntimeException(e.toString());
		} finally {
			try {
				if (buInputStream != null) {
					buInputStream.close();
				}
				if (bufferedOutputStream != null) {
					bufferedOutputStream.close();
				}
			} catch (Exception e) {
				throw new RuntimeException(e.toString());
			}
		}

	}
}