前言

File类获取的方法

getName() | getPath()

 File getAbsoluteFile() | File getParentFile()

long length()

File类遍历方法

 IO流对象的分类

1.按照操作的文件类型分类

2.按照数据的流向分类

IO流对象的分类归纳

 OutputStream

字节输出流写入文件的步骤

 追加写入

FileInputStream

---

前言

我们之前进行Java基础入门学习时，都或多或少得遇到与get有关的方法，看它的名字就知道，带有此字样的方法，一般都是进行“获取”的操作

而今天我们就从File类获取开始，一步步学习

IO对象  字节输出流  字节输入流  字节缓冲流  转换流  打印流

---

File类获取的方法

File getAbsoluteFile()                 获取绝对路径，返回值是File类型

File getParentFile()                    获取父路径，返回值是File类型

String getName()                       获取名字，File构造方法中的路径名字

String getPath()                         获取File构造方法中的路径，完整的路径转成String返回

long length()                              获取文件的字节数

getName() | getPath()

 这里边 getName()和getPath()比较简单，代码格式与上一篇Java基础入门·File类的使用类似，感兴趣的小伙伴可以点击链接或者进入我的博客主页查看

public static void fileMethod1(){
        File file = new File("D:\\code\\Java");
        String name = file.getName();
        System.out.println("name = " + name);
        String path = file.getPath();
        System.out.println("path = " + path);
    }

 这里的返回值是路径的最后一个字符串，即“Java”，后面是文件，就返回文件名，是文件夹，就返回文件夹名

 getPath则是直接把构造参数D:\\code\\Java转成字符串（没有太大意义）

我们使用file.toString效果也是一样的

---

 File getAbsoluteFile() | File getParentFile()

File getAbsoluteFile()是获取绝对路径，我们一开始使用的就是绝对路径，所以输出结果没有发生任何变化

public static void fileMethod2(){
        File file = new File("D:\\code\\Java.exe");
        File absoluteFile = file.getAbsoluteFile();
        System.out.println("absoluteFile = " + absoluteFile);

    }

但当我们直接写一个文件名时，会默认在此目录下寻找该文件，若指定前面的父路径，，则结果可能又会不一样

File file = new File("Java.exe");

File file = new File("day8.8/Java.exe");

 getParentFile()用于获取父路径，返回的是一个file对象，所以我们仍可以对其进行多次 getParentFile()的操作

public static void fileMethod2(){
        File file = new File("D:\\code\\Java\\day18\\Java.exe");
        File absoluteFile = file.getAbsoluteFile();
        System.out.println("absoluteFile = " + absoluteFile);
        File parentFile = file.getParentFile();
        System.out.println("parentFile = " + parentFile);
    }

多次操作后，可见返回的是文件的父路径的父路径的父路径······

但一定不能超过盘符找父路径，否则会返回null

File parentFile = file.getParentFile().getParentFile().getParentFile();

---

long length()

获取文件的字节数

long length = file.length();
System.out.println("length = " + length);

---

File类遍历方法

listFiles()遍历目录，把该路径下的文件全部存入File数组里，我们对其进行遍历，就可以看到它把所以子路径都进行了存储

public static void fileMethod(){
        File file = new File("D:\\code\\Java\\day18");
        File[] files = file.listFiles();

        for(File f:files){
            System.out.println(f);
        }
    }

 我们知道，文件夹里还有可能会有其他文件夹，当我们需要用到里面的文件路径时，还可以进行更深入的递归遍历，把目录下的所有文件的全路径都存储起来

实现这个方法也很容易，首先把方法改为传参，以便传入子文件夹才能进行下一步遍历，for循环里加一个文件夹判断，然后递归即可

public static void main(String[] args) {
        //直接在此处new对象
        fileMethod(new File("D:\\code\\Java\\day18"));
    }

    //此处传参，便于递归遍历子文件夹再次调用
    public static void fileMethod(File dir){
        File[] files = dir.listFiles();
        for(File f:files){
            if(f.isDirectory())
                fileMethod(f);
            else
            System.out.println(f);
        }
    }

此处代码修改：

当代码运行后，我们可以看到控制台输出全部都是文件的路径，那如果要输出文件夹的路径，该怎么实现，我们只需要在遍历开始前，输出一遍就好 ，在这句代码前

File[] files = dir.listFiles();

加一句输出语句，大功告成

System.out.println(dir);

---

IO流对象

IO：Input Output IO的作用是将数据从一个设备中流入到另一个设备

数据文件，从磁盘中流向内存中，从磁盘中流向移动存储设备，从一台计算机流向另一台计算机

一切都是字节：任何数据文件都是字节组成，字节是计算机中最小存储单元（例如音乐、游戏、电影）

