JAVA文件操作和IO

ambition…

已于 2023-12-27 11:21:13 修改

阅读量907

点赞数 19

分类专栏： java初阶文章标签： java java-ee

于 2023-12-26 16:32:49 首次发布

本文链接：https://blog.csdn.net/m0_69468924/article/details/135195990

版权

java初阶专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、文件

1、文件概念

操作系统里，会把硬盘设备和软件资源抽象为文件。但大多数情况下谈到文件指硬盘里的文件。

2、内存VS硬盘

①内存的访问速度快，硬盘的访问速度慢；

②内存空间小，硬盘空间大；

③内存贵，硬盘便宜；

④内存断电数据丢失，硬盘断电数据还在。

3、操作系统组织文件的方式

树形结构，以此电脑为根结点，不断分支（目录或文件）

4、文件路径

①绝对路径：以C: D:盘符开头的路径称为绝对路径；

②相对路径：需要先指定一个目录，该目录为基准目录，从基准目录出发，沿着路线找到指定文件，这样的路径称为相对路径，往往以.（当前目录，可以省略）或者..（当前目录的上一级目录）为开头。

5、文件类型

①文本文件：文件是以纯文本形式存储数据，保存的内容都是合法的字符；

②二进制文件：文件是以二进制形式存储数据，不要求保存的内容是合法的字符。

二、文件系统操作（File类）

1、涉及类

JAVA中通过import.IO.File类对一个抽象的文件进行描述，但有File对象并不代表文件真实存在。

2、File类的属性

一个路径中用来分割目录的符号。Windows系统下有'/'，也有'\'。

3、File类的构造方法

4、File类的方法

5、应用

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

public class test {
    public static void main(String[] args) throws IOException {
        File file=new File("c:/test.txt");
        System.out.println(file.getParent());   //父目录文件路径
        System.out.println(file.getName());     //纯文件名称
        System.out.println(file.getPath());     //文件路径
        System.out.println(file.getAbsolutePath());  //绝对路径
        System.out.println(file.getCanonicalPath());  //简化后的绝对路径
    }
}

import java.io.File;
import java.io.IOException;
public class test1 {
    public static void main(String[] args) throws IOException{
        File file=new File("C:/Users/16109/Desktop/test.txt");
        System.out.println(file.exists());  //文件是否真实存在
        System.out.println(file.isFile());  //文件是否是一个普通文件
        System.out.println(file.isDirectory());  //文件是否是一个目录
        file.createNewFile();  //创建一个file空文件
        System.out.println(file.exists());  //文件是否真实存在
        System.out.println(file.isFile());  //文件是否是一个普通文件
        System.out.println(file.isDirectory());  //文件是否是一个目录
    }
}

import java.io.File;

public class test2 {
    public static void main(String[] args) {
        File file=new File("C:/Users/16109/Desktop/test.txt");
        System.out.println(file.delete());  //删除文件
    }
}

import java.io.File;
import java.util.Arrays;

public class test3 {
    public static void main(String[] args) {
        File file=new File("C:/");
        String[] s=file.list();  //返回File对象代表的⽬录下的所有文件名
        System.out.println(Arrays.toString(s));
    }
}

import java.io.File;

public class test4 {
    public static void main(String[] args) {
        File file=new File("C:/text");
        System.out.println(file.mkdir());  //建 File 对象代表的⽬录
        File file1=new File("C:/text/aaa/bbb/ccc");
        System.out.println(file1.mkdirs());  //建 File 对象代表的⽬录，会创建中间⽬录
    }
}

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

public class test5 {
    public static void main(String[] args) throws IOException {
        File file=new File("C:/Users/16109/Desktop/test.txt");
        System.out.println(file.createNewFile());
        File srcFile=new File("C:/Users/16109/Desktop/test.txt"); //旧名
        File destFile=new File("C:/Users/16109/Desktop/test1.txt"); //新名
        System.out.println(srcFile.renameTo(destFile)); //重命名
    }
}

三、文件内容操作（流对象）

1、流对象类

二进制文件（字节流）：InputStream、OutStream

文本文件（字符流）：Reader、Writer

2、读文本文件（输入）

Reader是个抽象类，不能实例化，使用FileReader类实例化。

第一个read，一次读取一个字符；返回值int代表unicode编码，使用char，此时的字符固定为unicode，两个字节；使用String，此时的字符固定为utf8，三个字节。返回值-1为读取结束。

f第二个read，一次读取多个字符，直到把cbuf数组填充满；返回值int代表读取的长度，当内容长度大于数组长度时，可以while循环重复多次读，直到返回值为-1读取结束。

第四个read，一次读取多个字符，直到把cbuf数组下标off到len填充满。

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

public class test7 {
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("C:/Users/16109/Desktop/test1.txt");
        try {
            while (true) {
                int c = reader.read();
                if (c == -1)
                    break;
                char ret = (char) c;
                System.out.println(ret);
            }
        } finally {
            reader.close();  //释放资源
        }
    }
}

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

public class test8 {
    public static void main(String[] args) throws IOException {
        try(Reader reader=new FileReader("C:/Users/16109/Desktop/test1.txt")) {  
           //释放资源
           //写到try括号里的对象需要实现Closeable接口
            char[] cbuf = new char[10];
            while (true) {
                int c = reader.read(cbuf);
                if (c == -1)
                    break;
                for (int i = 0; i <c ; i++) {
                    System.out.println(cbuf[i]);
                }
            }
        }
    }
}

3、写文本文件（输出）

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

public class test9 {
    public static void main(String[] args) throws IOException {
        try(Writer writer=new FileWriter("C:/Users/16109/Desktop/test1.txt")){
             //会覆盖原来的内容
            writer.write("我在学习");
        }
    }
}

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

