文件操作---IO详解

文件流

File类

相关方法：

exists（）：判断文件是否存在

getPath():返回文件的路径

getAbsolutePath:返回文件所在的绝对路径

isDirectory:代表File对象所代表的是否是一个目录

createNewFile():根据File对象，自动创建一个空文件，创建成功后返回true

getName():返回File类对象的纯文件名

getParent:返回File类对象父级目录文件路径

mkdir:创建File对象代表的目录（只能一级一级地创建）

mkdirs:创建File对象代表的目录,如果必要，会创建中间目录(如果上一级路径不存在的话，会先创建出上一级路径）

createNewFile():

public class IODemo4 {
    public static void main(String[] args) throws IOException {
        File file = new File("./text.txt");
        file.createNewFile();
    }
}

mkdir:

public class IODemo4 {
    public static void main(String[] args) throws IOException {
        File file = new File("./aaa");
        file.mkdir();
    }
}

mkdirs():

public class IODemo4 {
    public static void main(String[] args) throws IOException {
        File file = new File("./aaa/bbb/ccc/ddd");
        file.mkdirs();
    }
}

getAbsolutePath:

public class IODemo4 {
    public static void main(String[] args) throws IOException {
        File file = new File("./aaa/bbb/ccc/ddd");
        file.mkdirs();
        System.out.println(file.getAbsolutePath());
    }
}

字节流

读文件(InpurStream)

public static void main(String[] args) throws IOException {
    File file = new File("D:/text.txt");
    InputStream inputStream = new FileInputStream(file);
    while(true){
        int b = inputStream.read();
        if(b == -1){
            break;
        }
        System.out.print((char)b+" ");
    }
}

read()方法：

read无参时，一次读一个，当读完时返回-1

当然也可以提供一个字节数组，将读的内容先放在这个数组中，那么一次读的个数就是字节数组的长度，减少了读的次数，提高了效率

public static void main(String[] args) throws IOException {
    File file = new File("D:/text.txt");
    InputStream inputStream = new FileInputStream(file);
    while(true){
        byte[] bytes = new byte[5];
        int b = inputStream.read(bytes);
        if(b == -1){
            break;
        }
        System.out.print(Arrays.toString(bytes));
    }
}

---

写文件(OutputStream）

public static void main(String[] args) throws IOException {
    File file1 = new File("D:/text2.txt");
    OutputStream outputStream = new FileOutputStream(file1);
    byte[] bytes = {97,98,99,100,101,102};
    outputStream.write(97);
    outputStream.write(98);
    outputStream.write(99);
    outputStream.write(100);
    outputStream.write(101);
}

---

当然写文件也可以传字节数组，一次性写多个

public static void main(String[] args) throws IOException {
    File file1 = new File("D:/text2.txt");
    OutputStream outputStream = new FileOutputStream(file1);
    byte[] bytes = {97,98,99,100,101,102};
    outputStream.write(97);
    outputStream.write(98);
    outputStream.write(99);
    outputStream.write(100);
    outputStream.write(101);
    outputStream.write(10);//换行的ASCII码值为10 
    outputStream.write(bytes);
}

---

字符流

读文件（Read）

public static void main(String[] args) throws IOException {
    File file = new File("D:/text.txt");
    Reader reader = new FileReader(file);
    while(true){
        int b = reader.read();
        if(b == -1){
            break;
        }
        System.out.print((char)b+" ");
    }
}

代码结构与字节流类似

---

写文件

public static void main(String[] args) throws IOException {
    File file = new File("D:/text.txt");
    Writer writer = new FileWriter(file);
    writer.write(100);
    writer.write(101);
    writer.write(101);
    writer.write(101);
    writer.write(101);
}

代码结构依然和字节流类似，但是这次的执行结果出现了问题

我们发现文件里面并没有写数据，这是为什么呢？

--->:这是由于Writer处理数据的时候会用到缓冲区，当我们用到流资源的时候，用完之后是要将流对象资源关闭的(close)，而这个操作就会同时带动缓冲区的刷新。

所以字节流和字符流的区别也就在这：字节流即使没有执行关闭流对象操作，其结果依然运行得出来，而字符流就不行了，需要刷新缓冲区才能看得见结果，这里我们可以使用flush方法和close方法均可。

相关题目

1.给出搜索目录，删除指定文件

package IO;

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

//删除指定文件
public class IODemo1 {
    public static void main(String[] args) {
        System.out.println("请输入路径");
        Scanner sc = new Scanner(System.in);
        File root = null;
        while (true) {
            String basePath = sc.next();
            root = new File(basePath);
            if (!root.isDirectory()) {
                //路径错误或者是个文件
                System.out.println("路径错误,请重新输入");
            } else {
                break;
            }
        }
        System.out.println("请输入要删除的文件名");
        String nameToDelete = sc.next();

        scanDir(root, nameToDelete);
    }
        public static void scanDir(File root,String nameToDelete){
            File[] files = root.listFiles();
            if(files == null){
                //双击后目录为空
                return;
            }else{
                for(File file : files){
                    if(file.isDirectory()){
                        //还是目录
                        scanDir(file,nameToDelete);
                        //打印递归过程
                        System.out.println(file.getAbsolutePath());
                    }else{
                        if(file.getName().equals(nameToDelete)){
                            System.out.println("找到文件，是否确定删除");
                            System.out.println("Y : 确定  N : 取消");
                            Scanner sc = new Scanner(System.in);
                            String option = sc.next();
                            if(option.equals("Y")){
                                file.delete();
                                System.out.println("删除成功");
                                return;
                            }
                            if(option.equals("N")){
                                System.out.println("取消成功");
                                return;
                            }
                        }
                    }
                }
                System.out.println("没有找到该文件");
            }
        }
}

2.拷贝文件

//复制文件
public class IODemo2 {
    public static void main(String[] args) throws IOException {
        try(InputStream inputStream = new FileInputStream("D:/code/tmp/fsh.jpg");
            OutputStream outputStream = new FileOutputStream("D:/code/fsh1.jpg")){

            while(true){
                byte[] bytes = new byte[1024];
                int b = inputStream.read(bytes);
                if(b == -1){
                    break;
                }
                outputStream.write(bytes);
            }
        }
    }
}