File类与IO流

程序员文章站 2024-03-04 17:03:11

...

File 类

文件和目录路径名的抽象表示形式。通过java的File类与我们磁盘上面的文件进行连接。
用户界面和操作系统使用与系统相关的路径名字符串来命名文件和目录。此类呈现分层路径名的一个抽象的、与系统无关的视图。
下面是常用的方法，以及递归实现树状图打印文件和文件夹

1、文件名
getName()：返回由此抽象路径名表示的文件或目录的名称。
getPath() ：将此抽象路径名转换为一个路径名字符串。
getAbsoluteFile()：返回此抽象路径名的绝对路径所对应的文件。
getAbsolutePath() ：返回此抽象路径名的绝对路径名字符串。
getParent() ：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录(如删除，相对路径创建的文件等)，则返回 null。
renameTo(File dest) ：重新命名此抽象路径名表示的文件。
2、判断信息
exists() ：测试此抽象路径名表示的文件或目录是否存在。
isFile() ：测试此抽象路径名表示的文件是否是一个标准文件。
isDirectory() ：测试此抽象路径名表示的文件是否是一个目录。
isAbsolute() ：测试此抽象路径名是否为绝对路径名。
canRead() ：测试应用程序是否可以读取此抽象路径名表示的文件。
3、长度
length() 返回由此抽象路径名表示的文件的长度 long类型，字节大小。而且只能读取文件的不能文件夹的。
4、创建、删除
createNewFile() ：当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
createTempFile(String prefix, String suffix) ：在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称【前缀三个字节长，后缀默认.temp】。
createTempFile(String prefix, String suffix, File directory) ：在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。常用deleteOnExit()一同使用，否则临时文件是不会自动删除的。
delete() ：删除此抽象路径名表示的文件或目录。
deleteOnExit() ：在虚拟机终止时，请求删除此抽象路径名表示的文件或目录，常用删除临时文件。
5、目录操作
mkdir() ：创建此抽象路径名指定的目录。
mkdirs()：创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
list() ：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。String数组
listFiles() ：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。File数组
listRoots()：列出可用的文件系统根路径。

package com.wf.File;

import java.io.File;
import java.io.IOException;

public class FileDemo {

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

        // 表示文件或者目录
        //File f0 = new File("d:\\File"); 不推荐使用
        // File f0 = new File("D:"+File.separator+"File"); 跨平台使用
        File f0 = new File("d:/File"); // 最常用使用
        File f1 = new File("D:/File/demo01.txt");
        File f2 = new File("D:/File/File/File");
        File f3 = new File("D:/File/File", "demo02.txt");   // 相对路径构建
        File f4 = new File("demo03.text");      // 没有盘符，是以当前项目相对路径进行构建
        File f5 = File.createTempFile("12", ".temp",f0);  // 创建临时文件 静态类

        f0.mkdir(); // 创建文件夹
        f1.createNewFile(); // 创建文件
        f2.mkdirs(); // 创建多层文件夹，利用mkdirs
        f3.createNewFile();
        f4.createNewFile();

        System.out.println(File.separator+"是此系统的标准的文件分隔符");
        System.out.println(File.pathSeparator+"是此系统的标准的路径分隔符");  // 一般在构建File时进行
        System.out.println(f0.exists() + "存在"); // 判断是否存在
        System.out.println(f0.isFile() + "不是文件"); // 判断是否为一个文件
        System.out.println(f1.isDirectory() + "不是文件夹"); // 判断是否为文件夹
        System.out.println(f2.isHidden() + "不是隐藏"); // 判断文件是否隐藏

        System.out.println(f3.getAbsolutePath() + "是绝对路径"); // 得到绝对路径
        System.out.println(f3.getPath() + "是相对路径"); // 得到绝对路径
        System.out.println(f3.getName() + "是他的名字"); //
        System.out.println(f3.getParent() + "是他的父节点的路径");
        System.out.println(f3.getParentFile().getName() + "是他的父文件名字");

        System.out.println(f4.getAbsolutePath() + "工作空间的绝对路径"); // 得到绝对路径
        System.out.println(f4.getPath() + "是相对路径"); // 得到绝对路径
        System.out.println("过滤指定文件");
        File[] listFiles = f2.listFiles(new FilenameFilter() {  //  过滤指定文件
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isFile() && name.endsWith(".java") ;
            }
        });
        for(File file:listFiles){
            System.out.println(file.getName());
        }   


        System.out.println("得到此目录中的的文件");
        File[] files = f0.listFiles();
        for (File f : files) {
            System.out.print(f.getName() + "\t");
        }

        System.out.println("树状体打印利用递归");
        printTree(f0, 0);

    }

    public static void printTree(File file, int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println(file.getName());

        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                printTree(f, level + 1);
            }
        }
    }

}

IO 流

File类与IO流

流：有流向流动的意思，即从源头经过程序流向目的地。记住是以程序为中心展开的。
分类：
根据流向分为：输入流和输出流。
根据数据分为：字节流和字符流。【字节流可以处理一切文本，字符流只可以处理纯文本】

字节流

