文件操作&IO流

一. 文件操作

1.1 认识文件

我们先来认识狭义上的文件 (file) 。针对硬盘这种持久化存储的 I/O 设备，当我们想要进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念，就类似办公桌上的一份份真实的文件一般。

 文件除了有数据内容之外，还有一部分信息，例如文件名、文件类型、文件大小等并不作为文件的数据存在,我们可以把这一部分数据视为文件的原信息.

1.2 树型结构和目录

随着文件越来越多,如何对文件进行管理也成了一个重大问题.这时出现了一种想法--按照层级结构组织文件,也就是我们见到过的树型结构.也就有了文件夹(folder)/目录(directory)的概念,通过一个个文件夹,我们可以将文件组织起来,方便用户的查找和使用.

其实本质上文件夹和目录是一个东西,只不过"目录"这个词显得更高级一些 

1.3 文件路径

有了目录,我们发现可以很容易地找到一个文件所在的位置.因为从树形结构的角度来看,从根节点开始,树上的每个结点都可以通过一条路径找到.

以盘符开头的路径称为绝对路径,也就是从根开始的路径.

 

 如上图,为test-9-10文件夹所在的路径,各级目录之间的分割符可以是'/'或'\',但是一般使'/',因为'\'在代码中容易被当成转义字符处理.

我们还可以从任意结点出发,进行路径的描述,这种描述方式被称为"相对路径".

比如,创建一个文件夹aaa,下面有a1.txt,a2.txt,a3.txt文件;再来一个bbb文件夹,下面有b.txt文件

 如果以b.txt为基准目录(工作目录)的话," ./ "表示的是当前目录,和b.txt同级;" ../ "表示的是上一级目录,和bbb文件夹同级.

如果想根据b.txt找到a2.txt,相对路径应该是"../aaa/a2.txt",你们学废了吗~

根据保存数据的类型,文件也被分为二进制文件和文本文件.文本文件是指按照某个字符集进行编码的文件,二进制文件则是按照标准格式保存的未被编码的文件.

区别它们最简单的方法就是用记事本打开,出现乱码就是二进制文件.

 Windows上会根据文件名的后缀区分文件类型和默认打开程序,但这个习俗在Linux,Unix系统上并不通用.

广义上的文件,泛指计算机中的各种软硬件资源(IO设备,内存等),操作系统为了便于更好地管理,将它们抽象成文件并提供了操作这些"文件"的接口,按照管理文件的方式统一管理.          

本篇文章讲解的是操作狭义上的文件. 

二. 对文件系统的操作

肯定有同学会问,对文件系统操作和对文件操作不一样嘛?

先来区分一下二者的区别,操作文件系统是指创建,删除,重命名等对文件整体的操作,操作文件是指增删查改文件的内容,它们操作的单位不一样.

2.1 File类

Java中通过java.io.File类来对一个文件(包括目录)进行抽象的描述.但是,一个File对象对应的文件并不一定真实存在.

2.2.1 方法介绍

构造方法

方法名	说明
File(File parent,String child)	根据父目录+孩子文件路径,创建一个File实例,父目录用File实例表示
File(String pathname)	根据文件路径创建一个File实例
File(String parent,String chile)	根据父目录+孩子文件路径,创建一个FIle实例,父目录用路径表示

看下图~

常用方法

返回类型	方法签名	说明
String	getParent()	返回File对象的父目录文件路径
String	getName()	返回File对象的文件名称
String	getPath()	返回File对象的文件路径
String	getAbsolutePath()	返回File对象的绝对路径
String	getCanonicalPath()	返回File对象的修饰过的路径
boolean	exists()	判断File对象描述的文件是否存在
boolean	isDirectory()	判断File对象描述的文件是否是一个目录
boolean	isFile()	判断File对象描述的文件是否是一个普通文件
boolean	createNewFile()	根据File对象的路径创建一个空文件并返回true,如果该文件已经存在,返回false
boolean	delete()	删除File对象描述的文件,删除成功返回true
boolean	deleteOnExit()	删除File对象描述的文件,删除操作要到JVM运行结束后才会执行
String[]	list()	返回File对象代表的目录下所有文件名
File[]	listFiles()	返回File对象代表的目录下的所有文件
boolean	mkdir()	创建File对象代表的目录
boolean	mkdirs()	创建File对象代表的目录,如果有必要,还会创建中间目录
boolean	renameTo(File dest)	对文件改名,也可以理解为我们平时的剪切复制操作
boolean	canRead()	判断用户是否有可读权限
boolean	canWrite()	判断用户是否有可写权限

2.2.2 使用举例

上面的方法是不是很多!没关系,多练练就会了(我猜你想要我说记不住也可以) 

 来看下面的示例吧,本人还会介绍下一些方法的区别~

