本文介绍了Java中的File类，包括其作用、构造方法和常用方法，如读写权限、文件属性的检查。接着讲解了File对象如何创建、删除目录以及列出目录内容。此外，还探讨了Java的输入输出流，区分了字符流和字节流，并举例说明了如何进行文件读写操作，包括异常处理和使用缓冲流提高效率。最后提到了对象的序列化和反序列化，以及Serializable接口的重要性。
File类:
概述：
1.是java.io包中很重要的一个类。
2.File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；
3.File对象可以对文件或目录的属性进行操作，如：文件名、最后修改日期、文件 大小等；
canRead(); 测试应用程序是否可以读取由此抽象路径名表示的文件。
canWrite(); 测试应用程序是否可以修改由此抽象路径名表示的文件。
lastModified(); //返回此抽象路径名表示的文件上次修改的时间。
getAbsoluteFile(); //返回此抽象路径名的绝对形式。
isAbsolute(); //测试这个抽象路径名是否是绝对的。
isDirectory(); //测试此抽象路径名表示的文件是否为目录。
isHidden(); //测试此抽象路径名命名的文件是否为隐藏文件。
public class FileDemo1 {
/*
一个File类的对象，可以表示计算机硬盘上的一个文件或目录（文件夹）
可以获取为念信息，创建文件，删除文件
但不能对文件中的数据进行读写操作
*/
public static void main(String[] args) {
//指明详细的路径以及文件名，请注意双斜线或用反斜杠; 指明详细的路径以及目录名，请注意双斜线。
File f = new File("D:/Demo.txt");
String p = "D:/";
File f1 = new File(p, "Demo.txt");
System.out.println(f1.canRead());
System.out.println(f1.canWrite());
System.out.println(f.canRead()); //测试应用程序是否可以读取由此抽象路径名表示的文件。
System.out.println(f.canWrite()); //测试应用程序是否可以修改由此抽象路径名表示的文件。
System.out.println(new Date(f.lastModified())); //返回此抽象路径名表示的文件上次修改的时间。
System.out.println(f.getAbsoluteFile()); //返回此抽象路径名的绝对形式。
System.out.println(f.isAbsolute()); //测试这个抽象路径名是否是绝对的。
System.out.println(f.isDirectory()); //测试此抽象路径名表示的文件是否为目录。
System.out.println(f.isHidden()); //测试此抽象路径名命名的文件是否为隐藏文件。
}
}delete(); //删除文件夹，文件夹里必须为空才可删
File d = new File("D:/a");
d.mkdir(); //创建单级路径文件夹 D:/a
d.mkdirs(); //创建多级路径文件夹 D:/a/b/c
d.delete(); //删除文件夹，文件夹里必须为空才可删
String[] fs = file.list(); //返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
File file = new File("D:/下载");
String[] fs = file.list(); //返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
for(String s:fs){
System.out.println(s);
//筛选出后缀名为exe的文件
File f1 = new File("D:/下载");
File[] files = f1.listFiles((e)->{return e.getName().endsWith("exe");});
for(File s:files){
//返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
System.out.println(s);
}IO输入输出：
概述：
把电脑硬盘上的数据读到程序中，称为输入,即input,进行数据的read 操作。
从程序往外部设备写数据，称为输出，即output，进行数据的write 操作。
字符字节流：从数据流编码格式上划分为字符流和字节流。
1.字节流：每次读写是以字节为单位(计算机中的所有数据存储都是字节单位)，可以读取任意文件（视频，音频...)
2.字符流：每次读写是以字符为单位，只能读取纯文本文件( txt， java，html）
| 字符流 | 字节流 | ||
| 输入字符流 | 输出字符流 | 输入字节流 | 输出字节流 |
| InputStream | OutStream | Reader | Writer |
| InputStreamReader | OutputStreamWriter | ||
| FileInputStream | FileOutStream | FileReader | FileWriter |
InputStreamReader：输入转换流，可以把原始字节编码转为字符。
OutputStreamWriter：将字符流转为字节。
read():每次只能读入或写出一个字节，效率低，读写次数多。
//创建一个输入字节流对象，并为其指定要读的文件。 注意：原文件不存在时会报错
FileInputStream in = new FileInputStream("D:/Demo.txt");
//输出时文件不存在会自动创建
FileOutputStream out = new FileOutputStream("D:/a/Demo.txt");
//每次读到一个字节数据并返回，直到读完后返回-1
in.read();
int b = 0;
while ((b = in.read()) != -1) {
out.write(b);
}
in.close();
out.close();//关闭流的通道，释放文件in.read(b):每次读一个byte数组个字节内容,返回实际向数组中装入的字节数量，读完后返回-1
//节点流直接负责数据读与写
FileInputStream in = new FileInputStream("D:/FeiQ.exe");
FileOutputStream out = new FileOutputStream("D:/Demo.exe");
//每次读一个byte数组个字节内容,返回实际向数组中装入的字节数量，读完后返回-1
byte[] b = new byte[1024];
int size = 0;
while ((size = in.read(b)) != -1) {
//每次向外写出一个byte数组个字节，从第0个开始，写size个
out.write(b, 0, size);
}
in.close();
out.close();异常处理：
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("D:/FeiQ.exe");
out = new FileOutputStream("D:/Demo.exe");
//每次读一个byte数组个字节内容,返回实际向数组中装入的字节数量，读完后返回-1
byte[] b = new byte[1024];
int size = 0;
while ((size = in.read(b)) != -1) {
//每次向外写出一个byte数组个字节，从第0个开始，写size个
out.write(b, 0, size);
}
} catch (FileNotFoundException e) {
System.out.println("文件找不到异常");
e.printStackTrace();
} catch (IOException e) {
System.out.println("传输中断");
} finally {
try {
if (in!=null){
in.close();
}
if (out!=null){
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}节点流和处理流 ：
根据封装类型不同分为节点流和处理流/包装流。
节点流：如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等， 则称为节点流。直接负责对接文件，进行读写。
节点流中常用类：
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
处理流：如果流封装的是其它流对象，称为处理流。 处理流提供了缓冲功能，提高读写效率,同时增加了一些新的方法。
处理流中常用类：
缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter
//节点流直接负责数据读与写
FileInputStream in = new FileInputStream("D:/FeiQ.exe");
FileOutputStream out = new FileOutputStream("D:/Demo.exe");
//处理流/包装流/缓存流（带缓冲区）
BufferedInputStream bin = new BufferedInputStream(in);
BufferedOutputStream bout = new BufferedOutputStream(out);
//每次读一个byte数组个字节内容,返回实际向数组中装入的字节数量，读完后返回-1
byte[] b = new byte[1024];
int size=0;
while ((size=bin.read(b))!=-1){
//每次向外写出一个byte数组个字节，从第0个开始，写size个
bout.write(b, 0 , size);
}
bin.close();
bout.flush();//刷新缓存区
bout.close();字符流：
read():每次只能读入或写出一个字符，效率低，读写次数多。
//字符流只能读纯文本文件
FileReader reader = new FileReader("D:\\1\\JavaSE\\2022-1-1IO2\\练习\\demo.txt");
FileWriter writer = new FileWriter("D:\\1\\JavaSE\\2022-1-1IO2\\练习\\demo1.txt");
int c = 0; //每次读一个字符编码
while ((c=reader.read())!=-1){
System.out.println(c);
writer.write(c);
}
reader.close();
writer.close();reader.read()：读入一个数组个字符
//字符流只能读纯文本文件
FileReader reader = new FileReader("D:\\1\\JavaSE\\2022-1-1IO2\\练习\\demo.txt");
FileWriter writer = new FileWriter("D:\\1\\JavaSE\\2022-1-1IO2\\练习\\demo1.txt");
char[] c = new char[10];
int size = 0;
while ((size=reader.read())!=-1){
System.out.println(size);
writer.write(c);
}
reader.close();
writer.close();缓冲流：
//字符流只能读纯文本文件
FileReader reader = new FileReader("D:\\练习\\demo.txt");
FileWriter writer = new FileWriter("D:\\练习\\demo1.txt",true);//后面输入不会覆盖，保留前面内容
//字符处理流
BufferedReader breader = new BufferedReader(reader);
BufferedWriter bwriter = new BufferedWriter(writer);
//String line = breader.readLine();//每次读一行数据
String line = null;
while ((line = breader.readLine())!=null){
bwriter.write(line); //每次读一行数据
bwriter.newLine(); //插入一个换行符
}
breader.close();
bwriter.flush(); //缓冲流关闭前需要刷新
bwriter.close();对象输入输出流：
主要的作用是用于写入对象信息与读取对象信息。
为什么要将运行时的对象输出到文件中？
答：为了实现数据持久保存，对象信息一旦写到文件上那么对象的信息就可以做到持久化了。
对象输出 -->对象序列化
对象输入流，将文件中存储的对象信息再次输入到程序中 --> 对象反序列化(Java中创建对象方式之一)
对象的输出流：ObjectOutputStream
对象序列化：
对象的输出流将指定的对象写入到文件的过程，就是将对象序列化的过程。
//将对象信息输出到文件中，成为对象序列化，对象的类必须实现Serializable接口
FileOutputStream out = new FileOutputStream("D:\\obj.txt");
ObjectOutputStream objout = new ObjectOutputStream(out);
objout.writeObject(date);
objout.writeObject(s);
objout.writeObject(user);
objout.flush();
objout.close();对象反序列化：
对象的输入流将指定序列化好的文件读出来的过程，就是对象反序列化的过程。
//对象反序列化，将文件中的信息输入到程序中，创建对象
FileInputStream in = new FileInputStream("D:\\obj.txt");
ObjectInputStream objin = new ObjectInputStream(in);
Date date = (Date)objin.readObject();
String s = (String)objin.readObject();
User user = (User) objin.readObject();
System.out.println(date);
System.out.println(s);
System.out.println(user);注意：
1.既然对象的输出流将对象写入到文件中称之为对象的序列化，所以必须要实现Serializable接口。
2.Serializable接口中没有方法。当一个类声明实现Serializable接口后， 表明该类可被序列化。
在类中可以生成一个编号 private static final long serialVersionUID=-5974713180104013488L;
随机生成唯一的 serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。某个类在与之对
应的对象已经序列化出去后做了修改，该对象依然可以被正确反序列化。
扫一扫
2819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
