关于IO流读取文件

IO分为字节流和字符流：
字节流：
<-- FileInputStream
inputStream
<-- BufferedInputStream
字节文件操作流：
方法一：

InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
int i = 0;
 //一次读取一个字节
while ((i = inputStream.read()) != -1) {
System.out.print((char)i);
}

方法二：

InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
// 字节数组
byte[] b = new byte[2];
//一次读取一个字节数组
while ((i2 = inputStream2.read(b)) != -1){
System.out.print(new String(b);
}

字节缓冲流：高效

// 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream in)
// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)
方法一：
InputStream in = new FileInputStream("test.txt");
// 字节缓存流
BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1){
System.out.print(new String(bs, 0, len));
}

字符流：
<–InputStreamReader转换流 <-- FileReader
Reader
<-- BufferedReader
字符转换流：

//使用默认编码  
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
int len;
while ((len = reader.read()) != -1){
System.out.print((char) len);
}
//指定编码 
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
注：Eclipse默认使用GBK编码,test.txt文件所以是GBK编码，当指定utf-8编码时所以会乱码。

字符缓冲流：高效

//生成字符缓冲流对象
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
String str;
//一次性读取一行
while ((str = reader.readLine()) != null) {
System.out.println(str);
}

InputStream转String：

public static String inputStream2Str(InputStream is) throws IOException {
	StringBuffer sb;
	BufferedReader br = null;
	try {
		br = new BufferedReader(new InputStreamReader(is));
		sb = new StringBuffer();
		String data;
		while ((data = br.readLine()) != null) {
			sb.append(data);
		}
	} finally {
		br.close();
	}
	return sb.toString();
}

InputStream转File：

public static void inputStream2File(InputStream is, File file) throws IOException {
	OutputStream os = null;
	try {
		os = new FileOutputStream(file);
		int len = 0;
		byte[] buffer = new byte[8192];
		while ((len = is.read(buffer)) != -1) {
			os.write(buffer, 0, len);
		}
	} finally {
		os.close();
		is.close();
	}
}

读取文件：

public static void main(String[] args) {
	int num = 0;
	char[] buf = new char[1024];
	byte[] bf = new byte[2];
	try {
			
		InputStream inputStream = new FileInputStream(new File("D://a.txt"));
		BufferedInputStream bis = new BufferedInputStream(inputStream);
		
		InputStreamReader reader = new InputStreamReader(new FileInputStream("D://a.txt"),"gbk");
		InputStreamReader input = new InputStreamReader(inputStream);
		reader.read(buf);
		System.out.println(buf);
		bis.read(bf);
		
		System.out.println(bf);
		
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

文件生成：

public static void main(String[] args) {
	List a = new ArrayList();
	  File f1 = new File("E://aaa//bbb");  
      if (!f1.exists()) {  
          f1.mkdirs();  
      }  
      // f1.mkdirs(); 生成所有目录  
      // f1.mkdir(); 必须AAA目录存在才能生成BBB目录  
      File f2 = new File("E://aaa//bbb//c.txt");  
      if (!f2.exists()) {  
          // 不能生成目录，只能创建文件，且/aaa/bbb目录必须存在  
          try {
			f2.createNewFile();
		} catch (IOException e) {
			e.printStackTrace();
		}  
      }  
}

OutputStreamWriter类输出文件

InputStreamReader reader = new InputStreamReader(new FileInputStream("D://a.txt"),"gbk");
BufferedReader bufferedReader = new BufferedReader(reader);
reader.read(buf);
System.out.println(buf);
//1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("D://b.txt"));

//2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
outputStreamWriter.write(buf);
//outputStreamWriter.write("hello");

//3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
outputStreamWriter.flush();

//4.释放资源
outputStreamWriter.close();

注意事项
outputStreamWriter.flush();一定要写flush()方法，不然会是个空文件
因为这是一个缓冲流，数据先输入到内存缓冲区里，在使用缓冲流时，数据都是先放在缓冲区中，如果不手动 flush() 或者close() 或者缓冲区不满，数据是无法写到指定位置的，所以对于缓冲流，在最后最好要记得flush()，类似的缓冲流还有 PrintWriter，BufferedWriter