当前位置：首页 > article >正文

Javaee文件的io操作

article 2024/11/23 19:43:10

1）针对文件系统进行操作

创建文件，删除文件，创建目录，重命名文件

2）针对文件内容进行操作

读文件，写文件。

3）针对文件系统进行操作

创建文件，删除文件，创建目录，重命名文件。

File类出自于java.io包里面，和输入输出相关的内容，就是在这个包里。

Overview (Java Platform SE 8 )（点击可直接进入）

属性

修饰符及类型	属性	说明
staticString	pathSeparator	依赖于系统的路径分隔符，String 类型的表⽰
staticchar	pathSeparator	依赖于系统的路径分隔符，char类型的表⽰

构造方法

签名	说明
File(Fileparent,Stringchild)	根据⽗⽬录+孩⼦⽂件路径，创建⼀个新的File实例
File(Stringpathname)	根据⽂件路径创建⼀个新的File实例，路径可以是绝对路径或者相对路径
File(Stringparent,Stringchild)	根据⽗⽬录+孩⼦⽂件路径，创建⼀个新的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
boolean	delete()	根据File对象，删除该⽂件。成功删除后返回true
void	deleteOnExit()	根据File对象，标注⽂件将被删除，删除动作会到JVM运⾏结束时才会进⾏
String[]	list()	返回File对象代表的⽬录下的所有⽂件名
File[]	listFiles()	返回File对象代表的⽬录下的所有⽂件，以File对象表⽰
boolean	mkdir()	创建File对象代表的⽬录
boolean	mkdirs()	创建File对象代表的⽬录，如果必要，会创建中间⽬录
boolean	canRead()	判断⽤⼾是否对⽂件有可读权限
boolean	renameTo(Filedest)	进⾏⽂件改名，也可以视为我们平时的剪切、粘贴操作
boolean	canWrite()	判断⽤⼾是否对⽂件有可写权限

上述都是涵盖了日常生活的常见方法

   File f=new File("d:/text.txt");
        System.out.println(f.getParent());
        System.out.println(f.getName());
        System.out.println(f.getPath());
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getCanonicalPath());

如果把d改成.

 File f=new File("./text.txt");
        System.out.println(f.getParent());
        System.out.println(f.getName());
        System.out.println(f.getPath());
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getCanonicalPath());

getab...是把当前的工作路径和相对路径进行简单的拼接。

  File f=new File("./test.txt");
        //调用创建方法，把它搞出来
        f.createNewFile();
        System.out.println(f.exists());
        System.out.println(f.isFile());
        System.out.println(f.isDirectory());

调用创建方法把他搞出来。

创建文件啥时候会失败呢？

1）给出的路径非法。

2）权限不足

有些程序，运行的过程中，会产生“临时文件”。

就需要再进程结束之后，自动删除掉。

这样的情况就可以使用deleteOnExit的方式来实现

   Scanner scanner=new Scanner(System.in);
        File f=new File("./test.txt");
        //文件删除
        f.delete();
        //把文件阻塞住
        f.deleteOnExit();
scanner.next();
        System.out.println(f.exists());

文件内容操作：

读文件，写文件，打开文件，关闭文件。

Java通过“流”这样的一组类，进行上述的文件内容操作。

stream流，操作系统本身，针对文件操作的时候，就引入了流概念。C语言中也有文件流说法，Java也是文件流说法。读文件的方式非常灵活，和接水非常类似。

在Java中，用来操作文件内容的“流”是一组类。

分成两组~~

字节流

（以字节为单位，读写数据的）{二进制文件}

InputStream

OutputStream

字符流

（以字符为单位，读写数据的）{文本文件}

Reader

Write

后面的用法就都基本一样，通过构造方法，打开文件，通过read/write方法来读写文件，通过close方法来关闭文件。

文件io

字节流以字节为单位读写数据

InputStream OutputStream

字符流以字符为单位读写数据

Reader

Writer

如果想要读字节文件，首先需要用InputSteam，

InputStream inputStream=new FileInputStream("d:/test.txt")

共有三个方法：

版本一：无参数，一次读取一个字节，读取到的内容，就通过返回值来表示了

既然一次读一个字节，返回值就应该是byte.但是实际上，这里的返回值是int

1）返回int为了能够有额外的余地表示“到达末尾”-1这样的情况。

2）确保读到的数据都是正数

从原则上来说，“字节”这样的概念，本身应该是“无符号”，但是byte类型本身有符号。

此处通过int类型就可以确保读出来的字节，都是正数，按照“无符号”的方式来处理了。

版本二：带有一个参数byte[]

package FILE;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo5 {
    public static void main(String[] args) throws RuntimeException, IOException {
//        InputStream inputStream=null;
//        try{
//            inputStream =new FileInputStream("d:/test.txt");
//        while(true){
//            int b=inputStream.read();
//            if(b==-1){
//                //读取完毕
//                break;
//            }
//            System.out.println(b);
//            byte[] bytes=new byte[1024];
//            int n=inputStream.read();
//            System.out.println("n = "+n);
//            if(n==-1){
//                //读取完毕，n就是-1.
//                break;
//            }
//            for (int i = 0; i < n; i++) {
//                System.out.println(bytes[i]);
//            }
//            System.out.println( );
//        }
//
//        }finally{
//            inputStream.close();
//        }
        try(InputStream inputSream=new FileInputStream("d:.test.txt")){
            byte[] bytes=new byte[1024];
            int n=inputSream.read(bytes);
            for (int i = 0; i < n; i++) {
                System.out.println(bytes[n]);
            }
        }
    }
}

