您的当前位置：首页 Java基础（5）File类与IO流

Java基础（5）File类与IO流

来源：榕意旅游网

File类与IO流

一、File类

1、概述

可以使用File类的方法

创建一个文件/文件夹
删除文件/文件夹
获取文件/文件夹
判断文件/文件夹是否存在
对文件夹进行遍历
获取文件的大小

File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法

静态成员变量

static String PathSeparator: 与系统有关的路径分隔符为了方便被表示成一个字符串

static char PathSeparatorChar 与系统有关的路径分隔符

static String Separator: 与系统有关的 默认名称 分隔符为了方便被表示成一个字符串

static char SeparatorChar：与系统有关的 默认名称 分隔符

操作路径：（不能写死）

F:\JAVA_code：windows（反斜杠 \ ）
F:/JAVA_code: Linux（正斜杠 / ）
“F:+File.Separator+JAVA_code”

2、构造方法

1、File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新File 实例。

2、File(String parent, String child)
根据parent 路径名字符串和child路径名字符串创建一个新File实例。

参数:把路径分成了两部分

String parent：父路径

String child：子路径
好处:
父路径和子路径,可以单独书写，使用起来非常灵活;父路径和子路径都可以变化

3、File(File parent, String child)
根据parent 抽象路径名和child 路径名字符串创建一个新File 实例。

参数:把路径分成了两部分

File parent:父路径
String child:子路径
好处:
父路径和子路径,可以单独书写，使用起来非常灵活;父路径和子路径都可以变化
父路径是File类型,可以使用File的方法对路径进行一-些操作,再使用路径创建对象public String

3、常用方法

3.1、获取

public String getAbsolutePath(): 返回此File的绝对路径名字符串。absolute：adj.绝对的，完全的

无论路径是绝对的还是相对的，该方法都返回的是绝对路径

public String getPath() : 将此File转换为路径名字符串。

toString方法就是调用的getPath方法：

public String toString() {
    return getPath();
}

获取的就是构造方法中的路径尾部的文件/文件夹

File file1 = new File("F:\\111\\222\\333\\444");
System.out.println(file1.getName());//444

File file2 = new File("F:\\111\\222\\333\\444\\4.txt");
System.out.println(file2.getName());//4.txt

public long length(): 返回由此File表示的文件的长度（大小），以字节为单位。

返回值:

以此抽象路径名表示的文件的长度(以字节为单位)，如果文件不存在返回0L。一些操作系统可能会返回。0L用于表示系统相关实体(如设备或管道)的路径名。

注意：文件夹没有大小概念，不能获取文件夹大小；若路径不存在，则返回0。

3.2、判断

3.3、创建与删除

public boolean createNewFile() : 当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。

创建文件的路径和名称在构造方法中给出(构造方法的参数)
返回值:布尔值
true :文件不存在,创建文件，返回true
false:文件存在,不会创建,返回false
注意:
1.此方法只能创建文件，不能创建文件夹
2.创建文件的路径必须存在,否则会抛出异常

可以删除构造方法路径中给出的文件/文件夹
返回值:布尔值
true:文件/文件夹删除成功，返回true
false:文件夹中有内容 ,不会删除返回false;构造方法中路径不存在false
注意:
delete方法是直接在硬盘删余文件/文件夹,不走回收站,删除要谨慎

true:文件夹不存在,创建文件夹.返回true
false:文件夹存在,不会创建，返回false;构造方法中给出的路径不存在返回false
注意:
此方法只能创建文件夹,不能创建文件

可以创建文件

路径不存在，返回true，但不会创建

3.4、File类的遍历

注意:

能获取到隐藏的文件/文件夹

二、递归

递归:在当前方法内调用自己。
分类:
直接递归：自己调用自己。
间接递归：A调B，B调C，C调A。

注意:
递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出。
在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。
构造方法，禁止递归

练习：

1、求1+2+3+…+n的和

public static void main(String[] args) {
        System.out.println(sun(5));//15
    }
public static int sun(int b){
    if(b == 1) return 1;
    return b + sun(b-1);
}

2、求阶乘

public static void main(String[] args) {
        System.out.println(multip(5));//120
    }
public static int multip(int i){
    if(i == 2) return 2;
    return i*multip(i-1);
}

public static void main(String[] args) {
    File file = new File("F:");
    fun(file);
}

