Java文件对象和流

File类

	File f1 = new File("路径");  //创建文件对象
	File f2 = new File(f1,"路径");  //通过给定的父抽象路径名和子路径名字符串创建一个新的File实例

File对象的操作

	public String getName()
	//返回由此抽象路径名表示的文件或目录的名称。

	public String getParent()
	//返回此抽象路径名的父路径名的路径名字符串，如果此路径名没有指定父目录，则返回 null。

	public File getParentFile()
	//返回此抽象路径名的父路径名的抽象路径名，如果此路径名没有指定父目录，则返回 null。
 	
	public String getPath()
	//将此抽象路径名转换为一个路径名字符串。

	public boolean isAbsolute()
	//测试此抽象路径名是否为绝对路径名。
	
	public String getAbsolutePath()
	//返回抽象路径名的绝对路径名字符串。
	
	public boolean canRead()
	//测试应用程序是否可以读取此抽象路径名表示的文件。
	
	public boolean canWrite()
	//测试应用程序是否可以修改此抽象路径名表示的文件。
	
	public boolean exists()
	//测试此抽象路径名表示的文件或目录是否存在。
	
	public boolean isDirectory()
	//测试此抽象路径名表示的文件是否是一个目录。
	
	public boolean isFile()
	//测试此抽象路径名表示的文件是否是一个标准文件。
	
	public long lastModified()
	//返回此抽象路径名表示的文件最后一次被修改的时间。
	
	public long length()
	//返回由此抽象路径名表示的文件的长度。
	
	public boolean createNewFile() throws IOException
	//当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。
	
	public boolean delete()
	// 删除此抽象路径名表示的文件或目录。
	
	public void deleteOnExit()
	//在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。

	public String[] list()
	//返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。
	*返回值是字符串数组!!!
	
	public String[] list(FilenameFilter filter)
	//返回由包含在目录中的文件和目录的名称所组成的字符串数组，这一目录是通过满足指定过滤器的抽象路径名来表示的。
	
	public File[] listFiles()
    //返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。

	public File[] listFiles(FileFilter filter)
	//返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。

	public boolean mkdir()
	//创建此抽象路径名指定的目录。
	
	public boolean mkdirs()
	//创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。
	
	public boolean renameTo(File dest)
	//重新命名此抽象路径名表示的文件。
	
	public boolean setLastModified(long time)
	//设置由此抽象路径名所指定的文件或目录的最后一次修改时间。

	public boolean setReadOnly()
	//标记此抽象路径名指定的文件或目录，以便只可对其进行读操作。

	public static File createTempFile(String prefix, String suffix, File directory) throws IOException
	//在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
	//例: f.createTempFile("txt","h",f)

	public static File createTempFile(String prefix, String suffix) throws IOException
	//在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

	public int compareTo(File pathname)
	//按字母顺序比较两个抽象路径名。
	
	public int compareTo(Object o)
	//按字母顺序比较抽象路径名与给定对象。

	public boolean equals(Object obj)
	//测试此抽象路径名与给定对象是否相等。

	public String toString()
	//返回此抽象路径名的路径名字符串。

关于getParentFile().mkdirs()

	File f = new File("D:/Java/j.txt");
	f.getParentFile().mkdirs();
	// D:/Java只是一个抽象路径, 只有真正需要在输入输出的时候才会进入该路径. 而getParentFile返回了父级对象(即D:/Java),mkdirs创建的该路径(当这个路径是不存在时创造)

字节流

流通常指的是输入/输出流, 而非Java的流库.
在Java API中, 可以从其中读入一个字节序列的对象称做输入流, 反向即为输出流. 这些字节序列通常是文件, 也可以是网络连接,内存块.

输入/输出(I/O)类层次的基础是抽象类InputStream和OutputStream.