注意:在idea中创建文件的基准目录是项目所在的路径.

     /**
     * 观察get方法的使用和区别
     */
    public static void main(String[] args) throws IOException {
        File file=new File("../test.txt");
        System.out.println(file.getParent());//输出父目录路径
        System.out.println(file.getName());//输出文件名
        System.out.println(file.getPath());//与创建File对象时传入的路径有关
        System.out.println(file.getAbsolutePath());//输出绝对路径
        System.out.println(file.getCanonicalPath());//去掉绝对路径中的不必要部分
    }

 

    /**
     * 普通文件的创建
     */
    public static void main(String[] args) throws IOException, InterruptedException {
        File file=new File("test.txt");
        System.out.println(file.isFile());//判断file描述的文件是否是普通文件
        file.createNewFile();//创建普通文件
        System.out.println(file.isFile());//判断是否是普通文件
    }

如果文件本身就不存在的话,不论判断它是文件还是目录,结果都会返回false

   /**
     * delete和deleteOnExit
     */
    public static void main5(String[] args) throws InterruptedException {
        File file=new File("test.txt");
        file.deleteOnExit();
        Thread.sleep(5000);
        System.out.println("删除成功");
    }

    public static void main4(String[] args) {
        File file=new File("test.txt");
        file.delete();
        System.out.println("删除成功");
    }

观察idea左侧文件路径,就会发现,如果执行deleteOnExit方法,会在5s后删除该文件;如果执行delete方法,会立即删除该文件.

在执行main方法前,aaa目录并不存在,aaa/bbb自然也不存在

    /**
     * 观察目录的创建
     */
    public static void main(String[] args) {
        File file=new File("src/aaa/bbb");//创建一个aaa目录,该目录下有bbb目录
        System.out.println(file.isDirectory());//判断是否是一个目录
        System.out.println(file.mkdir());//用普通方法创建目录
        System.out.println(file.exists());//判断该目录是否存在
        System.out.println(file.mkdirs());//可以创建多级目录
        System.out.println(file.isDirectory());//判断该目录是否存在
    }

下面是运行结果

     /**
     * 观察renameTo方法的使用
     */
    public static void main(String[] args) throws IOException, InterruptedException {
        File file=new File("test.txt");
        file.createNewFile();//在项目路径test-9-9下创建test.txt文件
        System.out.println(file.getAbsolutePath());
        file.renameTo(new File("../test-9-10/test.txt"));//把file文件移植到test-9-10/test.txt路径上
    }

 可以看到,最终test.txt文件存放在test-9-10文件夹下

三. 文件内容的读写--IO数据流

先来理解一下"流"是什么?相信同学们肯定被这道题支配过...

文件系统针对文件内容,通过"流对象"进行操作.

流--可以随意划分,就像水流一样,可以从任意处断开.我们将文件读写相关的对象称作"流对象".

站在CPU的角度来看,写文件操作--数据从内存流向硬盘,称为"输出流";读文件操作--数据从硬盘流向内存,称为"输入流".

根据文件内容格式不同,流对象分为两大类--字节流和字符流

3.1 输入流

3.1.1 InputStream

InputSteam类的方法是以字节为单位进行读取

返回值类型	方法签名	说明
int	read()	读取一个字节的数据,返回读到的数据对应的ASCII编码,返回-1代表读到文件末尾EOF
int	read(byte[] b)	最多读取b.length的数据到b中,返回实际读到的字节数;-1代表已经读完.
int	read(byte[] b,int off,int len)	读取的数据放在以off下标开始的字节数组内,最多读取len-off字节的数据;返回-1代表读完了
void	close()	关闭字节流

InputStream 只是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream 类，我们现在只关心从文件中读取,所以使用 FileInputStream

3.1.2  FileInputStream

构造方法

方法签名	说明
FileInputStream(File file)	利用File实例创建文件输入流对象
FileInputStream(String name)	利用文件路径创建文件输入流对象

 代码示例

/**
*按照字节进行读取
*/
public static void main(String[] args) throws IOException {
        InputStream stream=new FileInputStream("src/demo2/test.txt");
        while(true){
            int a=stream.read();
            if(a==-1){
                break;
            }
            System.out.println(a);//输出每个字节的值
        }
        strem.close();
    }

/**
*通过字符串进行读取
*/  
   public static void main(String[] args) throws IOException {
        File file=new File("src/demo2/test.txt");
        InputStream stream=new FileInputStream(file);
        byte[] b=new byte[1024];
        while(true){
            int len= stream.read(b);
            if(len==-1){
                break;
            }
            for(int i=0;i<len;i++){
                System.out.println(b[i]);
            }
        }
        stream.close();
    }

博主要提一个问题--上面两种读取方式,哪一种方式更好? 

答案是第二种!因为每次read操作,都要访问硬盘/IO设备,速度相当慢.如果我们一次读取多个字节,就可以减少访问次数,提高执行效率.

 如果我们想把读取到的字节按照一定的编码方式转化成字符输出,可以使用String的构造方法实现

 public static void main(String[] args) throws IOException {
        InputStream stream=new FileInputStream("src/demo2/test.txt");
        byte[] b=new byte[1024];
        while(true){
            int len=stream.read(b);
            if(len==-1) break;
            String s=new String(b,0,len,"utf-8");//utf-8为读取文件的编码方式
            System.out.println(s);
        }
    }

 可以感觉到,使用字符输出InputStream读取的内容还是比较困难的.我们可以换成熟悉的Scanner.

