文件处理（上）

JAVA学习笔记之文件处理

1 File类

File类是File文件和目录路径名的抽象表示形式。

Java中把文件或者目录（文件夹）都封装成File对象

也就是说，如果我们要去操作硬盘上的文件，或者文件夹，只要找到File这个类即可

1.1File类的构造函数

	File (String pathname):将一个字符串路径封装成File对象
	File(String parent,String child):传入一个父级路径和子级路径
	File(File parent,String Child):传入一个File类型的父级路径和子级路径

1.2案例

		//File (String pathname):将指定的路径名转换成一个File对象
		File f =new File("D:\\filedemo\\a.txt");//'\'是转义字符，在字符串中表示\,需要输入'\\'
		//File(String parent,String child):根据指定的父路径和文件路径创建File对象
		File f1 = new File("D:\\filedemo","a.txt");
		//File(File parent,String Child):根据指定的父路径对象和文件路径创建File对象
		File parent =  new File("D:\\filedemo");
		File f2 = new File(parent,"a.txt");
		File f3 = new File(new File("D:\\filedemo"),"a.txt");//通过匿名内部类

1.3File类的功能及案例

创建功能：

• boolean createNewFile()：当指定文件不存在时创建文件并返回true,否则返回false
• boolean mkdir()：创建目录，创建成功返回true,否则返回false
• boolean mkdirs()

案例

		//File f = new File("D:\\filedemo\\a.txt");绝对路径
	    File f = new File("a.txt");//相对路径,没有盘符
		//oolean createNewFile()：当指定文件不存在时创建文件并返回true,否则返回false
	    System.out.println(f.createNewFile());//返回false，文件已存在
	    File f1 = new File("a");
		//boolean mkdir():创建目录，创建成功返回true,否则返回false
	    System.out.println(f1.mkdir());//返回true并在当前文件目录下创建a文件夹
	    File f2 = new File("b\\c");
		//boolean mkdirs():创建递归文件夹，当文件夹所在的目录不存在，则一并创建
	    System.out.println(f2.mkdirs());//返回true，并创建递归目录

删除功能：

1. boolean delete()：当指定的文件或者文件夹存在时删除文件或者文件夹并返回true,否则放回false；

案例

		//boolean delete():当指定的文件或者文件夹存在时删除文件或者文件夹并返回true,否则放回false；注意：不可以递归删除文件夹，且删除的文件不可恢复
		System.out.println(f2.delete());//返回true,并删除b目录下的c目录

获取功能：

• File getAbsoluteFile():以File对象的形式返回File对象所指向的绝对路径
• String getAbsolutePath():返回File对象所指向的绝对路径
• String getName():获取文件或文件及的名称
• String getParent():返回该对象的父目录(创建该对象时指定的父目录)，没有返回null
• File getParentFile():以File对象的形式返回File对象所指向的父目录
• String getPath():返回创建File对象时给的路径（相对路径或绝对路径）
• long lastModified():以毫秒值的形式返回最后修改的时间
• long length():返回文件的字节数

案例

		File f = new File("a.txt");
		File f1 = new File("a");
		File f2 = new File("D:\\filedemo\\a.txt");
		
		//File getAbsoluteFile():以File对象的形式返回File对象所指向的绝对路径
		System.out.println(f2.getAbsoluteFile());//返回D:\filedemo\a.txt 绝对路径
		//String getAbsolutePath():返回File对象所指向的绝对路径
		System.out.println(f.getAbsoluteFile());//返回E:\WorkSpace\learn\a.txt 绝对路径
		File parent = new File("D:\\filedemo");
		File f3 = new File(parent,"a.txt");
		if (!parent.exists()){
		  parent.mkdirs();//使用mkdirs创建多级目录
		}
		//String getParent():返回该对象的父目录(创建该对象时指定的父目录)，没有返回null
		System.out.println(f3.getParent());//返回指定的父目录D:\filedemo
		//File getParentFile():以File对象的形式返回File对象所指向的父目录
		System.out.println(f1.getParentFile());//返回null，创建时并没有指定该对象的父目录111111
		//String getName():获取文件或文件及的名称
		System.out.println(f.getName());//输入文件名称a.txt
		System.out.println(parent.getName());//输出文件夹名称filedemo
		//String getPath():返回创建File对象时给的路径（相对路径或绝对路径）
		System.out.println(f.getPath());//返回相对路径a.txt
		System.out.println(f2.getPath());//返回绝对路径D:\filedemo\a.txt
		//long lastModified():以毫秒值的形式返回最后修改的时间
		Date date = new Date(f.lastModified());
		System.out.println(date.toLocaleString());
		//Long length():返回文件的字节数
		System.out.println(f.length());//返回8

判断功能

• boolean exists()：判断指定的文件或者文件夹是否存在，存在返回true，否则返回false
• boolean isAbsolute():判断File对象指向的路径是否是绝对路径
• boolean isDirectory():判断该File对象是否是一个文件夹
• boolean isFile():判断该File对象是否是一个文件
• boolean isHidden():判断该File对象是否是隐藏文件

