第八章IO

File类

● File类是java.io包中很重要的一个类；

● File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代 表一个文件或目录；

● File对象可以对文件或目录的属性进行操作，如：文件名、最后修改日期、文件 大小等；

● File对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。

File类的构造方法

方 法 原 型：File(String pathname)

说 明 ：指定文件（或目录）名和路径创建文件对象

//在当前目录下创建一个与aaa.txt文件名相关联的文件对象 

File f1 = new File("aaa.txt"); 

//指明详细的路径以及文件名，请注意双斜线或用反斜杠 

File f2 = new File("D:\\Java\\Hello.java"); 

//指明详细的路径以及目录名，请注意双斜线 

File f3 = new File("D:\\Java");

● File类的常用方法

1、isDirectory()： 判断此File对象代表的路径表示是不是文件夹，只有File对象代表路径存在且是一个目录时才返回true，否则返回false。

2、isFile()：判断此File对象代表的路径是否是一个标准文件，只有File对代表路径存在且是一个标准文件时才返回true，否则返回false。

3、getPath()：返回File对象所表示的字符串路径。

4、getName()：返回此对象表示的文件或目录最后一级文件夹名称。

5、getParent()：返回此File对象的父目录路径名；如果此路径名没有指定父目录，则返回 null。

6、getParentFile()：返回File对象所在的父目录File实例；如果File对象没有父目录，则返回 null。

import java.io.File;

public class Work {
public static void main(String[] args){
	File file = new File("E:\\网易有道词典\\Youdao\\Dict\\guid.dat");

	if(file.isDirectory()) //1、判断该路径是否为文件夹。
	{
		System.out.println("YES");
	}else{
		System.out.println("NO");
	}
	
	if(file.isFile()) //2、判断该路径是否为文件。
	{
		System.out.println("yes");
	}else{
		System.out.println("no");
	}
	
	System.out.println(file.getPath()); //3、路径名称。
	
	System.out.println(file.getName()); //4、最后一层名称。
	
	System.out.println(file.getParent()); //5、去掉最后一层的路径名称。
	
	File file1 = file.getParentFile(); //6、返回File实例，路径为去掉最后一层的路径。
	System.out.println(file1.getPath());

}
}

7、 renameTo()：重新命名此File对象表示的文件，重命名成功返回true，否则返回false。

8、 mkdir()：创建此File类对象指定的目录(文件夹)，不包含父目录。创建成功回true，否则返回false。

9、 mkdirs()：创建此File对象指定的目录，包括所有必需但不存在的父目录，创建成功返回true；否则返回false。注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。

10、createNewFile()：如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false；如果所创建文件所在目录不存在则创建失败并出现IOException异常。

11、exists()：判断文件或目录是否存在。

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

public class Work {
public static void main(String[] args) throws IOException{
	File file = new File("D:\\Tom\\Jim.txt");
	
	System.out.println(file.renameTo(new File("D:\\Tom\\Jom.txt"))); //7、改名，括号中必须是File实例。
	
	Boolean flag = new File("D:\\Tom\\Lacy").mkdir(); //8、创建一层文件夹。
	System.out.println(flag);
	
	flag = new File("D:\\Tom\\a\\b").mkdirs(); //9、可以创建多层文件夹。
	System.out.println(flag);
	
	flag = new File("D:\\Tom\\a.doxc").createNewFile(); //10、创建一层文件。
	System.out.println(flag);
	
	System.out.println(new File("D:\\Tom\\a.doxc").exists()); //11、判断该文件或者文件夹是否存在。
	
}
}

12、 delete()：删除File类对象表示的目录或文件。如果该对象表示一个目录，则该目录必须为空才能删除；文件或目录删除成功返回true，否则false。

13、 list()：返回由File对象对应目录所包含文件名或文件夹名组成的字符串数组。

14、 listFiles()：返回由当前File对象对应目录所包含文件路径或文件夹路径组成的File类型的数组。

15、 separator：指定文件或目录路径时使用斜线或反斜线来写，但是考虑到跨平台，斜线反斜线最好使用File类的separator属性来表示。

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

public class Work {
public static void main(String[] args) throws IOException{
	File file = new File("D:\\Tom\\Jom.txt");
	File file1 = new File("D:"+File.separator+"Tom");  //15、File.separator会根据操作系统自动生成\\或者/。
	
	System.out.println(file.delete()); //12、删除文件或者内容为空的文件夹。
	
	String[] names = file1.list(); //13、返回该文件夹下的文件名称和文件夹名称。
	for (String name : names) {
		System.out.println(name);
	}
	
	File[] files = file1.listFiles(); //14、返回该文件夹下的文件和文件夹的File实例数组。
	for (File file2 : files) {
		System.out.println(file2.getPath());//输出路径。
	}
}
}

boolean exists()