public class test10 {
    public static void main(String[] args) {
        try(Writer writer=new FileWriter("C:/Users/16109/Desktop/test1.txt",true)){
            writer.write("你也在学习");  //不会覆盖原来的内容
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4、读二进制文件（输入）

（1）应用

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class test11 {
    public static void main(String[] args) throws IOException {
        InputStream inputStream=new FileInputStream("C:/Users/16109/Desktop/test1.txt");
        while (true){
            byte[] bytes=new byte[1024];
            int c=inputStream.read(bytes);
            if(c==-1)
                break;
            for (int i = 0; i < c; i++) {
                System.out.printf("%x\n",bytes[i]);  //十六进制
            }
        }
        inputStream.close();
    }
}

（2）输入字节流转字符流

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

public class test12 {
    public static void main(String[] args) throws IOException {
        InputStream inputStream=new FileInputStream("C:/Users/16109/Desktop/test1.txt");
        Scanner scanner=new Scanner(inputStream);
        String s=scanner.next();
        System.out.println(s);
        inputStream.close();
    }
}

5、写二进制文件（输出）

（1）应用

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

public class test13 {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("C:/Users/16109/Desktop/test1.txt");
        //覆盖之前内容
        String s="你今天在学习吗?";
        outputStream.write(s.getBytes());
        outputStream.close();
    }
}

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

public class test14 {
    public static void main(String[] args) {
        try(OutputStream outputStream=new FileOutputStream("C:/Users/16109/Desktop/test1.txt",true)){
            //不覆盖之前内容
            String s="我在学习";
            outputStream.write(s.getBytes());
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

（2）输出字节流转字符流

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

public class test15 {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream("C:/Users/16109/Desktop/test1.txt",true);
        PrintWriter writer=new PrintWriter(outputStream);
        writer.println("你好!"); //写入内存缓存区，未进入硬盘
        writer.flush(); //确保内容进入硬盘
        outputStream.close();
    }
}

四、文件例子

1、扫描指定⽬录，并找到名称中包含指定字符的所有普通⽂件（不包含⽬录），并且后续询问用户是否要删除该⽂件

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

//扫描指定⽬录，并找到名称中包含指定字符的所有普通⽂件（不包含⽬录），并且后续询问用户是否要删除该⽂件
public class test16 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入要扫描的指定目录：");
        String path = sc.next();
        File rootPath = new File(path);
        if (!rootPath.isDirectory()) {
            System.out.println("要扫描的指定目录不存在");
            return;
        }
        System.out.print("请输入包含的指定字符：");
        String key = sc.next();
        scanDir(rootPath, key);
    }
        public static void scanDir (File rootPath, String key){
            File[] files = rootPath.listFiles();
            if (files == null) {
                return;
            }
            for (File file : files) {
                System.out.println("当前扫描的文件：" + file.getAbsolutePath());
                if (file.isDirectory()) {
                    scanDir(file, key);
                } else {
                    checkFile(file, key);
                }
            }
        }
        public static void checkFile (File file, String key){
            if (file.getName().contains(key)) {
                System.out.println("当前文件为：" + file.getAbsolutePath() + "请确认是否删除（Y/N）");
                Scanner sc=new Scanner(System.in);
                String choice = sc.next();
                if(choice.equals("Y")||choice.equals("y")){
                    file.delete();
                    System.out.println("删除成功！！！");
                }
            }
        }
}

2、进⾏普通⽂件的复制

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

//进⾏普通⽂件的复制
public class test17 {
    public static void main(String[] args) throws IOException {
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入你要复制的文件名：");
        String srcPath=sc.next();
        File srcFile=new File(srcPath);
        if(!srcFile.exists()||srcFile.isDirectory()){
            System.out.println("输入路径有误！！！");
            return;
        }
        System.out.print("请输入你要复制到的目标路径：");
        String destPath=sc.next();
        File destFile=new File(destPath);
        if(!destFile.exists()||destFile.isDirectory()){
            System.out.println("输入路径有误！！！");
            return;
        }
        System.out.print("请选择是否复制(Y/N)：");
        String choice=sc.next();
        if(choice.equals("Y")||choice.equals("y")){
            Reader reader=new FileReader(srcFile);
            Writer writer=new FileWriter(destFile);
            char[] cbuf=new char[1000];
            while (true){
                int n=reader.read(cbuf);
                if(n==-1)
                    break;
                writer.write(cbuf);
            }
            System.out.println("复制成功！！！");
            reader.close();
            writer.close();
        }
    }
}

3、扫描指定⽬录，并找到名称或者内容中包含指定字符的所有普通⽂件（不包含⽬录）

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

//扫描指定⽬录，并找到名称或者内容中包含指定字符的所有普通⽂件（不包含⽬录）
public class test18 {
    public static void main(String[] args) throws IOException {
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入指定目录：");
        String path=sc.next();
        File file=new File(path);
        if(!file.exists()){
            System.out.println("指定目录不存在！！！");
            return;
        }
        System.out.print("请输入关键词：");
        String key=sc.next();
        scanDir(file,key);
    }
    public static void scanDir(File file,String key) throws IOException {
        File[] files=file.listFiles();
        if (files==null)
            return;
        for(File file1:files){
            if(file1.isFile()){
                checkFile(file1,key);
            }else {
                scanDir(file1,key);
            }
        }
    }
    public static void checkFile(File file,String key) throws IOException {
        if(file.getName().contains(key)){
            System.out.println("找到一个名称包含指定字符的普通⽂件："+file.getAbsolutePath());
        }else {
            StringBuffer stringBuffer=new StringBuffer();
            Reader reader=new FileReader(file);
            char[] cbuf=new char[1000];
            while (true){
                int n=reader.read(cbuf);
                if(n==-1)
                    break;
                stringBuffer.append(cbuf);
            }
            reader.close();
            String s=stringBuffer.toString();
            if(s.contains(key)){
                System.out.println("找到一个内容包含指定字符的普通⽂件："+file.getAbsolutePath());
            }
        }
    }
}