字节流读取文件

	public static void main(String[] args) {
		try {
			File f = new File("D:/Java_file/h.txt");
			FileInputStream fis = new FileInputStream(f);
			//创建字节数组，其长度就是文件的长度
			byte[] all = new byte[(int)f.length()];
			//以字节流的形式读取文件所有内容
			fis.read(all);
			for(byte b:all) {
				System.out.println(b);
				//打印文件内容对应的ASCCII码
			}
			fis.close();//关闭流
		}
		catch(IOException e) {
			e.printStackTrace();
		}
//FileInputStream一定要在try中, 不然会报错

字节流写入数据

	public static void main(String[] args) {
		try {
			File f = new File("D:/Java_file/h.txt");
			byte data[]= {65,1};
			FileOutputStream fis = new FileOutputStream(f);
			fis.write(data);
			System.out.println("");
			fis.close();
		}
		catch(IOException e) {
			e.printStackTrace();
		}

在写入数据时, 如果文件路径的文件是不能存在的, 它会自动创建该文件

使用字节流拆分合并文件

字符流

字符流与字节流方法相同,只是用到了不同的类
读取字符

	public static void charOutput(File f) {		//FileReader 是Reader子类
		try(FileReader fr = new FileReader(f)){	// 创建基于文件的Reader
			char[] all = new char[(int)f.length()];
			fr.read(all);
			for(char a:all) {
				System.out.print(a);
			}
			
		}
		catch(IOException e) {
			e.printStackTrace();
		}
	}

写入字符

	public static void charInput(String str, File f) {
		try(FileWriter fr = new FileWriter(f)){	// 创建基于文件的Writer
			char[] cs = str.toCharArray(); //将字符串转换为字符数组
			fr.write(cs);
		}
		catch(IOException e) {
			e.printStackTrace();
		}
	}

关于中文字符
和Python类似, 读取的中文采用什么格式的编码, 写入就采用相同格式编码, 这样才能保证中文不乱码.

缓存流

每读写一次都要访问硬盘, 如果读写频率过高,那么就会有问题.
使用缓存流就是囤积一定量再读入写入.

导入包

import java.io.BufferedReader;
import java.io.PrintWriter;

缓存字符输入流 BufferedReader 可以一次读取一行数据
缓存流必须建立在一个存在的流之上

		try (	FileReader fr = new FileReader(f);
                BufferedReader br = new BufferedReader(fr); ){
                while (true) {
                String line = br.readLine();
                if (null == line)break;
                System.out.println(line);
                }  
        catch......

PrintWriter 缓存字符输出流， 可以一次写出一行数据

	try(	FileWriter fr = new FileWriter(f);
			PrintWriter pw = new PrintWriter(fr);){
			pw.println("写入内容");
			pw.flush();
			}

flush会强制把缓存中的数据写入硬盘，无论缓存是否已满
如果不用flush,只有缓存满了才会写入.

数据流

先导入包

import java.io.DataInputStream;
import java.io.DataOutputStream;

使用数据流输出的话, 它只能读取以数据流写入的数据, 否则会出现

写入数据

try (	FileOutputStream fos  = new FileOutputStream(f);
      	DataOutputStream dos =new DataOutputStream(fos);){
            dos.writeBoolean(false);		//写入布尔值
            dos.writeInt(0);				//写入int类型
            dos.writeUTF("hello world!");	//写入字符串
        } catch (IOException e) {
            e.printStackTrace();
        }

读取数据

try (	FileInputStream fis  = new FileInputStream(f);
        DataInputStream dis =new DataInputStream(fis);){
            boolean b= dis.readBoolean();
            int i = dis.readInt();
            String str = dis.readUTF();  
            System.out.print(str+i+b);  //在此处调整输出顺序
        } catch (IOException e) {
            e.printStackTrace();
        }

对象流

关于对象流, 主要功能是序列化对象
这个对象的类必须实现Serializable接口

import java.io.Serializable;
public class tools implements Serializable{
}

实现

		File f = new File("D:/Java_file/kinfe");
		tools kinfe = new hero();
		kinfe.name = "finfe";
//		
		try(FileOutputStream fos = new FileOutputStream(f);
			ObjectOutputStream oos = new ObjectOutputStream (fos);
			FileInputStream fis = new FileInputStream(f);
			ObjectInputStream ois = new ObjectInputStream(fis);){
			oos.writeObject(h);
			tools object1 = (tools)ois.readObject();
			System.out.println(object1.name);
		}
		catch(IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }