java之文件操作

Posted 2021-11-26 zhuzhaoli

一.File类

1.1File类说明

File类关心的是磁盘上文件的存储，描述的是一个文件或者文件夹。在整个java.io包中，File类是唯一一个与文件本身操作有关的类，所谓的文件本身指的是文件的创建，删除，重命名，修改文件日期，获取文件的大小等。

1.2体验File类

package com.boxiaoyuan.www;

import java.io.File;

public class Demo03 {
    public static void main(String[] args) {
        File file = new File("d:\\a.txt");
        System.err.println(file.exists());//判断文件是否存在
        System.out.println(file.isDirectory());//判断对象是否为目录
        System.out.println(file.isFile());//判断对象是否为文件
    }
}

说明：File对象可以表示不存在的文件，File对象不会在磁盘上创建文件，我们可以随意创建对象，并可以调用File对象的方法判断文件是否存在，是否为文件，是否为目录等。

1.3构建File类的实例

File file = new File(String pathname);//通过指定的路径创建File实例
File file = new File(String parent, string child);//根据parent路径名和child路径名创建一个File对象，完成的路径为parent+child
File file = new File(File parent, String child);//根据parent抽象路径名和child路径创建File实例，完成的路径为parent.getPath+child

说明：如果写的Java程序需要跨越不同的操作系统，那么分割符建议使用File.separatorChar获取操作系统的分隔符。

1.4File类中常用的方法

创建

createNewFile() 在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。

mkdir() 在指定位置创建目录，这只会创建最后一级目录，如果上级目录不存在就抛异常

mkdirs() 在指定位置创建目录，这会创建路径中所有不存在的目录

renameTo(File dest) 重命名文件或文件夹，（1.如果源文件与目标文件在同一级路径下，那么renameTo方法的作用是重命名，如果源文件与目标文件不在同一级目录下，那么renameTo的作用是剪切；2.如果源文件夹与目标文件夹在同一级路径下，那么renameTo方法的作用是重命名，如果源文件夹与目标文件夹不在同一级目录下，那么renameTo不起作用（不能用于剪切文件夹））

删除

deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录，保证程序异常时创建的临时文件也可以被删除
delete() 删除文件或一个空文件夹，如果是文件夹且不为空，则不能删除，成功返回true，失败返回false

判断

exists() 文件或文件夹是否存在
isFile() 是否是一个文件，如果不存在，则始终为false
isDirectory() 是否是一个目录，如果不存在，则始终为false
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录
isAbsolute() 测试此抽象路径名是否为绝对路径名

获取

getName() 获取文件或文件夹的名称，不包含上级路径
getPath() 返回绝对路径，可以是相对路径，但是目录要指定
getAbsolutePath() 获取文件的绝对路径，与文件是否存在没关系
length() 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null
lastModified() 获取最后一次被修改的时间

文件夹相关

listRoots() 列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null
list(FilenameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null
listFiles(FilenameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null

package com.boxiaoyuan.www;

import java.io.File;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        File file = new File("d:\\aaa.txt");
        System.out.println("文件创建成功了吗"+file.createNewFile());
        
        File dir = new File("d:\\aa\\vv\\ds\\aa");
        System.out.println("创建文件夹成功了吗"+dir.mkdir());
        dir = new File("d:\\aa\\bb\\vv\\ss");
        System.out.println("文件夹创建成功了吗"+dir.mkdirs());
        
        File destFile = new File("d:\\aa\\bb\\vv\\ss\\aa.txt");
        System.out.println("文件复制成功了吗？"+file.renameTo(destFile));
        
    }
}

二.流

2.1java中IO流的分类

IO流值的是输入（Input）和输出流（Output），在Java程序中，对于数据的输入和输出操作都是以流的方式进行，Java提供了各种各样的流，来获取不同种类的数据。

常见的2种IO流分类：

1.按流向分：

输入流：程序从别处读取数据的流；

输出流：程序可以向别处写出的流；

2.按数据传输的单位分：

字节流：以字节为单位传输数据的流；

字符流：以字符为单位传输的流。

2.2IO流的基类和分类

常见的流分类：

流分类	使用分类	字节输入流	字节输出流	字符输入流	字符输出流
	抽象基类	InputStream	OutputStream	Reader	Writer
节点流	访问文件	FileInputStream	FileOutStream	FileReader	FileWriter
处理流	缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
	打印流		PrintStream		PrintWriter

 

 

 

 

 

字符流的抽象基类

Reader和Writer

字节流的抽象基类

InputStream和OutputStream

说明：由上面四个类派生出来的子类名称都是以其父类名作为子类名的后缀，如：InputStream的子类为FileInputStream。

2.3字节流操作

FileInputStream 从文件系统中的某个文件中获得输入字节，FileInputStream 用于读取图像数据之类的原始字节流。要读取字符流，应首先考虑使用 FileReader。

2.3.1FileInputStream和FileOutputStream

package com.boxiaoyuan.www;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo03 {
    /**
     * 复制图片
     * @param args
     */
    public static void main(String[] args) {
        FileInputStream fileInStream  = null;
        FileOutputStream fileOutStream = null;
        try {
            fileInStream = new FileInputStream("D:\\美女.jpg");
            fileOutStream = new FileOutputStream("e:\\美女.jpg");
            byte[] byt = new byte[1024];
            int len = 0;
            while((len = fileInStream.read(byt))!=-1) {
                fileOutStream.write(byt, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fileOutStream!=null) {
                try {
                    fileOutStream.close();
                }catch (IOException e) {
                    e.printStackTrace();
                }finally{
                    if(fileInStream!=null) {
                        try {
                            fileInStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }  
    }
}

2.3.2字节流缓冲区

package com.boxiaoyuan.www;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo03 {
    /**
     * 复制mp3
     * @param args
     */
    public static void main(String[] args) {
        BufferedInputStream bfInStream = null;
        BufferedOutputStream bfOutStream = null;
        try {
            bfInStream = new BufferedInputStream(new FileInputStream("d:\\等你下课.mp3"));
            bfOutStream = new BufferedOutputStream(new FileOutputStream("E:\\等你下课.mp3"));
            int len = 0;
            while((len=bfInStream.read())!=-1) {
                bfOutStream.write(len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(bfOutStream!=null) {
                try {
                    bfOutStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(bfInStream!=null) {
                        try {
                            bfInStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }      
        }        
    }
}

说明：

1.BufferedInputStream的close方法实际上关闭的是传递进去的FileInputStream对象。

2.BufferedOutputStream的write方法，实际上数据是写入到BufferedOutputStream内部维护的字节数组中，只有调用了close或者flush方法，数据才会真正写入到硬盘中。

2.4字符流操作

2.4.1FileWriter字符流写入

FileWriter写文件的步骤：

1.创建一个FileWriter对象，该对象一初始化就必须要明确被操作的文件，而且该文件会被创建到执行的目录，如果文件已经存在，则会覆盖。

2.调用write方法将字符串写入到流中。

3.刷新流对象中的缓冲区中的数据，将其数据刷新到目的地中，flush之后，流还可以继续使用，如果是调用close关闭流，会刷新缓冲区，然后关闭流，之后流不能再继续使用。

在实际中如何选择使用字节流还是字符流呢，如果操作的是文本数据，可以使用字符流；如果操作的是非文本数据（图片，视频，音频等），则可以使用字节流。

package com.boxiaoyuan.www;

import java.io.FileWriter;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        FileWriter fileWriter = new FileWriter("d:\\testa.txt", true);
        fileWriter.write("这是个测试文件");
        fileWriter.close();
    }
}

2.4.2FileReader字符流读取

下面为常用的通过字符数组进行读取的示例：

package com.boxiaoyuan.www;

import java.io.FileReader;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        FileReader fileReader = new FileReader("d:\\testa.txt");
        char[] cbuf = new char[1024];
        int len = 0;
        while((len=fileReader.read(cbuf))!=-1) {
            System.out.println(new String(cbuf, 0, len));
        }
        fileReader.close();
    }
}

2.4.3文件拷贝

package com.boxiaoyuan.www;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            fileReader = new FileReader("d:\\testa.txt");
            fileWriter = new FileWriter("e:\\testa.txt");
            char[] cbuf = new char[1024];
            int len = 0;
            while((len=fileReader.read(cbuf))!=-1) {
                fileWriter.write(cbuf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fileWriter!=null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(fileReader!=null) {
                        try {
                            fileReader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }  
        }
    }
}

2.4.4BufferedReader字符流缓冲区读

从字符输入流中读取文本，缓冲各个字符，从而实现字符，数组和行的高效读取，并且可以指定缓冲区的大小，或者使用默认值，但是大多数情况下，默认值就已经足够到了。

package com.boxiaoyuan.www;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Demo03 {
    /**
     * BufferedReader提供了一个一次读取一行的方法readLine，方便对文本数据进行获取
     * @param args
     */
    public static void main(String[] args) {
        FileReader fReader = null;
        BufferedReader bReader = null;
        try {
            fReader = new FileReader("d:\\testa.txt");
            //使用缓冲技术，将字符读取流对象作为参数传递给缓冲区对象的构造函数
            bReader = new BufferedReader(fReader);
            String s = null;
            while((s=bReader.readLine())!=null) {
                System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(bReader!=null) {
                try {
                    bReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    bReader = null;
                }
            }
        }  
    }
}

2.4.5BufferedWriter字符流缓冲区读

将文本写入字符输出流，缓冲各个字符，从而提供了单个字符，数组和字符串的高效写入，可以指定缓冲区的大小，或者使用默认的大小，大多数情况下，默认值就已经够用了。

package com.boxiaoyuan.www;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo03 {
    
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        BufferedWriter bWriter = null;
        try {
            fileWriter = new FileWriter("d:\\testa.txt");
            bWriter = new BufferedWriter(fileWriter);
            for(int i=0;i<7;i++) {
                bWriter.write("hello "+ i);
                bWriter.newLine();//跨平台的换行符
                bWriter.flush(); //把缓冲区的数据刷新到文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(bWriter!=null) {
                try {
                    bWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    bWriter = null;
                }
            }
        }        
    }
}

2.4.6通过缓冲区复制文本

package com.boxiaoyuan.www;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo03 {
    
    public static void main(String[] args) {
        FileWriter fWriter = null;
        FileReader fReader = null;
        BufferedReader bReader = null;
        BufferedWriter bWriter = null;
        try {
            fWriter = new FileWriter("e:\\testa.txt");
            fReader = new FileReader("d:\\testa.txt");
            bReader = new BufferedReader(fReader);
            bWriter = new BufferedWriter(fWriter);
            String line = null;
            while((line=bReader.readLine())!=null) {
                bWriter.write(line);
                bWriter.newLine();
                bWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(bWriter!=null) {
                try {
                    bWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    bWriter=null;
                }
            }
            if(bReader!=null) {
                try {
                    bReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    bReader=null;
                }
            }
        }    
    }
}

2.5 打印流

打印流是java.io包中输出信息最为方便的一个类，主要包括字节打印流（PrintStream）和字符打印流（PrintStream），打印流可以打印任何类型的数据，包括小数，整数和字符串等，OutputStream只能输出String类型，因此才有了打印流。

package com.boxiaoyuan.www;

import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Demo03 {
    public static void main(String[] args) {
        BufferedReader bfReader = null;
        PrintWriter pWriter=null;
        try {
            bfReader = new BufferedReader(new InputStreamReader(System.in));
            pWriter = new PrintWriter(new FileOutputStream("d:\\aaa.txt"), true);
            String line = null;
            while((line=bfReader.readLine())!=null) {
                if(line.equals("end")) {
                    break;
                }
                pWriter.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(pWriter!=null) {
                pWriter.close();
            }
            if(bfReader!=null) {
                try {
                    bfReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }     
    }
}