黑马程序员_java IO总结

                                                        --------------android培训、java培训、期待与您交流！ --------------

一、IO流概述

IO（Input/Output，输入/输出）流提供了一条通道程序，可以通过这一通道将数据送到目的地。虽然IO流通常与文件读取有关，但是程序的源和目的地也可以是内存、显示器窗口等等。

Java由数据流处理输入输出模式，程序从指向源的输入流中读取源中的数据；

输出流的指向是数据要到达的目的地，程序通过向输出流中写入数据把信息传递到目的地。

IO流体系
   |─字符流 JDK1.1
   |       |─Writer 写入流
   |       |       |─PrintWriter 字符打印流                                         
   |       |       |─StringWriter 字符串写入流                                    
   |       |       |─BufferedWriter 字符写入流缓冲区                                 
   |       |       |─CharArrayWriter 字符数组写入流缓冲区              
   |       |      └─OutputStreamWriter 字符转换字节流                  
   |       |                 └-FileWriter 字符文件写入流                         
   |       |
   |      └─Reader 读取流
   |              |-StringReader 字符串读取流 
   |              |-BufferedReader 字符读取流缓冲区 
   |              |        └─LineNumberReader 跟踪行号的缓冲字符输入流
   |              |-CharArrayReader 字符数组读取流缓冲区 
   |             └─InputStreamReader 字节转换字符流
   |                       └─FileReader 字符文件读取流 
   |
   |─字节流 JDK1.0
   |       |─InputStream 输入流
   |       |        |─FileInputStream 文件输入流
   |       |        |─PipedInputStream 管道输入流
   |       |        |─ObjectInputStream 对象输入流
   |       |        |─SequenceInputStream 合并输入并流
   |       |        |─ByteArrayInputStream 字节数组输入流缓冲区
   |       |       └─FilterInputStream
   |       |                  |─DataInputStream 数据输入流
   |       |                 └─BufferedInputStream 字节输入流缓冲区
   |       |
   |      └─OutputStream 输出流
   |                 |─FileOutputStream 文件输出流 
   |                 |─PipedOutputStream 管道输出流 
   |                 |─ObjectOutputStream 对象输出流 
   |                 |─ByteArrayOutputStream 字节数组输出流缓冲区 
   |                └─FilterOutputStream
   |                            |─DataOutputStream 数据字节输出流 
   |                           └─BufferedOutputStream 字节输出流缓冲区                                    
  └─File 类

按操作数据来区分为两种：字符流、字节流。

  解析：处理文本文件数据的时候一般会选择字符流，一般来说音乐、图像、流媒体文件都用字节流来读。
。字符流（一次可以处理一个缓冲区）一次操作比字节流（一次一个字节）效率高

按流向区分：输入流，输出流。

IO流常用基类（后缀）：

字节流抽象基类：InputStream 输入（读操作） 、OutputStream 输出（写操作）

字符流的抽象基类：Reader 、Writer

二、File类

File类是java.io包中唯一代表磁盘文件本身的对象。File类定义了一些与平台无关的方法来操作文件，可以调用File类中的方法，实现创建、删除、重命名文件等操作。数据流可以将数据写入到文件中，文件也是数据流最常用的数据媒体。

1、文件的创建与删除

用File类创建一个文件对象。通常有3种构造方法

（1）File(String pathname)：

pathname指路径名称。

File file=new File("d:/1.txt");

（2）File(String parent,String child)：

parent:父路径字符串

child：字路径字符串：包含文件名

File file =new File("d:/","1.txt");

（3）File(File f,String child)：

f：父路径对象

child：字路径字符串：包含文件名

实例：

当创建一个文件对象，若指定目录不存在文件，则File类对象可调用createNewFile方法创建一个，如果存在，可以将其删除。

import java.io.*;

public class FileTest { // 创建类FileTest
	public static void main(String[] args) { // 主方法
		File file = new File("word.txt"); // 创建文件对象
		if (file.exists()) { // 如果该文件存在
			file.delete(); // 将文件删除
			System.out.println("文件已删除");
		} else { // 如果文件不存在
			try { // try语句块捕捉可能出现的异常
				file.createNewFile(); // 创建该文件
				System.out.println("文件已创建");
			} catch (Exception e) { // catch处理该异常
				e.printStackTrace(); // 输出异常信息
			}
		}
	}
}

2、获取文件信息

File类提供了很多方法用于获取文件的信息。

getName：获取文件名称

canRead：判断文件是否可读

canWrite：判断文件是否可写

exits：判断文件是否存在

length：返回文件长度（字节为单位）

isHidden：判断文件是否隐藏文件

import java.io.*;

public class FileTest { 
	public static void main(String[] args) {
		File file = new File("word.txt"); // 创建文件对象
		if (file.exists()) { // 如果文件存在
			String name = file.getName(); // 获取文件名称
			long length = file.length(); // 获取文件长度
			boolean hidden = file.isHidden(); // 判断文件是否是隐藏文件
			System.out.println("文件名称：" + name); 
			System.out.println("文件长度是：" + length);
			System.out.println("该文件是隐藏文件吗？" + hidden);
		} else { // 如果文件不存在
			System.out.println("该文件不存在"); 
		}
	}
}

三、文件输入输出流

1、FileInputStream与FileOutputStream类

FileInputStream与FileOutputStream类都用来操作磁盘文件。

FileInputStream类用来读入，FileOutputStream类用于写出

这两个类都只提供了对字节或字节数组的读取方法。

import java.io.*;

