24. File类及I/O操作

2024-04-09 23:20:40 阅读数 370

1、File类

1.1 概述

File类是http://java.io包很重要的一个类；
File类的对象可以表示文件，也可以是目录。
File对象只可以对文件或目录的属性进行操作，不可以操作文件的具体数据，即不能对文件进行读/写操作。

1.2 构造方法

（1） File(File parent, String child)

从父抽象路径名和子路径名字符串创建新的 File实例。

（2）File(String pathname)

通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

（3） File(String parent, String child)

从父路径名字符串和子路径名字符串创建新的 File实例。

（4） File(URI uri)

通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

代码案例：

//创建文件的方法

public class CreateFile {

    public static void main(String[] args) {
        // 创建文件对象。
        File file = new File("D:/FileDemo/FileDemo.txt");
        // 创建文件
        if (!file.exists()) {
            try {
                if (file.createNewFile()) {
                    System.out.println("文件创建成功");
                } else {
                    System.out.println("文件创建失败");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("文件已存在");
        }

    }

}

//创建目录的方法

import java.io.File;

public class CreateDirectory {

    public static void main(String[] args) {
        File file = new File("D:\\FileDemo");

        if (!file.exists()) {
            if (file.mkdirs()) {
                System.out.println("创建成功");
            } else {
                System.out.println("创建目录失败");
            }
        } else {
            System.out.println("目录已存在,创建失败");
        }
    }

}

1.3 常用方法

遍历方法：

//遍历方法

import java.io.File;

public class FileList{
    public static void main(String[] args) {
        // 创建目录对象。
        File file = new File("E:\\");

        // 使用list方法
        String[] fileNameList = file.list();
        
        // 遍历目录数组
        for (String s : fileNameList) {
            System.out.println(s);
        }
        
        System.out.println("------------------------------------");

        // 使用listFiles方法
        File[] fileList = file.listFiles(); 
        
        for (File f : fileList) {
            System.out.println(f.getAbsolutePath());
        }
    }
}

1.4 FileFilter文件过滤器

1.4.1 两个作用：

（1）过滤不符合规格的文件名

文件名过滤器接口：interface FilenameFilter
需重写accept方法自定义过滤规则

boolean accept(File dir, String name) -- dir：表示文件的当前目录。 -- name：表示当前目录的子目录或者文件的名字。

File类中提供了使用文件名过滤器遍历目录的方法

String[] list(FilenameFilter filter) -- 把满足指定过滤条件的文件和目录，返回到String数组中。 File[] listFiles(FilenameFilter filter) -- 把满足指定过滤条件的文件和目录，返回到File数组中。

（2）常用于检测文件是否存在

文件过滤器接口：interface FileFilter
需重写accept方法自定义过滤规则,如下：

boolean accept(File pathName) -- pathName：表示当前目录的子目录或者文件的名字。

File类中提供了使用文件过滤器遍历目录的方法：

File[] listFiles(FilenameFilter filter) -- 把满足指定过滤条件的文件和目录，返回到File数组中。

代码演示：

public class FileFilterDemo {

    public static void main(String[] args) {
        //创建目录对象
        File dir = new File("D:\\FileDemo");

        //使用"匿名内部类"的方式创建过滤器
        FileFilter filter = new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.getName().toLowerCase().endsWith(".txt");
            }
        };
        
        File[] files = dir.listFiles(filter);
        
        for (File file : files) {
            System.out.println(file);
        }
    }

}

2、输入流与输出流

类：InputStream、OutputStream、Reader、Writer

2.1 流按着数据的传输方向分为：

输入流：往内存中读叫输入流。
输出流：从内存中往外写叫输出流。

（1）所有输入流都是InputStream类或者Reader类的子类。

类名以InputStream结尾的类都是InputStream的子类。
类名以Reader结尾的类都是Reader类的子类。

（3）所有输出流都是OutputStream类或者Writer类的子类。

类名以OutputStream结尾的类都是OutputStream的子类。
类名以Writer结尾的类都是Writer类的子类。

2.2 从数据流编码格式上划分为：

字节流：处理单元为1个字节
字符流：处理单元为2个字节

（1）InputStream和OutputStream的子类都是字节流