public static void fun(File file){
    //判断目录是否真实存在
     if(!file.exists()){
         System.out.println(file+"目录不是真实存在的");
         return;
     }
     //参数传递进来的不是一个文件夹
     if(!file.isDirectory()) {
         System.out.println("错误路径："+file);
         return;
     }
    
    System.out.println("==============="+file.getName()+"===============");
    File[] files = file.listFiles();
    for (File s :files) {
        if(!s.isDirectory()) {
            System.out.println(s.getName());//输出这个文件下的文件名
        }else{
            fun(s);//每次递归的都是一个文件夹
        }
    }
}

4、在F:盘寻找.java文件（只要稍微修改题目3的代码，就可以实现）

public static void main(String[] args) {
    File file = new File("F:");
    fun(file);
}
public static void fun(File file){
    //判断目录是否真实存在
     if(!file.exists()){
         System.out.println(file+"目录不是真实存在的");
         return;
     }
     //参数传递进来的不是一个文件夹
     if(!file.isDirectory()) {
         System.out.println("错误路径："+file);
         return;
     }
     File[] files = file.listFiles();
   	 for (File s :files) {
          if(s.isFile()){
              if (s.toString().endsWith(".txt")){
                  System.out.println(s.toString());
              }
          }else{
              fun(s);//每次递归的都是一个文件夹
         }
     }
}

三、文件过滤器

在File类中有两个和ListFiles重载的方法，方法的参数传递的就是过滤器

1、File[] listFiles(FileFilter filter)

java.io.FileFilter接口:

用于抽象路径名(File对象)的过滤器。过滤文件（File对象）

唯一的抽象方法：
boolean accept(File pathname) 测试指定抽象路径名是否应该包含在某个路径名列表中。

2、File[] listFiles(FilenameFilter filter)

java. io.FilenameFilter接口:

实现此接口的类实例可用于过滤器文件名。过滤文件名

唯一的抽象方法:
boolean accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中。

例：

public class Demo01 {
    public static void main(String[] args) {
        File file = new File("F:");
        fun(file);
    }

    public static void fun(File file){
        File[] files = file.listFiles(new InterfaceImp());
        for (File s :files) {
            if(!s.isDirectory()) {
                System.out.println(s.getName());//输出这个文件下的文件名
            }else{
                fun(s);//每次递归的都是一个文件夹
            }
        }
    }
}

package Demo03.FileFilter;

import java.io.File;
import java.io.FileFilter;

public class InterfaceImp implements FileFilter {
    @Override
    public boolean accept(File pathname){
        return  false;//若为true 输出就有输出结果，false无
    }
}

通过以上案例可以发现：

accept方法返回的是一个布尔值，

true：就会把传过去的File对象存到File数组中

false：不会把传过去的File对象存到File数组中

匿名内部类实现

1、FileFilter

....
public static void fun(File file){
    File[] files = file.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            if(pathname.isDirectory()){
                return true;
            }
            return pathname.getName().endsWith(".txt");
        }
    });
....

2、FilenameFilter

File[] files = file.listFiles(new FilenameFilter(){
    @Override
    public boolean accept(File dir, String name){
        return new File(dir,name).isDirectory() || name.endsWith(".txt");
    }
});
//File[] files = file.listFiles((dir, name)-> new File(dir,name).isDirectory() || name.endsWith(".txt"));

四、IO流

1、字节流

一切文件数据(文本图片、视频等)在存储时,都是以二进制数字的形式保存,都是一个一个的字节,传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底
层传输的始终为二进制数据。

1.1、字节输出流

Java.io.OutputStream:字节输出流，（父类）。二进制输出的跟类（父类）

1.1.1、子类共性的成员方法

public void close() : 关闭此输出流并释放与此流相关联的任何系统资源。

public void flush() : 刷新此输出流并强制任何缓冲的输出字节被写出。

public void write(byte[] b): 将b.length字节从指定的字节数组写入此输出流。

一次写多个字节:
如果写的第一个字节是正数(0- 127),那么显示的时候会查询ASCII表
如果写的第一个字节是负数，那第一个字节会和第二个字节两个字节组成一个中文显示，查询系统默认码表(GBK)

public void write(byte[] b, int off, int Len) :从指定的字节数组写入Len字节，从偏移量off开始输出到此输出流。

off :数组开始的索引

Len:写几个字节

public abstract void write(int b) :将指定的字节输出流。

java. io. FileOutputstream extends Outputstream