案例

		File f2 = new File("D:\\filedemo\\a.txt");
		File f = new File("a.txt");
		File f1 = new File("a");
		//boolean exists()：判断指定的文件或者文件夹是否存在，存在返回true，否则返回false
		System.out.println(f.exists());//返回true,a.txt文件存在
		//boolean isAbsolute():判断File对象指向的路径是否是绝对路径
		System.out.println(f.isAbsolute());//返回false,该路径相对路径
		System.out.println(f2.isAbsolute());//返回ture,该路径是绝对路径
		//boolean isDirectory():判断该File对象是否是一个文件夹
		System.out.println(f1.isDirectory());
		//boolean isFile():判断该File对象是否是一个文件
		System.out.println(f.isFile());
		//boolean isHidden():判断该File对象是否是隐藏文件
		System.out.println(f.isHidden());

修改功能

• boolean renameTo(File dest): 修改文件名：将当前File对象所指向的路径修改为指定File对象所指向的路径

案例

		File f = new File("a.txt");
		File f1 = new File("a");
		File f2 = new File("D:\\filedemo\\a.txt");
		File f3 = new File("b.txt");
		//boolean renameTo(File dest):修改文件名：将当前File对象所指向的路径修改为指定File对象所指向的路径
		//注意：修改的文件路径不能存在，如果存在，则修改失败。修改文件名
		System.out.println(f.renameTo(f3));//返回true,同时a.txt改名b.txt

重要获取功能

• String[] list():
• File[] listFiles()
• static File[] listRoots

案例

		File f = new File("a.txt");
		File f1 = new File("a");
		File f2 = new File("D:\\filedemo\\a.txt");
		//String[] list():返回当前路径下所有的文件和文件夹名称
		//注意：只有指向文件夹的File对象才能调用该方法
		String[] files = f1.list();
		for (int i = 0; i < files.length; i++) {
		   System.out.println(files[i]);
		}
		//File[] listFiles():以File对象的形式返回当前路径下的所有文件和文件夹
		//与String[] list()区别：list()只能返回文件名称，但是listFiles()返回的file对象可以通过file的方法获取其他数据(如绝对路径等)
		File[] files1 = f1.listFiles();
		for (File file:files1){
		   System.out.println(file.getName());
		}
		//static File[] listRoots():返回根目录
		File[] files2 = File.listRoots();
		for (File file:files2){
		   System.out.println(file);//返回盘符
		}

综合案例