Scanner的构造方法

可以看到,第一个参数是InputStream对象,第二个是译码方式.

从中我们可以看到,System.in也是InputStream对象.

注意: Scanner只适合读取文本文件,不能用来读取二进制文件

 public static void main(String[] args) throws IOException {
        InputStream inputStream=new FileInputStream("src/demo2/test.txt");
        Scanner scanner=new Scanner(inputStream,"utf8");
        while (scanner.hasNext()){
            System.out.println(scanner.next());
        }
        scanner.close();
        inputStream.close();
    }

 其实上述代码中,Scanner对象可以不用关闭,因为我们调用close()方法是为了删除文件描述符,InputStream对象关闭的时候已经完成了.

3.1.3 try-with resources

上面的代码中,有一个很大的问题!如果代码执行过程中抛出了异常,就会停止执行,close()方法将无法被调用.

因此聪明的你一定想到了try-finally语法

public static void main(String[] args) throws IOException {

        InputStream inputStream=null;

        try {
            inputStream=new FileInputStream("src/demo2/test.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            inputStream.close();
        }

    }

但是上面的代码写起来有两处不便----1.InputStream对象必须定义在try-finally外面,否则涉及到变量作用域问题2.我们还需要手动closeInputStream流对象

 因此Java提供了另一种结构try-with,下面演示一下这种结构的使用

public static void main(String[] args) {
        try(InputStream stream=new FileInputStream("src/demo2/test.txt")){

        }catch (IOException e){
            e.printStackTrace();
        }
    }

虽然没有显式调用close()方法,实际上当try语句执行完毕时,系统会自动调用close()

注意:

并不是所有的对象都可以放在try()内部,这个对象必须实现Closeable接口

当使用多个流对象时,要将它们全放在try后面的()内,并且用;分割 

这里强调一下close()方法的重要性!!!

 前面的博文中提到过,每个进程都有一个文件描述符表,用来记录该进程打开的文件,每当打开一个文件,就会往文件描述符表中增添一项,close()就是把该文件对应的表项释放掉.

但是文件描述符表是一个不可扩容的数组,满了之后便不能打开任何文件.因此我们最好使用try-with机制,及时释放无用文件.

3.1.4 Reader

和InputStream一样,Reader也是一个抽象类,需要借助普通类来实现.这里我们使用FileReader类.

Reader类的方法和InputStream一样,下面简单进行演示,不再赘述.

public static void main(String[] args) {

        try(Reader reader=new FileReader("src/demo2/test.txt")){
            while(true){
                int a= reader.read();//返回读到字符的值
                if(a==-1) break;
                System.out.printf("%c ",a);//按照字符类型输出读到的值
            }
        }catch (IOException e){
            e.printStackTrace();
        }

    }

我们知道,Java中的char是按照Unicode进行编码的,如果我们要读取的文件是按照utf-8进行编码,标准库内部会自动帮我们将读取的字符转按照Unicode编码

 上图为"hello,world"按照Unicode编码的结果,下图为按照十六进制输出读到的字符串的结果

3.2 输出流

 3.2.1 OutputStream

聪明的你一定想到了,OutputStream也只是一个抽象类,只能通过子类创建实例.

下面来康康OutputStream提供的常用方法吧~

返回值类型	方法签名	说明
void	write(int b)	写入要给字节的数据
void	write(byte[] b)	将b这个字符数组中的数据全部写入
int	write(byte[] b,int off,int len)	将b这个字符数组从off下标开始的数据写入,一共写len个字节
void	close()	关闭字节流
void	flush()	大多数OutputStream为了减少访问外设的次数,在写数据的时候都会将数据先写入内存的一个指定区域里,直到该区域满了,调用了close方法或者满足其他指定条件时才真正将数据写入到设备中,这个区域我们称之为"缓冲区". 所以我们需要手动刷新,将缓冲区的数据冲到设备中.

注意: 创建Outstream对象时,就相当于打开了它对应的文件,默认情况下会清空文件原有内容;

如果文件不存在会自动创建. 

3.2.2 FileOutputStream

下面简单演示下,write方法向文件中写入二进制数据

public static void main(String[] args) {

        try(OutputStream stream=new FileOutputStream("src/demo3/test.txt")){

            String s="hello啊";//创建一个字符串

            stream.write(s.getBytes());//将该字符串内部的字符数组输出到文件中
        }catch (IOException e){
            e.printStackTrace();
        }

    }

3.2.3 Writer 

 同样,我们也可以使用Writer向文件中写入字符

 public static void main(String[] args) {

        try(Writer writer=new FileWriter("src/demo3/test.txt")){//FileWriter为Writer的子类
            String s="你好,中国!";
            writer.write(s);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

其实,Java中还提供了PrinterWriter类,供我们使用熟悉的printf等方法.

 public static void main5(String[] args) {
        try(PrintWriter writer=new PrintWriter("src/demo3/test.txt");
        Scanner scanner=new Scanner(System.in)){

            String s=scanner.next();//从控制台输入字符串

            writer.println(s);//将字符串输入到文件中

        }catch (IOException e){
            e.printStackTrace();
        }
    }