java面向对象——IO流：File类

基本概念

I/O就是Input/Output的简写，也就是输入/输出的含义。 I/O流就是指像流水一样不间断地进行读写的过程。

按照读写单位的不同分为：
字节流 - 主要指以字节为单位进行读写的流，可以用于任何文件的读写操作。
字符流 - 主要指以字符(2字节)为单位进行读写的流，只能用于文本文件的读写操作
按照数据流动方向的不同分为：
输入流 - 主要指读取文件中的内容输入到程序中，也就是读文件。
输出流 - 主要指将程序中的数据输出到文件中，也就是写文件。

I/O流的层次结构

字节流的顶层类：InputStream类 和 OutputStream类。

InputStream类的主要实现子类：

FileInputStream类、DataInputStream类(间接子类)、ObjectInputStream类。

OutputStream类的主要实现子类：

FileOutputStream类、DataOutputStream类(间接子类)、ObjectOutputStream类。

字符流的顶层类：Reader类 和 Writer类。

Reader类的主要实现子类有：

BufferedReader类、InputStreamReader类、StringReader类。

Writer类的主要实现子类有：

BufferedWriter类、OutputStreamWriter类、StringWriter类。

补充：java.io.PrintStream类是OutputStream类间接子类，通常与BufferedReader搭配使用

File类

java.io.File类用于描述文件和文件的路径信息，可以获取文件的大小等属性信息。

常用的方法

File(String pathname) - 用于根据参数指定的路径名来构造对象
boolean exists() - 用于判断调用对象所代表的文件或目录是否存在
String getName() - 用于获取调用对象所代表的文件或目录的名称
long length() - 用于获取文件的长度/大小
String getAbsolutePath() - 用于获取抽象路径名的绝对路径信息并返回
	绝对路径 - 主要指从根目录开始的路径。如：C:/  D:/  ...
	qa相对路径 - 主要指从当前目录开始的路径。如:.代表当前目录 ..代表上一级目录 
               - 以后的开发中推荐采用相对路径。
long lastModified() - 用于获取最后一次修改时间。返回距离1970年的毫秒数，与Date类中构造搭配使用.
boolean delete() - 用于删除调用对象代表的文件或目录。
boolean createNewFile() - 用于创建新的空文件。

File[] listFiles() - 用于获取调用对象所关联目录中的所有内容。
boolean isFile() - 用于判断是否为一个文件。
boolean isDirectory() - 用于判断是否为一个目录。

FileOutputStream类(重中之重)

java.io.FileOutputStream类用于将图像数据之类的原始字节流写入输出流中。

   FileOutputStream(String name) - 根据参数指定的路径名来构造对象并关联起来。
   FileOutputStream(String name, boolean append) - 以追加的方式构造对象。
   void write(int b) - 用于将参数指定的单个字节写入输出流。
   void write(byte[] b) - 用于将参数指定的字节数组内容全部写入输出流中。
   void write(byte[] b, int off, int len) - 用于将数组中一部分内容写入输出流。
   void close() - 关闭输出流并释放有关的资源.

FileInputStream类(重中之重)

java.io.FileInputStream类用于读取图像之类的原始字节流。

FileInputStream(String name) - 根据参数指定的路径名来构造对象与之关联。
int read() - 用于从输入流中读取一个字节的数据并返回，若读取到文件尾则返回-1
int read(byte[] b) - 用于从输入流中读满整个参数指定的数组。
   - 若读取到文件尾则返回-1，否则返回实际读取到的字节数。
int read(byte[] b, int off, int len) - 读取len个字节到数组b中。
int available() - 用于获取调用对象所关联文件的大小并返回。
void close() - 关闭输入流并释放资源。

DataOutputStream类(熟悉)

java.io.DataOutputStream类用于将java语言中基本数据类型的数据写入到输出流中

DataOutputStream(OutputStream out) - 根据参数指定的引用来构造对象。
  - 其中OutputStream类是个抽象类，因此实参需要传递子类的对象。
void writeInt(int v) - 用于将参数指定的整数数据写入到输出流中。
void close()

DataInputStream类(熟悉)

java.io.DataInputStream类用于从输入流中读取基本数据类型的数据内容。

DataInputStream(InputStream in) - 根据参数指定的引用来构造对象。
  - 其中InputStream类是个抽象类，因此实参需要传递子类的对象。
int readInt() - 用于从输入流中读取一个整数并返回。
void close()

BufferedReader类(重点)

java.io.BufferedReader类用于读取单个字符、字符数组以及一行字符串的场合。

BufferedReader(Reader in) - 根据参数指定的引用来构造对象。
   - 其中Reader类是个抽象类，实参需要传递子类的对象。
String readLine() - 用于读取一行字符串内容并返回。
void close() 