关闭文件close

为啥要关闭文件？

如果你没关闭文件，大部分情况，肯可能感知不到，但是一旦真的遇到了问题，就是大事。

打开文件：

打开文件的时候，会在操作系统内核，pcb结构体中，给“文件描述符表”添加一个元素，这个元素就是表示，当前打开的文件相关信息。

OutputSteam

版本一：一次write一个字节，参数是int类型。

版本二：一次write若干字节，会把参数数组里所有的字节都写入文件中。

版本三：一次write若干字节，把数组从offset下标开始，连续写len个字节。

默认的写方式打开，会清空。如果使用“追加写”方式打开就可以了。

package FILE;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Demo6 {
    public static void main(String[] args) {
        try(OutputStream outputStream=new FileOutputStream("d:/test.txt")){
outputStream.write(97);
outputStream.write(98);
outputStream.write(99);
outputStream.write(100);

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

如果读字符：

package FILE;

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

public class Demo7 {
    public static void main(String[] args) {
        try(Reader reader=new FileReader("d:/test.txt")){
            while(true){
                int c=reader.read();
                if(c==-1){
                    break;
                }
                char ch=(char)c;
                System.out.print(ch);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

如何写入字符：

public class Demo9 {
    public static void main(String[] args) {
        try (Writer writer = new FileWriter("d:/test.txt", true)) {
            writer.write("你好世界你好世界");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

案例一：做一个查找目录和文件的小程序

package FILE;

import java.io.File;
import java.util.Scanner;

public class Demo8 {
    public static void main(String[] args) {
        //1.输入必要的信息
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入查询的目录");
        String rootPath=scanner.next();
        System.out.println("请输入查询的");
        String searchWord=scanner.next();
        //2.构造File对象，检查路径是否合法
        File rootFile =new File(rootPath);
        if(!rootFile.isDirectory()){
            System.out.println("输入的路径非法");
            return;
        }
        //3.进行递归搜索.
        searchFile(rootFile,searchWord);
    }
    private static void searchFile(File rootFile,String searchWord){
        //1.先列出当前目录有哪些内容
        File [] files=rootFile.listFiles();
        if(files==null){
            //空目录返回
            return;
        }
    for (File f:files){
        if(f.isFile()){
            //普通文件，就判定文件名是否包含查询词
            String fileName=f.getName();
            if(fileName.contains(searchWord)){
                System.out.println("找到匹配结果："+f.getAbsolutePath());

            }else if (f.isDirectory()){
                searchFile(f,searchWord);

            }
        }

    }
    }
}

案例二：做一个简单的io案例

输入一个路径，表示要被复制的文件

输入另一个文件，表示要复制到的目标文件

package FILE;

import java.io.*;
import java.util.Scanner;

//输入一个路径，表示要被复制的文件
//输入另一个文件，表示要复制到的目标目录
public class Demo9 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要被复制的文件");
        String srcPath=scanner.next();
        System.out.println("请输入要复制到的目标路径");
        String destPath=scanner.next();
        //验证目录是否合法
        File srcFile=new File(srcPath);
        if(!srcFile.isFile()){
            System.out.println("输入的复制的文件路径不合法");
            return;
        }
        File destFile=new File(destPath);
        if(!destFile.isFile()){
            System.out.println("输入的要复制到的目标路径非法");
            return;
        }
        //读写文件
        try(InputStream inputStream=new FileInputStream(srcFile);
            OutputStream outputStream=new FileOutputStream(destFile)) {
            while(true){
                byte[] bytes=new byte[1024];
                int n=inputStream.read(bytes);
                if(n==-1){
                    break;
                }
                outputStream.write(bytes,0,n);

            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

如果文件不存在，就创建

1）createNewFile

2）通过OutputNewFile打开文件，也能创造文件。

通过inputStream打开文件，不会创建文件。

案例三：两种结合

输入一个路径，再输入一个查询词。

搜索这个路径中，文件内容，包含这个查询词这里的文件。

package FILE;

import java.io.*;
import java.util.Scanner;

//查找搜索的路径
//查找目录的内容
public class Demo10 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要搜索的路径：");
        String path=scanner.next();
        System.out.println("请输入要查找的词");
        String searchWord=scanner.next();
        //判断路径是否合法
        File rootFile=new File(path);
        if (!rootFile.isDirectory()) {
            System.out.println("文件不合法");
            return;
        }
        search(rootFile,searchWord);
    }
    private static void search(File rootFile,String searchWord){
        File []files=rootFile.listFiles();
        if(files==null){
            //空目录，递归结束
            return;
        }
        for (File f:files){
            if(f.isFile()){
                //读取文件并搜索
                matchWord(f.searchWord);
            }else if(f.isDirectory()){
                search(f.searchWord);
            }

        }

    }
    //负责针对一个文件进行读取和判定
    private static void matchWord(File f,String searchWord){
        try(Reader reader =new FileReader(f)) {
            StringBuilder stringBuilder=new StringBuilder();
while(true){
    int c=reader.read();
    if(c==-1){
        break;

    }
    stringBuilder.append((char)c);
}
//循环结束，此时文件所有的内容，就都进入了stringBuilder了
            if(stringBuilder.indexOf(searchWord)>=0){
                System.out.println("找到了匹配结果"+f.getAbsolutePath());

            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

}

查看全文

http://www.kler.cn/a/406162.html