可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。

（2）Reader和Writer的子类都是字符流

主要处理字符或字符串，字符流处理单元为2个字节。
字节流将读取到的字节数据，去指定的编码表中获取对应文字。

由于上述两种分类都是针对InputStream、OutputStream、Reader、Writer四个类，所以代码案例写在一起

代码案例：

//字节输入流（FileInputStream）

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo {

    public static void main(String[] args) {
    
        //建立文件对象
        File file=new File("C:\\Users\\25849\\Desktop\\1.txt"); 
   
        try
        {
            //建立链接
            FileInputStream fileInputStream=new FileInputStream(file);
            
            int  n=0; 
            
            StringBuffer sBuffer=new StringBuffer();
 
            while (n!=-1)  //当n不等于-1,则代表未到末尾
            {
                
               n=fileInputStream.read();//读取文件的一个字节(8个二进制位),并将其由二进制转成十进制的整数返回
              
               char by=(char) n; //转成字符
               
               sBuffer.append(by);
 
            }
           System.out.println(sBuffer.toString());
   
        }
        catch (FileNotFoundException e)
        {
          
           System.out.println("文件不存在或者文件不可读或者文件是目录");
        }
        catch (IOException e)
        {
           System.out.println("读取过程存在异常");
        } 
    }
}

结果：由于文件存的是字符类型，以字节形式读取，会把原本的字符分解为两个字节，所以乱码了

????¤§???????¤§asfsa???
sdg sgdf???dfhfh
?¤§?????????????????¨é??
?????¨é???????¨é??sf?

//字节输出流（FileOutputStream）

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

public class FileOutputStreamDemo {

    public static void main(String[] args) {
        // 建立文件对象
        File file = new File("C:\\Users\\25849\\Desktop\\1.txt");

        try {
            String content = "我生来坚强\n只要不死\n我就笑得猖狂";
            FileOutputStream out = new FileOutputStream(file, true);
            out.write(content.getBytes());
            System.out.println("写入成功");
        }

        catch (FileNotFoundException e) {

            System.out.println("文件不存在或者文件不可读或者文件是目录");
        } catch (IOException e) {
            System.out.println("读取过程存在异常");
        }
    }
}

结果：

写入成功
在没有实力之前，你要学会比狼能忍
在有了实力之后，你要学会比狼更狠我生来坚强我生来坚强
只要不死
我就笑得猖狂

//字符输入流（FileReader）

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2 {

    public static void main(String[] args) {

        // 建立文件对象
        File file = new File("C:\\Users\\25849\\Desktop\\1.txt");

        try {
            // 建立链接
            FileReader fileReader = new FileReader(file);
            int n = 0;

            char[] chars = new char[10];
            String s ;

            while ((n = fileReader.read(chars)) != -1) // 当n不等于-1,则代表未到末尾
            {
                String string = new String(chars,0,n);
                
                System.out.println(string);

            }

        } catch (FileNotFoundException e) {

            System.out.println("文件不存在或者文件不可读或者文件是目录");
        } catch (IOException e) {
            System.out.println("读取过程存在异常");
        }
    }
}

//字符输出流（FileWriter）

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

public class FileWriterDemo2 {