public class FileTest { 
	public static void main(String[] args) { 
		File file = new File("d:/word.txt"); // 创建文件
		try { 
			// 创建FileOutputStream对象
			FileOutputStream out = new FileOutputStream(file);
			// 创建byte型数组
			byte buy[] = "java IO流测试".getBytes();
			out.write(buy); // 将数组中信息写入到文件中
			out.close(); // 将流关闭
		} catch (Exception e) { 
			e.printStackTrace();
		}
		try {
			// 创建FileInputStream类对象
			FileInputStream in = new FileInputStream(file);
			byte byt[] = new byte[1024]; // 创建byte数组
			int len = in.read(byt); // 从文件中读取信息
			// 将文件中信息输出
			System.out.println("文件中的信息是：" + new String(byt, 0, len));
			in.close(); // 关闭流
		} catch (Exception e) {
			e.printStackTrace(); 
		}
	}
}

2、 FileReader与FileWriter类

由于FileInputStream类和FileOutputStream类这两个类都只提供了对字节或字节数组的读取方法。

在读取汉字的时候可能会出现乱码现象，此时采用字符流Reader和Writer既可避免。

import java.io.*;

public class FileTest { 
	public static void main(String[] args) { 
		File file = new File("d:/word.txt"); // 创建文件
		try { 
			// 创建FileWriter对象
			FileWriter out= new FileWriter(file);
			// 创建char型数组
			String s="java字符IO测试";
			out.write(s); // 信息写入到文件中
			out.close(); // 将流关闭
		} catch (Exception e) { 
			e.printStackTrace();
		}
		try {
			// 创建FileReader类对象
			FileReader in = new FileReader(file);
			char byt[] = new char[1024]; // 创建char数组
			int len = in.read(byt); // 从文件中读取信息
			// 将文件中信息输出
			System.out.println("文件中的信息是：" + new String(byt, 0, len));
			in.close(); // 关闭流
		} catch (Exception e) {
			e.printStackTrace(); 
		}
	}
}

四、带缓存的输入输出流

字符流缓冲区：

对应的类为BufferedWriter、BufferedReader

缓冲区要结合流才能使用，在创建缓冲区之前，必须要有流对象。

优点：增加了对数据的读写效率。

写操作步骤：

（1）创建一个字符写入流操作对象（fw）；

（2）（创建一个BuferedWriter对象bufw）然后将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可

（3）通过缓冲的bufw.write（）方法写入数据，提供一个跨平台的newLine()换行符

（4）刷新流bufw.flush();切记只要用到缓冲区必须要刷新

（5）关闭缓冲区bufw.close()

（6）关闭流资源fw.close()

字符流缓冲区读操作：

步骤：

（1）创建一个读取流对象和文件相关联；

（2）加入缓冲技术，将字符读取流对象作为参数传递给创建的缓冲对象的构造函数（同写操作）

（3）调用缓冲技术里面的readLine来读取一行的数据，写一个while循环来读取大量数据，当readLine()达到末尾就返回null;

（4）打印读取的数据

（5）关闭缓冲区流bufr.close()

（6）关闭流资源fw.close()

实例：

import java.io.*;

public class Student { 
	public static void main(String args[]) {
		// 定义字符串数组
		String content[] = { "java", "IO", "测试" };
		File file = new File("d:/word.txt"); // 创建文件
		try {
			FileWriter fw = new FileWriter(file); // 创建FileWriter类对象
			// 创建BufferedWriter类对象
			BufferedWriter bufw = new BufferedWriter(fw); 
			for (int k = 0; k < content.length; k++) { // 循环遍历数组
				bufw.write(content[k]); // 将字符串数组中元素写入文件中
				bufw.newLine(); // 输入换行符，将数组中的单个元素以单行的形式写入文件
			}
			bufw.close(); // 将BufferedWriter流关闭
			fw.close(); // 将FileWriter流关闭
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			FileReader fr = new FileReader(file); // 创建FileReader类对象
			// 创建BufferedReader类对象
			BufferedReader bufr = new BufferedReader(fr);
			String s = null; 
			int i = 0; 
			// 如果文件的文本行数不为空,则进入循环
			while ((s = bufr.readLine()) != null) { 
				i++; // 将变量做自增运算
				System.out.println("第" + i + "行:" + s); // 输出文件数据
			}
			bufr.close(); // 将FileReader流关闭
			fr.close(); // 将FileReader流关闭
		} catch (Exception e) { // 处理异常
			e.printStackTrace();
		}
	}
}

实例2：

通过缓冲区复制一个.java文件数据到一个.txt文件里。

import java.io.*;

class CopyTextByBuf{
	public static void main(String[] args) throws IOException{
      //创建读取缓冲和写入缓冲对象引用
  	BufferedReader bufr = null;
  	BufferedWriter bufw = null;    
  	try{
          //创建对象实体
      	bufr = new BufferedReader(new FileReader("d:/IODemo.java"));
      	bufw = new BufferedWriter(new FileWriter("d:/IODemo_Copy.txt"));    
      	
           	//初始化行为null。line相当于一个中转站
      		//读取流中的行字符串，赋给line。直到line不为null
          	String line = null;
      		while((line=bufr.readLine())!=null){
          	bufw.write(line); //写入一行字符
          	bufw.newLine();  //换行
          	bufw.flush();   //刷新写入流对象
          }
      }
  	catch (IOException e){
      	throw new RuntimeException("读取失败");
      }
  	finally{
      	try{
          	if(bufr!=null)      //如果读取流对象不为null
              	bufr.close();  //则关闭读取流资源
          }
      	catch (IOException e){
          	throw new RuntimeException("读取流关闭失败");
          }
       	try{
          	if(bufw!=null)     //如果写入流对象不为null
              	bufw.close(); //则关闭写入流资源
          }
      	catch (IOException e){
          	throw new RuntimeException("写入流关闭失败");
          }
      }
  }
}