判断文件是否存在，存在返回true，否则返回false

boolean isFile()

判断是否为文件，是文件返回true，否则返回false

boolean isDirectory()

判断是否为目录，是目录返回true，否则返回false

String getName()

获得文件的名称

long length()

获得文件的长度（字节数）

boolean createNewFile()

throws IOException

创建新文件，创建成功返回true，否则返回false，有可能抛出

IOException异常，必须捕捉

boolean delete()

删除文件，删除成功返回true，否则返回false

public String[] list()

将目录下的子目录及文件的名字，返回到String数组中

public File[] listFiles()

将目录下的子目录及文件的实例返回到File数组中

输入及输出的概念

● 输入输出（I/O）

把电脑硬盘上的数据读到程序中，称为输入,即input,进行数据的read 操作

从程序往外部设备写数据，称为输出，即output，进行数据的write

操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6NyMlu1k-1626494909062)(C:\Users\何文强\AppData\Roaming\Typora\typora-user-images\1624964940833.png)]

字节流与字符流

● 字节流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

1、FileInputStream（文件字节输入流）

package io;

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

public class ByteInput {
public static void main(String[] args) throws IOException {
	//1、定义要使用的文件
	File file = new File("F:" + File.separator + "byteInput.txt");
	file.createNewFile();   //文件存在的时候不会执行，不存在的时候会执行
 
	//2、定义字节输入流指定为文件输入流
	InputStream input = new FileInputStream(file);
	byte[] b = new byte[(int) file.length()]; // file.length()获取文件的长度返回long类型
	int len = input.read(b);
	input.close();
 
	//3、验证输入结果
	System.out.println("文件的内容长度为 : " + len);
	System.out.println("文件的内容为: " + new String(b));
}
}

2.FileOutputStream（文件字节输出流）实现对文件内容的逐字节处理

package io;

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

public class ByteOutput {
public static void main(String[] args) throws IOException{
	//1、获取要操作的文件
	File file=new File("F:"+File.separator+"byteOutput.txt");
	file.createNewFile();
	
	//2、写入指定的内容
	String str="I Like Java!";
	OutputStream output=new FileOutputStream(file);
	output.write(str.getBytes(), 0, str.length()); //写入字符串
	output.close();
}
}

● 字符流中常用类

字符输入流 FileReader

字符输出流 FileWriter

3、FileReader（文件字符输入流）实现对文件内容的逐字符处理

package io;

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

public class CharInput {
public static void main(String[] args) throws IOException {
	//1、指定要操作的文件
	File file=new File("F:"+File.separator+"charInput.txt");
	file.createNewFile();
	
	//2、指定字节输入流
	Reader reader=new FileReader(file);
	char[] c=new char[(int)file.length()];
	int len=reader.read(c);
	reader.close();
	
	//3、验证
	System.out.println("字符流读取文件的长度为: "+len);
	System.out.println("字符流读取文件的内容: "+new String(c));
}
}

4、FileWriter（文件字符输出流）实现对文件内容的逐字符处理

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

public class CharOutput {
public static void main(String[] args) throws IOException {
	File file = new File("F:" + File.separator + "charOutput.txt");
	file.createNewFile();
 
	Writer writer = new FileWriter(file);
	writer.write("I Love Basketball！", 0, 18);
	writer.close();
}
}

输入流与输出流

● 流按着数据的传输方向分为：

输入流：往程序中读叫输入流。

输出流：从程序中往外写叫输出流。

● InputStream和OutputStream的子类都是字节流

可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元 为1个字节。

● Reader和Writer的子类都是字符流

主要处理字符或字符串，字符流处理单元为1个字符。

字节流将读取到的字节数据，去指定的编码表中获取对应文字。

输入输出字节流

● InputStream的基本方法

读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。

int read() throws IOException

读取一系列字节并存储到一个数组buffer，

返回实际读取的字节数，如果读取前已到输入流的末尾返回-1

int read(byte[] buffer) throws IOException

关闭流释放内存资源

void close() throws IOException

● OutputStream的基本方法

向输出流中写入一个字节数据,该字节数据为参数b的低8位

void write(int b) throws IOException

将一个字节类型的数组中的从指定位置（off）开始的

len个字节写入到输出流

void write(byte[] b, int off, int len) throws IOException

关闭流释放内存资源

void close() throws IOException

节点流与处理流

● 根据封装类型不同流又分为

节点流

处理流

● 节点流：

如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，

则称为节点流。

● 处理流。

如果流封装的是其它流对象，称为处理流。

处理流提供了缓冲功能，提高读写效率,同时增加了一些新的方法。

● 节点流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

字符输入流 FileReader

字符输出流 FileWriter

● 处理流中常用类

缓冲字节输出流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

缓冲字符输入流 BufferedReader

缓冲字符输出流 BufferedWriter

