1.文件

1.1什么是文件

1.2文件路径

2.Java中操作文件

File类中常见的属性

File类中常见的构造方法

File类中常见的方法

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

按字节进行数据读InputStream

FileInputStream

按字节进行数据写OutputStream

按字符进行数据读FileReader

按字符进行数据写FileWriter

Scanner简化读操作

PrintWriter简化写操作

Java中的文件代码示例1

1.文件

1.1什么是文件

狭义上的文件：硬盘上保存的数据，都是“文件”来组织的，本质上都是二进制或是字符组织的数组，被打包成一个文件存在硬盘上。常见的文件有图片（png），文本（txt），可执行文件（exe）等。

广义上的文件：操作系统的主要功能就是对计算机资源进行统一管理与分配。对于Linux来说，所有的计算设备都会被描述（抽象）成文件。（例如：网卡，键盘，打印机等）

树形结构组织：随着文件越来越多，如何进行文件的组织呢？就是按照层级结构进行组织---也就是数据结构中的树形结构。而我们平时所谓的文件夹或者目录，就是专门用来存放管理信息的。

在cmd中查看指定（当前）目录的树形结构语法：

目录>tree /F

查看树形结构示例：

1.2文件路径

绝对路径：从根目录开始一直到目标程序的表示方式

相对路径：从当前目录开始，表示目标程序路径的方式

从当前目录开始找到目标程序（一个点）

语法：.+目标程序目录

返回到上一级目录，再找目标程序（两个点）

语法：..+目标程序目录

举例：这是QQ.exe的完整目录

当前目录在

要找QQ.exe操作：

若当前目录在：

要找QQ.exe操作：

补充：

对于cmd来说，起始工作目录就是当前的用户目录

对于idea来说，起始工作目录就是工程的根目录

2.Java中操作文件

操作系统的一个重要功能就是对文件的管理，每个操作系统都有自己的一套系统API调用，Java作为一个跨平台的语言，JVM针对不同的操作系统做了一层封装，我们只需要使用JDK提高的关于文化操作的API就可以完成不同系统上的文件操作。

Java中通过java.io.File类来对一个文件进行抽象的描述。

输入输出是以内存为参照物的，输入指的是从外部输入到内存，输出指的是把内存中的数据输出到外部（磁盘，显卡等）。

注意：有File对象，并不代表真实存在该文件。

File类中常见的属性

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

File类中常见的构造方法

签名	说明
File(File parent, String child)	根据父目录 + 孩子文件路径，创建一个新的 File 实例
File(String pathname)	根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径
File(String parent,String child)	根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用路径表示

示例代码：

        //通过指定文件路径来创建一个File对象
        File file=new File("D:/temp/hello.txt");
        System.out.println(file);

File类中常见的方法

常见方法1：

修饰符及返回值类型	方法签名	说明
String	getParent()	返回 File 对象的父目录文件路径
String	getName()	返回 FIle 对象的纯文件名称
String	getPath()	返回 File 对象的文件路径
String	getAbsolutePath()	返回 File 对象的绝对路径
String	getCanonicalPath()	返回 File 对象的修饰过的绝对路径
boolean	exists()	判断 File 对象描述的文件是否真实存在
boolean	isDirectory()	判断 File 对象代表的文件是否是一个目录
boolean	isFile()	判断 File 对象代表的文件是否是一个普通文件