我们入门先了解什么输入输出

从Java程序里把数据存进文件中为：  输出

从文件中读取数据加载内存中为：      输入

---

 IO流对象的分类

1.按照操作的文件类型分类

文本类型文件     ——选择流对象字符流

什么是文本文件：使用文本工具：记事本，notepad++等等，打开文件后人类可以直接阅读的文件

非文本类型文件  ——选择流对象字节流

word文件是非文本文件

2.按照数据的流向分类

输入流：Java程序从其他地方读取数据

输出流：Java程序中的数据，写入到其他地方

---

IO流对象的分类归纳

四大抽象类 

字节输出流：OutputStream 抽象类（最高父类）

字节输入流：InputStream 抽象类（最高父类）

字符输出流：Writer 抽象类 （最高父类）

字符输入流：Reader抽象类 （最高父类）

---

 OutputStream

Java.io.OutputStream是所有字节输出流的超类：可以写入任何类型的文件

写入字节的方法write

void write(int b)                                                写入单个字节

void write(byte[] b)                                           写入字节数组

void write(byte[] b,int off,int len)                       写入数组的一部分，开始索引，写入的个数

FileOutputStream

构造方法：FileOutputStream(File file)

构造方法：FileOutputStream(String file)

创建字节输出流对象，绑定参数就是要写入的数据目的

IO流对象使用完毕后要释放资源

---

字节输出流写入文件的步骤

创建字节输出流对象，构造方法中，绑定文件路径，写入目的

调用流对象的方法write写入数据

释放资源

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

    public static void writeByte() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("F:\\Text\\1.txt");
        fileOutputStream.write(100);
        fileOutputStream.close();
    }

绑定的文件路径为1.txt，如果没有该文件，则自己创建，有，则覆盖里面的数据

下面的代码是写入字符串数组

public static void writeArray() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("F:\\Text\\1.txt");
        byte[] bytes = {97,98,99,100};
        fileOutputStream.write(bytes);
        fileOutputStream.write("good,well,nice".getBytes());
        fileOutputStream.close();
    }

 追加写入

 敲代码时可能已经想到了，存储文件数据，不能永远覆盖重来，每一次都是新的数据，旧数据丢失就没意义了，那想续接在后面怎么办：FileOutputStream第二个参数写true

 还有换行写入：Windows换行符号  \r  \n 

public static void writeAppend() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("F:\\Text\\1.txt",true);
        fileOutputStream.write("\r\n".getBytes());
        fileOutputStream.write("99,100,101".getBytes());
        fileOutputStream.close();
    }

---

Java.io.InputStream是所有字节输入流的超类：可以读取任何类型的文件

FileInputStream

构造方法：FileInputStream(File file)

构造方法：FileInputStream(String file)

创建字节输入流对象，绑定数据源文件

读取字节的方法read 

void read(int b)                                                读取单个字节

void read(byte[] b)                                           读取字节数组

 读取单个字节

public static void ReadByte() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("F:\\Text\\1.txt");
        int r = fileInputStream.read();
        System.out.println("r = " + r);
    }

read方法可以多次调用，每多调用一次就往后多读一个字节，读取到末尾时返回-1

这里出现了重复的代码，所以我们可以使用循环来遍历文件中所有字节

public static void ReadByte() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("F:\\Text\\1.txt");
        int r = 0;
        while ((r = fileInputStream.read())!=-1){
            System.out.print((char)r);
        }

    }

读取字节数组，可以一次读取多个字节，但也和上面一样，每多一次调用，就会往后读取直到末尾返回-1

public static void ReadArray() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("F:\\Text\\1.txt");
        byte[] bytes = new byte[5];
        //定义变量保存read方法的返回值
        int r = 0;
        r = fileInputStream.read(bytes);
        System.out.println("r = " + r);
        //数组转字符串
        System.out.println(new String(bytes));
    }

 增加了循环，修改String参数后的代码，读取多少个r，就转换r个，保证后面不出现上一次循环遗留的字符

public static void ReadArray() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("F:\\Text\\1.txt");
        byte[] bytes = new byte[2];
        //定义变量保存read方法的返回值
        int r = 0;
        while ((r = fileInputStream.read(bytes))!=-1){
            //此处增加String开始索引、转换的个数r
            System.out.print(new String(bytes,0,r));
        }
    }

tips：数组大小一般推荐设置1024的整数倍  byte[] bytes = new byte[1024];

今天的Java文章分享就到此结束了， 喜欢的小伙伴记得一键三连，点赞收藏评论，如果想了解更多内容，可以用未来百万富豪的手指，点点小小的关注！你们的支持就是我最大的动力！