    public static void main(String[] args) {
        FileWriter filewriter = null;
        try {

            filewriter = new FileWriter("C:\\Users\\25849\\Desktop\\1.txt",true);

            String content = "abcdefghigklmn";
            
            filewriter.write( content );
        
        } catch (IOException e1) {
            e1.printStackTrace();
        }finally{
            try {
                //清空缓存区
                filewriter.flush();
                //关闭“文件字符输出流”
                filewriter.close();
                System.out.println("写入成功！");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

2.3 从封装类型不同分为：

节点流：如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，则称为节点流。
处理流：如果流封装的是其它流对象，称为处理流。处理流提供了缓冲功能，提高读写效率。

（1）节点流中常用类

字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter

（2）处理流中常用类

缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter

上面的节点流就是之前描述的，在这里着重描述处理流

2.3.1 处理流：

1.缓冲区原理：

-缓冲区的概念。

-缓冲区的作用：要对操作的数据进行临时的缓存，提高了读写效率。

-缓冲区如何提高读写效率。

2.处理流的特点：

字符缓冲输入流提供了读取一行的方法readLine() 。
字符缓冲输出流提供了写入一个空行的方法newLine()。
字符缓冲输出流，把写入的数据先写入到内存，再使用flush()方法将内存数据刷到硬盘上。

注意：在使用字符缓冲输出流时，一定先flush(),然后再close(),避免数据的丢失。

代码案例：

//缓冲字节输入处理流(BufferedInputStream)

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo2 {

    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        BufferedInputStream bufferedInputStream = null;
        try {
            fileInputStream = new FileInputStream("C:\\Users\\25849\\Desktop\\1.txt");
            
            bufferedInputStream = new BufferedInputStream(fileInputStream);     

            byte[] bytes = new byte[16];
    
            int length = 0;
        
            while ((length = bufferedInputStream.read(bytes)) != -1) {
                System.out.println(new String(bytes, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedInputStream.close();
                System.out.println("读取完成！");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

//缓冲字节输出处理流(BufferedOutputStream)

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo2 {

    public static void main(String[] args) {

        FileOutputStream fileOutputStream = null;

        BufferedOutputStream bufferedOutputStream = null;
        try {

            fileOutputStream = new FileOutputStream("C:\\Users\\25849\\Desktop\\1.txt");

            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

            String content = "abcdefghigklmn";

            byte[] bytes = content.getBytes();

            bufferedOutputStream.write(bytes);

            System.out.println("写入成功！");
        } catch (IOException e) {

            e.printStackTrace();

        } finally {
            try {
                // 刷新 “缓冲字节输出处理流”
                bufferedOutputStream.flush();
                // 关闭 “缓冲字节输出处理流”
                bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//缓冲字符输入处理流(BufferedReader)

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

public class BufferedReaderDemo2 {

    public static void main(String[] args) {

        FileReader fileReader = null;
    
        BufferedReader bufferedReader = null;
        try {
    
            fileReader = new FileReader("C:\\Users\\25849\\Desktop\\1.txt");
    
            bufferedReader = new BufferedReader(fileReader);
    
            String content = null;
            int length = 0;
            
            while ((content = bufferedReader.readLine()) != null) {
    
                System.out.println(content);
            }

        } catch (IOException e) {

            e.printStackTrace();
        } finally {

            try {
                //关闭  “字符输入处理流”
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//缓冲缓冲字符输出处理流(BufferedWriter )

2.4 节点流和处理流速度的对比

//用字节节点流复制一个视频

package com.company.project.homework.h11;

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

import javax.xml.crypto.Data;

//复制两个视频文件
//字节流
//用节点流

public class Demo2 {
    public static void main(String[] args) throws IOException {
        
        long now = System.currentTimeMillis();
        
        FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");
        FileOutputStream fos ;
        
        File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");
        if(!newfile.exists()) {
            newfile.createNewFile();
        }
        fos = new FileOutputStream(newfile);

        
        byte[] by = new byte[128];
        int num = 0 ;
        while ((num = fis.read(by)) != -1) {
            fos.write(by,0,num);
            
        }
        System.out.println("复制完成");
        System.out.println("使用时间:" + (System.currentTimeMillis() - now));
        fos.close();
        fis.close();
        
    }
}

结果：

复制完成
使用时间:203

//用字节处理流复制同一个视频

package com.company.project.homework.h11;

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

import javax.xml.crypto.Data;

//复制两个视频文件
//字节流
//用处理流

public class Demo {
    public static void main(String[] args) throws IOException {
        
        long now = System.currentTimeMillis();
        
        FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");
        FileOutputStream fos ;
        
        File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");
        if(!newfile.exists()) {
            newfile.createNewFile();
        }
        fos = new FileOutputStream(newfile);
        
        
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        
        byte[] by = new byte[128];
        int num = 0 ;
        while ((num = bis.read(by)) != -1) {
            bos.write(by,0,num);
            
        }
        System.out.println("复制完成");
        System.out.println("使用时间:" + (System.currentTimeMillis() - now));
        bos.close();
        bis.close();
        fos.close();
        fis.close();
        
    }
}

结果：

复制完成
使用时间:15

明显速度提升了很多！！！！