PrintStream类(重点)

java.io.PrintStream类是用于打印各种数据类型的数据内容。

PrintStream(OutputStream out) - 根据参数指定的引用构造对象。
  - 其中OutputStream类是个抽象类，实参需要传递子类的对象。
void println(String x) - 用于打印字符串并换行。
void close()

ObjectOutputStream类(重点)

java.io.ObjectOutputStream类用于将对象整体写入到输出流中。

只能将支持 java.io.Serializable 接口的对象写入流中。
类通过实现 java.io.Serializable 接口以启用其序列化(将一个对象中的所有内容转换为字节序列的过程)功能。

序列化：将Object转换为byte序列，就是序列化，反之叫反序列化

(2)常用的方法

ObjectOutputStream(OutputStream out) - 根据参数指定的引用来构造对象。
	其中OutputStream类型是个抽象类，实参需要传递子类的对象。
void writeObject(Object obj) - 用于将参数指定的对象整体写入到输出流中。
void close()

ObjectInputStream类(重点)

java.io.ObjectInputStream类用于从输入流中整体读取一个对象。

常用的方法

ObjectInputStream(InputStream in) - 根据参数指定的引用来构造对象。
	其中InputStream类是个抽象类，实参需要传递子类的对象。
Object readObject() - 用于读取一个对象并返回。【无法根据返回值来判断是否读取到文件的末尾】
void close()

经验：

当需要向文件中写入多个对象时，通常建议将这些对象先放入到一个集合中，将整个集合看做一个整体写入文件中，此时读取文件中的数据只需要调用一次readObject()方法就可以读出所有内容。

文件创建

public class TestFile {
	public static void show(File f){
		System.out.println(f.getName());
		System.out.println(f.length()+"字节");
		System.out.println(f.getAbsolutePath());
		Date d = new Date(f.lastModified());
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(sdf.format(d));
		
	}
	public static void main(String[] args) {
		File f1 = new File("d:/a.txt");
		if(f1.exists())
			show(f1);
		else{
			try {
				f1.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if(f1.exists()){
				System.out.println("文件创建成功");
				show(f1);
			}
		}
	}
}

目录查看

public class TestFile {
	public static void main(String[] args) {
		File f2 = new File("D:/java");
		File[] ff = f2.listFiles();
		for(File f : ff){
			if(f.isDirectory())
				System.out.println("["+f.getName()+"]");
			else
				System.out.println(f.getName());
		}
	}
}

文件拷贝

public class CopyFile {
	public static void main(String[] args) {
		try {
			//创建FileInputStream类型的对象与被拷贝的源文件关联 
			FileInputStream fis = new FileInputStream("d:/a.txt");
			//创建FileOutputStream类型的对象与拷贝的目标文件关联
			FileOutputStream fos = new FileOutputStream("d:/b.txt");
			//不断的从源文件中读取写入到目标文件中
			System.out.println("正在玩命的拷贝...");
			byte[] data = new byte[1024*8];
			int res = 0;
			while((res = fis.read(data)) != -1){	//从输入流中读满整个参数指定的数组大小
				fos.write(data,0,res);
			}
			System.out.println("文件拷贝成功！");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

文件读写

public class TestFileStream {
	public static void main(String[] args) {
		try {
			//创建FileOutputStream类型的对象与d:/a.txt文件关联
			FileOutputStream fos = new FileOutputStream("d:/a.txt");		//覆盖
			//FileOutputStream fos = new FileOutputStream("d:/a.txt",true);  //追加
			for(int i = 1;i<6;i++){
				fos.write(i+48);		//写入
			}
			fos.write("Hello".getBytes());	//将字符串写入到文件中，则需要调用字符串转换成字符数组
			System.out.println("写入数据成功");
			fos.close();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		//----------------------读取文件----------------------
		try {
			FileInputStream fis = new FileInputStream("d:/a.txt");
			int res = 0;
			while((res = fis.read())!= -1){
				System.out.print((char)res);
			}
			fis.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

对象写入文件

public class UserTestObjectOutputStream {
	public static void main(String[] args) {
		User u = new User("liubin","123456","liubin2048@163.com");
		try {
			//构造ObjectOutputSteam类型的对象与d:/a.txt文件关联
			ObjectOutputStream oos = new ObjectOutputStream(
					new FileOutputStream("d:/a.txt"));
			//将User类型的对象整体写入到文件中
			oos.writeObject(u);
			System.out.println("写入数据成功！");
			
			ObjectInputStream ois = new ObjectInputStream(
					new FileInputStream("d:/a.txt"));
			System.out.println("读出数据：" + ois.readObject());
			
			oos.close();
			ois.close();
		} 
		catch (Exception e) {
			e.printStackTrace();
		}	
	}
}