输入流：
InputStream类此抽象类是表示字节输入流的所有类的超类。
read() ：从输入流中读取数据的下一个字节。很少用
read(byte[] b) ：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
read(byte[] b, int off, int len) ：将输入流中最多 len 个数据字节读入 byte 数组。
close() ：关闭此输入流并释放与该流关联的所有系统资源。
实现类FileInputStream：从文件系统中的某个文件中获得输入字节

输出流：
OutputStream类：此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。
write(byte[] b) ：将 b.length 个字节从指定的 byte 数组写入此输出流。
write(byte[] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
flush() ：刷新此输出流并强制写出所有缓冲的输出字节。
close()：关闭此输出流并释放与此流有关的所有系统资源。
实现类FileOutputStream：用于写入诸如图像数据之类的原始字节的流

字符流

输入流：
Reader类用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

read(char[] cbuf) ：将字符读入数组。
read(char[] cbuf, int off, int len) ：将字符读入数组的某一部分。
close() ：关闭该流并释放与之关联的所有资源。

实现类：InputStreamReader是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。 FileReader类用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的,常用。

输出流：
Writer类写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

write(char[] cbuf) ：写入字符数组。
write(char[] cbuf, int off, int len) ：写入字符数组的某一部分。
write(String str, int off, int len) ：写入字符串的某一部分。
flush()：刷新该流的缓冲。
close()：关闭此流，但要先刷新它。

实现类： OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。 FileWriter类用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的，常用。

IO流使用步骤

1、读取文件建立连接
2、选择对应的流
3、进行相关操作选取数组大小以及对应方法
4、释放资源

读取文件：
1、建立联系——》 File对象
2、选择流——》文件输入流 InputStream FileInputStream
3、读取大小及方法——》 byte[] car = new byte[1024] + read方法
4、释放资源——》关闭

写出文件：
1、建立联系——》 File对象
2、选择流——》文件输出流 OutputStream FileOutputStream
3、操作——》write方法 flush方法
4、释放资源——》关闭

拷贝文件：

1、建立联系——》 File对象源头文件目的地文件
2、选择流——》文件输入流 OutputStream FileOutputStream 文件输出流 OutputStream FileOutputStream
3、操作——》byte[] car = new byte[1024] + read方法 + write方法+flush方法
4、释放资源——》关闭

代码如下三个方法：

    public static void inputStream() {
        File f = new File("D:/File/input.txt");  //  加载文件
        FileInputStream input = null;
        try {
            input = new FileInputStream(f);     //  建立连接

            byte[] car = new byte[1024]; // 定义每次读多少个
            int length = 1; // 实际读取大小 可以不读定义那么多

            while (-1 != (length = input.read(car))) { // 赋值实际读取大小  进行循环读取
                String info = new String(car, 0, length);
                System.out.println(info);

            }

        } catch (FileNotFoundException e) {
            System.out.println("file not found");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("read fail");
            e.printStackTrace();
        } finally {
            if (null != input) {
                try {
                    input.close();
                } catch (IOException e) {
                    System.out.println("关闭失败");
                    e.printStackTrace();
                }
            }
        }
    }



public static void outputStream(){

        File f = new File("D:/File/input.txt");  //  加载文件

        FileOutputStream output = null;  



        try {
            // output = new FileOutputStream(f);     //  文件进行覆盖
             output = new FileOutputStream(f,true);  //追加形式

            String str = "hello world";
            byte[] data =str.getBytes();  
            output.write(data);
            output.flush(); //  强制帅新
        } catch (FileNotFoundException e) {
            System.out.println("file not found");
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            System.out.println("write error");
            e.printStackTrace();
        }finally{
            if(null!=output){
                try {
                    output.close();
                } catch (IOException e) {
                    System.out.println("close error");
                    e.printStackTrace();
                }
            }
        }

    }


    public static void copyFile(){

        File src = new File("D:/File/File/psb.jpg");  // 源文件 必须存在
        File dest = new File("D:/File/File/psdcopy.jpg");  //目的地  可以不存在
        FileOutputStream output =null;  //  输入流
        FileInputStream input =null;    //  输出流

        try {
             input = new FileInputStream(src);
             output =  new FileOutputStream(dest);

            byte [] car = new byte[1024];   // 定义大小
            int length = 0;         //  实际读取大小
            while(-1!=(length = input.read(car))){  // 循环文件读取
                output.write(car,0,length);    //  文件写出
            }
            output.flush();  //  刷新
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("read error");
            e.printStackTrace();
        }finally{
            if(null!=output){
                try {
                    output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(null!=input){
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }

上一篇： Android Style.xml的应用详解及代码实现

下一篇： Java排序算法总结之选择排序

File类与IO流

File 类

IO 流

字节流

字符流

IO流使用步骤

File类与IO流

Java学习笔记_06_File类与IO流

File跟Io流的学习

File 与 IO 流

File类与IO流

Java IO流之File类概述

浅谈java IO流——四大抽象类

Java IO流 File类的常用API实例

Java中IO流 RandomAccessFile类实例详解

Java文件(io)编程_基于File类的基本用法(必看篇)