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

你的名字 2022-05-09 15:04 257阅读 0赞

#### 基本概念 ####

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();
    		}	
    	}
    }