//字符输入流
BufferedReader(Reader in)//创建一个32字节的缓冲区
BufferedReader(Reader in, int size)//size为自定义缓存区的大小

//字符输出流
BufferedWriter(Writer out)
BufferedWriter(Writer out, int size)

//字节输入流
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)

//字节输出流
BufferedOutputStream(OutputStream in)
BufferedOutputStream(OutputStream in, int size)

输入输出字符流

• Reader 的基本方法

读取一个字符并以整数的形式返回,

如果返回-1已到输入流的末尾。

int read() throws IOException

读取一系列字符并存储到一个数组buffer，

返回实际读取的字符数，如果读取前已到输入流的末尾返回-1

int read( char[] cbuf) throws IOException

关闭

void close() throws IOException

• Writer 的基本方法

向输出流中写入一个字符数据,该字节数据为参数b的16位

void write(int c) throws IOException

一个字符类型的数组中的数据写入输出流，

void write( char[] cbuf) throws IOException

将一个字符类型的数组中的从指定位置（off set）开始的

length个字符写入到输出流

void write( char[] cbuf, int off set, int length) throws IOException

关闭

void close() throws IOException

package com.zch.io;

import java.io.File;
import java.util.Date;

/**

 在src根目录下创建FileInfo类，在该类的主方法中创建文件对象，通过File类的相关方法，获取文件的相关信息
 
@author zch
*/
  public class FileInfo {
  public static void main(String[] args) {
String filePath ="src/com/zch/io/FileInfo.java";
// 根据指定路径创建文件对象
File file = new File(filePath);
System.out.println("文件名称:" + file.getName());
System.out.println("文件是否存在：" + file.exists());

System.out.println(“文件的相对路径：” + file.getPath());
System.out.println(“文件的绝对路径：” + file.getAbsolutePath());
System.out.println(“是否为可执行文件：” + file.canExecute());
System.out.println(“文件可以读取：” + file.canRead());
System.out.println(“文件可以写入：” + file.canWrite());
System.out.println(“文件上级路径：” + file.getParent());
System.out.println(“文件大小：” + file.length() + “B”);
System.out.println(“文件最后修改时间：” + new Date(file.lastModified()));
System.out.println(“是否文件类型：” + file.isFile());
System.out.println(“是否为文件夹：” + file.isDirectory());
}

}

Print流

Print 打印流：只做输出没有输入

打印流分为字节打印流和字符打印流

PrintWriter：字符打印流

print方法可以打印各种类型数据

对象输入输出流

● 对象的输入输出流 : 主要的作用是用于写入对象信息与读取对象信息。 对象信息 一旦写到文件上那么对象的信息就可以做到持久化了

对象的输出流： ObjectOutputStream

对象的输入流: ObjectInputStream

● 要将序列化之后的对象保存下来，需要通过对象输出流(ObjectOutputStream)

将对象状态保存，之后再通过对象输入流(ObjectInputStream)将对象状态恢复。

在ObjectInputStream 中用readObject()方法可以直接读取一个对象， ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。

对象序列化

● 对象的寿命通常随着生成该对象的程序的终止而终止。

有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。

● 对象的输出流将指定的对象写入到文件的过程，就是将对象序列化的过程，对象 的输入流将指定序列化好的文件读出来的过程，就是对象反序列化的过程。既然 对象的输出流将对象写入到文件中称之为对象的序列化，所以必须要实现 Serializable接口。

Serializable接口中没有任何方法。当一个类声明实现Serializable接口后， 表明该类可被序列化。

在类中可以生成一个编号

private static final long serialVersionUID = -5974713180104013488L; 随机生成 唯一的 serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。某个类在 与之对应的对象已经序列化出去后做了修改，该对象依然可以被正确反序列化

public class Example {
    public static void main(String[] args) {
        User user = new User("Tom", "111", 21);
        try {
            FileOutputStream fos = new FileOutputStream("C:\\Example.txt");
            //创建输出流对象，使之可以将对象写入文件中
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            //将对象写入文件
            oos.writeObject(user);
            System.out.println("修改之前用户的信息：");
            System.out.println("用户名：" + user.name);
            System.out.println("原密码：" + user.password);
            System.out.println("年龄：" + user.age);

            FileInputStream fis = new FileInputStream("C:\\Example.txt");
            //创建输入流对象，使之可以从文件中读取数据
            ObjectInputStream ois = new ObjectInputStream(fis);
            user = (User) ois.readObject();
            user.setPassword("222");
            System.out.println("修改之后的用户信息：");
            System.out.println("用户名：" + user.name);
            System.out.println("修改之后的密码：" + user.password);
            System.out.println("年龄：" + user.age);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    String name;
    String password;
    int age;

    User(String name, String password, int age) {
        this.name = name;
        this.password = password;
        this.age = age;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

​