找出指定目录下的所有java文件

		public static void main(String[] args) throws Exception {
	        File f3 = new File("src");
	        find(f3);
	    }	

		private static void find(File file){
        //1.先判断是不是目录
        if (file.isDirectory()){
            //2.获取该目录下的所有文件
            File[] files = file.listFiles();
            //3.循环遍历所有文件，并判断
            for (File f:files){
                //4.判断是否是文件
                if (f.isFile()){
                    //5.判断文件结尾处是否是.java
                    if (f.getName().endsWith(".java")){
                        System.out.println(f.getName());
                    }
                }else {//6.文件夹
                    //7.递归调用方法
                    find(f);
                }
            }
        }

2 IO流

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的类都在IO包中

流按照流向分为两种：

• 输入流：读取数据 FileReader 父类：Reader
• 输出流：写出数据 FileWriter 父类: Writer

流按照数据类型分为两种：

• 字节流：字节输入流：读取数据 InputStream
• 字节流：字节输出流：写出数据 OutputStream
• 字符流：字符输入流：读取数据 Reader
• 字符流：字符输出流：写出数据 Writer

2.1 FileWriter类使用

2.1.1 FileWriter向文件中写数据步骤

		1.使用FileWriter流关联文件
		2.使用FileWriter的写方法写数据
		3.使用FileWriter的刷新方法将数据从内存刷到硬盘上
		4.使用FileWriter的关闭流方法将释放占用的系统底层资源

2.1.2 FileWriter的方法

• FileWriter(String fileName):构造方法，传入一个文件的路径
• void write(String str):向文件中写str
• void flush():将内存中的数据刷新到文件中
• void close():关闭流释放系统底层资源

案例

		//1.创建文件
		File f = new File("a.txt");
		//2.创建文件输出流
		FileWriter fw = new FileWriter(f);
		//3.写入数据
		fw.write("hello world");
		//4.数据并没有直接写到文件，其实写到了内存缓冲区，刷新内存
		fw.flush();//将数据写入到硬盘文件中
		//5.释放资源
		fw.close();

close()和flush()的区别

flush():先刷新缓冲区，流对象还可以继续使用
close():先刷新缓冲区，再释放系统资源，流对象不可再被使用

补充FileWriter的写方法

• void write(String str):写一个字符串数据
• void write(String str,int index,int len):写一个字符串中的一部分数据
• void write(int ch):写一个字符数据，这里写int类型的好处是，既可以写cha类型的数据，也可以写char对应的int类型的值。如’a’ 97
• void write(char[] chs):写一个字符数组数据
• void write(char[] chs,int index,int len):写一个字符数组的一部分数据
• 这里具体方法不做演示，参考上文

2.2 FileReader类使用

2.2.1 FileReder方法

• FileReader(String fileName):构造方法，传入一个文件的路径
• int read():读取单个字符
• int read(char[] cbuf):读取字符，并将字符读入数组

案例

File f = new File("a.txt");
	        //创建输入流对象
	        FileReader fr = new FileReader(f);
	        //调用输入流数据的读数据方法（一次读取一个字符）
	        int ch = fr.read();
	        System.out.println(ch);
	        System.out.println((char)ch);//返回h(上一次输入的hello world)
	        //改进：查看源码，当返回值是-1的时候，说明没有数据了，这就是循环结束的条件
	        int chs;
	        while ((chs=fr.read())!=-1){
	            System.out.println((char)chs);
	        }
	        //释放资源
	        fr.close();
			/**阅读源码，读取文件最终调用的方法是read0()
			 * private int read0() throws IOException {
			 *     synchronized(this.lock) {
			 *         if (this.haveLeftoverChar) {
			 *             this.haveLeftoverChar = false;
			 *             return this.leftoverChar;
			 *         } else {
			 *             char[] var2 = new char[2];
			 *             int var3 = this.read(var2, 0, 2);
			 *             switch(var3) {
			 *             case -1: 当值为-1时，说明没有数据了，并退出
			 *                 return -1;
			 *             case 0:
			 *             default:
			 *                 assert false : var3;
			 *
			 *                 return -1;
			 *             case 2:
			 *                 this.leftoverChar = var2[1];
			 *                 this.haveLeftoverChar = true;
			 *             case 1:
			 *                 return var2[0];
			 *             }
			 *         }
			 *     }
			 */

综合案例：使用FileReader和FileWriter复制一个文件

		File f = new File("a.txt");
		File f3 = new File("b.txt");
		System.out.println(f3.createNewFile());
		//创建输入流对象
		FileReader fr = new FileReader(f);
		//创建输出流对象
		FileWriter fw = new FileWriter(f3);
		//一次读写一个字符
		int ch;
		while ((ch=fr.read())!=-1){
		    fw.write(ch);//写入一个字符
		    fw.flush();
		}
		//一次读写一个字符数组
		int len;//用于存储读到的字符个数
		char[] chs = new char[1024];//一般是1024的整数倍
		while ((len = fr.read(chs))!=-1){
		    fw.write(chs,0,len);//注意：有些字符数组没有到1024，所以不能直接写入chs数组
		    fw.flush();
		}
		
		//释放资源
		fr.close();

2.3 FileOutputStream 字节输出流类

2.3.1 FileOutputStream方法

• public FileOutputStream(String name):创建输出流操作的目标
• public FileOutputStream(String name,boolean append):append为true代表每次写入都向文件末尾天际，为false则每次都是覆盖写入
• void write(int n):输出一个字节
• void write(byte[] b):输出一个字节数组
• void write(byte[] b,int off,int len):输出字节数组的一部分
• void close():释放IO占用的底层资源

案例

		//创建IO流对象，绑定IO资源
        FileOutputStream fos = new FileOutputStream("a.txt");
        //输出数据（单个字符)
        fos.write(97);
		//输出数据(字符数组)
		byte[] bytes = { 97,98,99};
		fos.write(bytes);
        //释放资源
        fos.close();

2.4 FileInputStream 字节输入流类

2.4.1 FileInputStream方法

• public FileInputStream(String name):创建输入流操作的目标
• int read():读取一个字节，返回的是字节内容本身，读取到末尾返回-1
• int read(byte[] b):读取一个字节数组
• void close():释放IO占用的底层资源

案例

		//创建IO流对象，绑定IO资源
        FileInputStream fis = new FileInputStream("a.txt");
        //读取数据（一次读取一个字节）
        int ch;
        while ((ch=fis.read())!=-1){
            System.out.println(ch);
        }
        //读取数据（一次一组字符数组）
        int len = -1;
        byte[] bytes =new byte[1024];
        while ((len = fis.read(bytes))!=-1){
            //将字节数组变成字符串，方便观察（通过字符串的构造方法）
            //读取几个字节，就转换几个字节为字符串
            String s = new String(bytes,0,len);
            System.out.println(s);
        }
        //释放资源
        fis.close();

FileOutputStream与FileInputStream综合案例

使用字节流复制一张图片

		//创建IO流对象，绑定IO资源
        FileInputStream fis = new FileInputStream("1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\filedemo\\1.jpg");
        //读取数据（一次一组字节数组）
        int len;//用于存储读到的字节个数
        byte[] bytes =new byte[1024];
        while ((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);//不需要刷新资源
        }
        //释放资源
        fos.close();
        fis.close();

小贴士
流的关闭原则：先开后关，后开先关
注意:二进制文件只能使用字节流进行复制（如图片、视频、音频等）
文本文件的复制既可以使用字符流，也可以使用字节流
建议使用字节流

待续小结

关于文件处理的，还有不少，缓冲流，标准输入输出流等等。也还是有收获的，坚持下去，就会有新的成长。
为每一个坚持下去的人加油，为自己加油！

文件处理（下）