FileOutputStream:文件字节输出流
作用: 把内存中的数据写入到硬盘的文件中

1.1.2、FileOutputstream类的构造方法

FileOutputStream(String name )创建一个向具有指定名称的文件中写入数据的输出文件流。
Fileoutputstream(File file) 创建一个向指定File 对象表示的文件中写入数据的文件输出流。
参数: （写入数据的目的地）
String name ;目的地是一个文件的路径
File file:目的地是一个文件

构造方法的作用:
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
3.会把Fileoutputstream对象指向创建好的文件

写入数据的原理

(内存–>硬盘)
java程序 --> JVM(java虚拟机) --> 0S(操作系统) --> 0S调用写数据的方法 --> 把数据写入到文件中

1.1.3、字节输入输出流的使用步骤

1、创建一个FileOutputStream对象，构造方法中传入写入数据的目的地

2、调用FileOutputStream中的write方法，把数据写入到文件中。

3、释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提供程序的效率）

FileOutputStream fileOutputStream = new FileOutputStream("F:\\a.txt");

fileOutputStream.write(97);

fileOutputStream.close();

1.1.4、续写和换行

追加写/续写:使用两个参数的构造方法
FileOutputstream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
Fileoutputstream(File file, boolean append) 创建一个向指定File 对象表示的文件中写入数据的文件输出流。
参数:
String noame,File file:写入数据的目的地
boolean append:追加写开关
true :创建对象不会覆盖源文件。继续在文件的末尾追加写数据
false:创建一个新文件,覆盖源文件

写换行:写换行符号
windows: \r\n
linux:/n
mac:/r

1.2、字节输入流

java.io.Inputstream:字节输入流，二进制输入的分类（父类）。

1.2.1、子类共性的方法

int read()从输入流中读取数据的下一个字节。

int read(byte[] b)将此输入流中的数据读取到字节数组中，最大长度为b.length字节

参数

b：数据被读入的缓冲区

返回值

到达文件的末尾时则返回-1

否则，返回读取到缓冲区的字节总数

void close() 关闭此输入流并释放与该流关联的所有系统资源。

java. io. FileInputStream extends Inputstream
FileInputStream:文件字节输入流
作用:把硬盘文件中的数据，读取到内存中使用

1.2.2、FileInputStream类的构造方法

FileInputStream(String name )
FileInputstream(File file)
参数：读取文件的数据源
String name :文件的路径
File file:文件

构造方法的作用:
1.会创建一个FileInputStream对象
2.会把FileInputstream对象指定构造方法中要读取的文件

度去数据的使用原理：

java程序 --> JVM --> OS --> OS读取数据的方法 --> 读取文件

1.2.3成员方法

public int read()从此输入流中读取一个数据字节。如果没有输入可用，此方法将阻塞。

返回下一个数据字节；若达到这个文件的末尾，则返回-1。

FileInputStream f = new FileInputStream("b.txt");
int len = 0;
  while((len = f.read()) != -1){
      System.out.println(len);
  }

public int read(byte[] b)从此输入流中最多将 b.length 个字节读入到一个byte数组中，返回读取的实际字节数；若已经到达文件的末尾，则返回-1。

字节数组b起到缓冲作用，存储每次读取到的多个字节

数组的长度一般定义为1024（1kb）或1024的整数倍

返回值为每次读取的有效值个数

2、字符流

2.1、字符输入流

java. io. Reader :字符输入流，是字符输入流的最顶层的父类,定义了一些共性的成员方法,是一个抽象类

2.1.1、共性的成员方法

int read() 读取单个字符并返回。
int read(char[] cbuf) 一次读取多个字符,将字符读入数组。
void close() 关闭该流并释放与之关联的所有资源。

2.2.2、文件字符输入流

java.io.FileReader extends InputStreamReader

InputStreamReader extends Reader

FileReader:文件字符输入流
作用:把硬盘文件中的数据以字符的方式读取到内存中

构造方法

FileReader(String fileName)
FileReader(File file)
参数:读取文件的数据源
String fil eName：文件的路径
File file：一个文件
FileReader构造方法的作用:
1.创建一个FileReader对象
2.会把FileReader对象指向要读取的文件

2.2、字符输出流

java. io. Writer :字符输出流,是所有字符输出流的最顶层的父类是一个抽象类

2.2.1、共性的成员方法

void write(int c)写入单个字符。

void write(char[] cbuf)写入字符数组。