示例代码(绝对路径)：

        //指定绝对路径并创建一个file对象
        File file=new File("D:/test/hello.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());
        //是否存在
        System.out.println(file.exists());
        //是否是一个目录
        System.out.println(file.isDirectory());
        //是否是一个文件
        System.out.println(file.isFile());

运行结果：

代码示例（相对路径）：

        //指定相对 路径并创建一个file对象
        File file=new File("./hello.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());
        //是否存在
        System.out.println(file.exists());
        //是否是一个目录
        System.out.println(file.isDirectory());
        //是否是一个文件
        System.out.println(file.isFile());

运行结果：

常见方法2：

修饰符及返回值类型	方法签名	说明
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	renameTo(File dest)	进行文件改名，也可以视为我们平时的剪切、粘贴操作
boolean	canRead()	判断用户是否对文件有可读权限
boolean	canWrite()	判断用户是否对文件有可写权限

示例代码1：

    public static void main(String[] args) throws IOException {
        //通过绝对路径创建file对象
        File file=new File("D:/test/hi.txt");

        //创建文件
        boolean result=file.createNewFile();
        if(result){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
    }

运行结果：

示例代码2：

        //通过绝对路径创建file对象
        File file=new File("D:/test/hi.txt");

        //删除文件
        boolean result=file.delete();
        if(result){
            System.out.println("删除成功");
        }else{
            System.out.println("删除失败");
        }

运行结果：

示例代码3：

    public static void main(String[] args) {
        //指定一个目录的路径
        File file=new File("D:/test");

        //获取目录下的文件和子目录
        String[]list=file.list();
        System.out.println(Arrays.toString(list));

        //获取目录下的文件对象数组
        File[]files=file.listFiles();
        System.out.println(Arrays.toString(files));
    }

运行结果：

示例代码4：

    public static void main(String[] args) {
        //指定要创建的目录
        File file=new File("D:/test/testSingle");

        //创建单个目录
        boolean result=file.mkdir();
        if(result){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
    }

运行结果：

示例代码5：

        //指定要创建的目录
        File file=new File("D:/test/a/b/c");

        //创建单个目录
        boolean result=file.mkdirs();
        if(result){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }

示例代码6：

        //定义源文件
        File sourceFile=new File("D:/test/hello.txt");
        //定义目标文件
        File destFile=new File("D:/test/hi.txt");
        //重命名
        boolean result=sourceFile.renameTo(destFile);
        if(result){
            System.out.println("修改成功");
        }else{
            System.out.println("修改失败");
        }

示例代码7：

        //通过指定文件路径来创建一个File对象
        File file=new File("D:/temp/hi.txt");
        //是否可写
        System.out.println(file.canWrite());
        //是否可读
        System.out.println(file.canRead());

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

数据流分为输入流和输出流两类。

按字节进行数据读InputStream

InputStream只是一个抽象类，要使用还需要具体的实现类。从文件中读取，使用FileInputStream.

方法：

修饰符及返回值类型	方法签名	说明
int	read()	读取一个字节的数据，返回 -1 代表已经完全读完了
int	read(byte[]b)	最多读取 b.length 字节的数据到 b 中，返回实际读到的数量； -1 代表以及读完了
int	read(byte[]b, int off, int len)	最多读取 len - off 字节的数据到 b 中，放在从 off 开始，返回实际读到的数量； -1 代表以及读完了
void	close()	关闭字节流

注意：

打开一个文件，相当于把文件放入文件描述符表中。

用完一定要关闭，如果不关闭，那么文件描述符表（本质上是一个数组），就会被填满，导致以后可能就无法再打开文件。

示例代码1：

        //创建一个文件对象
        File file=new File("D:/test/hi.txt");
        //创建一个输入流
        InputStream inputStream=new FileInputStream(file);
        //读取文件内容
        while(true){
            int read=inputStream.read();
            //是否读完
            if(read==-1){
                break;
            }
            System.out.println(read);
        }
        //关闭
        inputStream.close();

示例代码2：

        //创建一个文件对象
        File file=new File("D:/test/hi.txt");
        //创建一个输入流
        InputStream inputStream=new FileInputStream(file);
        //定义一个数组用来保存读到的数据
        byte[]bytes=new byte[1024];
        //读取文件内容
        while(true){
            //读到的数据会被填充到Bytes数据中，返回读取数据的长度
            int len=inputStream.read(bytes);
            //判断是否读完
            if(len==-1){
                break;
            }
            //打印读到的内容
            for (int i = 0; i < len; i++) {
                System.out.println(bytes[i]);
            }
        }
        //关闭
        inputStream.close();

运行结果：

FileInputStream

构造方法：

签名	说明
FileInputStream(File file)	利用 File 构造文件输入流
FileInputStream(String name)	利用文件路径构造文件输入流

按字节进行数据写OutputStream

OutputStream同样只是一个抽象类，要使用还需要具体的实现类。

方法

修饰符及返回值类型	方法签名	说明
void	write(int b)	写入要给字节的数据
void	write(byte[] b)	将 b 这个字符数组中的数据全部写入 os 中
int	write(byte[]b, int off, int len)	将 b 这个字符数组中从 off 开始的数据写入 os 中，一共写 len 个
void	close()	关闭字节流
void	flush()	重要：我们知道 I/O 的速度是很慢的，所以，大多的 OutputStream 为了减少设备操作的次数，在写数据的时候都会将数据先暂时写入内存的一个指定区域里，直到该区域满了或者其他指定条件时才真正将数据写入设备中，这个区域一般称为缓冲区。但造成一个结果，就是我们写的数据，很可能会遗留一部分在缓冲区中。需要在最后或者合适的位置，调用 flush （刷新）操作，将数据刷到设备中。

注意：我们写的文件内容一般是先写到缓冲区里，缓冲区里的内容什么时候写入是由操作系统决定的。

示例代码：

    public static void main(String[] args) throws IOException {
        //先创建一个file对象
        File file=new File("D:/test/hi.txt");
        //创建一个输出流
        FileOutputStream outputStream=new FileOutputStream(file);
        //向文件中写入内容
        outputStream.write(100);
        outputStream.write(101);
        outputStream.write(102);
        //刷新缓冲区
        outputStream.flush();
        //关闭流
        outputStream.close();
    }

运行结果：

运行前：运行后：

新写入的内容会覆盖掉原内容。

按字符进行数据读FileReader

        //先创建一个file对象
        File file=new File("D:/test/hi.txt");
        //根据file对象创建一个reader(面向字符的输入流)
        FileReader reader=new FileReader(file);
        //循环读取
        while(true){
            int read=reader.read();
            if(read==-1){
                break;
            }
            //打印
            System.out.println(read);
        }
        reader.close();

运行结果：

文件中是字母abc，输出的是它的ASCII值。

按字符进行数据写FileWriter

    public static void main(String[] args) throws IOException {
        //先创建一个file对象
        File file=new File("D:/test/hi.txt");
        //根据file对象创建一个字符输出流
        FileWriter writer=new FileWriter(file);
        //写入数据
        writer.write("你好");
        writer.write("hi");
        //刷新缓冲区
        writer.flush();
        //关闭流
        writer.close();
    }

运行结果：

可以传入字符串，但是没有换行，如果要换行，必须手动加入换行符。

Scanner简化读操作

        //创建一个输入流
        FileInputStream inputStream=new FileInputStream("D:/test/hi.txt");
        //根据创建输入流创建scanner对象
        Scanner scanner=new Scanner(inputStream,"UTF-8");
        //循环读取
        while(scanner.hasNext()){
            String next=scanner.next();
            System.out.println(next);
        }
        inputStream.close();

scanner.next()是每次读取一个词。

scanner.nextLine()是每次读取一行。这里采用scanner,next()。

运行结果：

PrintWriter简化写操作

        //创建一个输出流
        FileOutputStream outputStream=new FileOutputStream("D:/test/hi.txt");
        //根据创建输出流创建PrintWriter对象
        PrintWriter writer=new PrintWriter(outputStream);
        //写入文件
        writer.println("哈喽");
        writer.println("world");
        writer.println("我是PrintWriter写入的内容");
        //刷新缓冲区
        writer.flush();
        //关闭
        writer.close();

这里的println和平常的输出方法一样。

Java中的文件代码示例1

题目：扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后序询问用户是否要删除文件。

思路：本题是在一个目录中找到指定字符所在文件，并选择要不要删除。

1.用户输入一个路径

2.检查路径是否有效

3.用户输入目标字符

4.获取路径下的文件和目录

5.如果是目录的话，再递归查找文件

6.如果是文件检查文件名是否包含用户输入的字符

代码：

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

public class Exe01 {
    public static void main(String[] args) throws IOException {
        //1.接收用户输入的扫描路径
        System.out.println("请输入要扫描的路径（绝对路径）：");
        Scanner sc=new Scanner(System.in);
        String rootPath=sc.next();
        //2.判断路径是否有效
        File root=new File(rootPath);
        //路径是否存在
        if (!root.exists()) {
            System.out.println("路径不存在");
            return;
        }
        //判断路径是不是一个目录
        if (!root.isDirectory()) {
            System.out.println("指定路径不是一个有效目录");
            return;
        }
        //3.接收关键字
        System.out.println("请输入关键字");
        String key=sc.next();
        if(key==null || "".equals(key)){
            System.out.println("关键字不能为空");
            return;
        }
        //4.扫描目录下的所有文件
        scan(root,key);
    }

    private static void scan(File root, String key) throws IOException {
        //1.先获取目录下的所有文件
        File[]files=root.listFiles();
        //递归的终止条件
        if(files==null || files.length==0){
            return;
        }
        //遍历数组中每个文件
        for (int i = 0; i < files.length; i++) {
            //取出每一个文件
            File tempFile=files[i];
            //判断是文件还是目录
            if(tempFile.isFile()){
                //如果是文件，判断文件名中是否包含关键字
                String fileName=tempFile.getName();
                //如果在文件中找到关键字
                if(fileName.contains(key)){
                    System.out.println("找到文件"+tempFile.getCanonicalPath()+",是否删除(Y/N)");
                    //接收用户的输入，根据输入判断是否删除
                    Scanner sc=new Scanner(System.in);
                    String order=sc.next();
                    //删除操作
                    if(order.equalsIgnoreCase("y")){
                        tempFile.delete();
                        System.out.println(tempFile.getCanonicalPath()+"删除成功");
                    }
                }
            }else{
                //如果是目录，则递归
                scan(tempFile,key);
            }
        }
    }
}

Java中的文件代码示例1

题目：进行普通文件的复制。

思路：

1.用户输入源文件的路径

2.检查源文件是否存在，并且是一个文件

3.用户输入目标文件的路径

4.检查目标文件是否存在，并校验目录或文件

5.完成复制

代码：

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

public class Exe02 {
    public static void main(String[] args) {
        //1.接收用户输入的源文件路径
        System.out.println("请输入源文件路径：");
        Scanner sc=new Scanner(System.in);
        String sourcePath=sc.next();
        //2.判断源文件是否有效
        File sourceFile=new File(sourcePath);
        //文件是否存在
        if (!sourceFile.exists()) {
            System.out.println("源文件不存在");
            return;
        }
        //判断是不是一个文件
        if (!sourceFile.isFile()) {
            System.out.println("源文件不是一个有效的文件");
            return;
        }
        //3.接收用户输入的目标文件路径
        System.out.println("请输入目标文件路径（绝对路径）：");
        String destPath=sc.next();
        File destFile=new File(destPath);
        //判断目标文件是否存在
        if (destFile.exists()) {
            System.out.println("目标文件已存在");
            return;
        }
        //判断目标文件的父目录是否存在
        if (!destFile.getParentFile().exists()) {
            System.out.println("目标文件的父目录不存在");
            return;
        }
        //循环读取源文件的内容并写到目标文件中
        try(FileInputStream inputStream=new FileInputStream(sourceFile);
            FileOutputStream outputStream=new FileOutputStream(destFile)) {
            //定义一个byte数组用来做为输出型参数，保存每次读到的文件内容
            byte[]bytes=new byte[1024];
            //循环读取内容
            while(true){
                int len=inputStream.read(bytes);
                if(len==-1){
                    break;
                }
                //写入目标文件
                outputStream.write(bytes);
                //强制刷新缓冲区
                outputStream.flush();
            }
            System.out.println("复制成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}