abstract void write(char[] cbuf, int off， int len)写入字符数组的某一部分, off数组的开始索引，len写的字符个数。

在OutputstreamWriter 中被实现

void write(String str)写入字符串。

void write(String str, int off, int Len) 写入字符串的某一部分, off字符串的开始索引, len写的字符个数。

void flush()刷新该流的缓冲。

void close() 关闭此流，但要先刷新它。

2.2.2、文件字符输出流

java. io.FileWriter. extends OutputstreamWriter

OutputstreamWriter extends Writer

FileWriter:文件字符输出流

作用:把内存中字符数据写入到文件中

构造方法

Filelriter(File file )根据给定的File 对象构造一个FileWriter 对象。
Filelriter(String fileName) 根据给定的文件名构造一个FileWriter 对象。
参数:写入数据的目的地
String fileName :文件的路径
File file:是一个文件
构造方法的作用:
1.会创建一个FileWriter对象
2.会根据构造方法中传递的文件/文件的路径创建文件
3.会把FileWriter对象指向创建好的文件

字节输出流使用步骤：

2.2.3、续写和换行

追加续写（与字节流一样）

这里写出我个人遇到的小问题

 public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("b.txt");
        char[] chars = new char[1024];
        int flage = 0;
        while((flage = fileReader.read(chars)) != -1);
        System.out.println("原始文件中的数据为：");
        System.out.println(chars);//ABCD

     	//追加续写
        FileWriter fileWriter = new FileWriter("b.txt",true);
        for (int i = 0; i < 10; i++) {
            fileWriter.write(i+65);
        }
        //咳咳

        flage = 0;
        while((flage = fileReader.read(chars)) != -1);
        System.out.println("追加写入后获取的chars:");
        System.out.println(chars);
     	fileWriter.close();//咳咳
        fileReader.close();
    }

运行后输出结果为

原始文件中的数据为：
ABCD

追加写入后的chars:
ABCD

新建对象，重新获取：
ABCD

文件b.txt中内容为：ABCDABCDEFGHIJ

本以为是因为第二次输出前的fileReader.read(chars)已经指到第一次ABCD的末尾了，继续往后跳只会获取到新写进去的ABCD 不再会获取到之前的了，但是追加写入的是ABCDEFGHIJ。这个想法是错误的。

正解：

根据文件b中的数据可以发现数据是写入到文件中了，但是调用read方法时没有将数据获取到字符数组中。又根据writer方法的特点：只是把数据写到内存缓冲区中，需要调用flush方法或是close方法将数据刷新到文件中，而这段代码在最后才将内存缓冲区的数据ABCDEFGHIJ刷新到文件中，这就是这段代码的问题。

五、Properties集合

java.util.Properties集合 extends Hashtable<k, v> implements Map<k, v>

Properties类表示了一个持久的属性。Properties可保存在流中或从流中加载。

Properties是唯一一个和IO流相结合的集合

1、成员方法

1、store方法

把集合中的临时数据，持久化的写入到硬盘中存储。

void store(OutputStream out, String comments)
//OutputStream out字节输出流 不可以写中文

void store(Writer writer, String comments)
//Writer writer字符输出流  可以写中文
//String comments注释，用来说明保存的文件是干什么的

使用步骤

1、创建Properties集合对象，添加数据

2、创建字符/字节输出流对象，构造方法中绑定要输出的目的地

3、使用Properties集合中的方法store，把集合中的临时数据持久的写入到硬盘中

4、释放资源

// 1、创建Properties集合对象，添加数据
Properties properties =  new Properties();
properties.setProperty("1\\2","hh");
properties.setProperty("1\\3","hhh");
properties.setProperty("1\\4","hhhh");

//2、创建字符/字节输出流对象，构造方法中绑定要输出的目的地
FileWriter fw = new FileWriter("b.txt");
//3、使用Properties集合中的方法store，把集合中的临时数据持久的写入到硬盘中
properties.store(fw,"save date");
//4释放资源
fw.close();

2、load方法

把硬盘中保存的文件（键值对），读取到集合中使用。

使用步骤

1、创建Properties集合对象

2、load方法读取保存键值对的文件

3、遍历Properties集合

在文件中的某一行最前端写上#，就会将此行注释调，不会被读取。

Set stringPropertyNames() 从此属性列表返回一组不可修改的键，其中键及其对应值为字符串，如果尚未从主属性列表中找到同名键，则默认属性列表中包含不同的键。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文