1. File 类
public class File extends Object implements Serializable, Comparable<File>
构造方法
常用方法：
| 变量和类型 | 方法 | 描述 |
| boolean | delete() | 删除此抽象路径名表示的文件或目录 |
| boolean | isFile() | 测试此抽象路径名表示的文件是否为普通文件。 |
| String | getName() | 返回此抽象路径名表示的文件或目录的名称。 |
| String | getParent() | 返回此抽象路径名父项的路径名字符串，如果此路径名未指定父目录，则返回 null 。 |
| File | getParent() | 返回此抽象路径名父项的路径名，如果此路径名未指定父目录，则返回 null 。 |
| long | length() | 返回此抽象路径名表示的文件的长度。 |
| File[] | listFiles() | 返回一个抽象路径名数组，表示此抽象路径名表示的目录中的文件。 |
| boolean | mkdir() | 创建此抽象路径名指定的目录。 |
| boolean | mkdirs() | 创建此抽象路径名指定的目录，包括任何必需但不存在的父目录 |
| boolean | exists() | 测试此抽象路径名表示的文件或目录是否存在 |
| String | getAbsolutePath() | 返回此抽象路径名的绝对路径名字符串。 |
| String[] | list() | 返回一个字符串数组，用于命名此抽象路径名表示的目录中的文件和目录 |
| File[] | listFiles() | 返回一个抽象路径名数组，表示此抽象路径名表示的目录中的文件。 |
| boolean | renameTo(File dest) | 重命名此抽象路径名表示的文件。 |
| boolean | createNewFile() | 当且仅当具有此名称的文件尚不存在时，以原子方式创建由此抽象路径名命名的新空文件 |
| File[] | istFiles(FileFilter filter) | 返回一个抽象路径名数组，表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 |
java跨平台时候，不同系统的路径分隔符和名称分隔符并不相同，使用时用""+pathSeparator
和""+separator表示路径，实现跨平台路径访问。
与系统相关的路径分隔符，为方便起见，表示为字符串。 System.out.println(File.pathSeparator); : 系统相关的默认名称分隔符，为方便起见，表示为字符串。 System.out.println(File.separator); \
package Demo;
import java.io.File;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
//创建文件对象，并指定文件路径 此时只是个文件对象，并未创建指定路径下的文件或文件夹
//如果此路径下存在该名称的文件或者文件夹则指向此文件或文件夹
File file = new File("绝对路径"); // D://demo.txt
//创建的是文件
boolean newFile = file.createNewFile();
System.out.println(newFile?"创建成功":"创建失败");
File file1 = new File("绝对路径");// D://demo.txt
//创建的是文件夹
boolean mkdir = file1.mkdir();
System.out.println(mkdir?"创建成功":"创建失败");
//File(File parent, String child) 在父文件夹中创建一个子文件
File a = new File("d:haha");
a.mkdir();
File file2 = new File(a,"a.txt");
file2.createNewFile();
//File(String parent, String child) 在父文件夹中创建一个子文件
File b = new File("d://haha");
b.mkdir();
File file3 = new File("d://haha","b.txt");
file3.createNewFile();
//删除
file2.delete();
file3.delete();
//将file文件重命名并剪切到新的文件目录下
File newFile1 = new File("d:\\a.zip");
file.renameTo(newFile1);
}
}
示例：
查找e盘下的所有以avi结尾的文件并打印文件的绝对路径
扩展：可以基于此思想写一个垃圾清理文件，记住一定要弄明白垃圾文件的后缀
import java.io.File;
public class Demo {
public static void main(String[] args) {
File e = new File("e://");
File[] files = e.listFiles();
listFile(files);
}
public static void listFile(File[] files){
if(files!=null&&files.length>0){
for (File file:files) {
if(file.isFile()){
if(file.getName().endsWith(".avi")){
//if(file.length()>100*1024*1024) //100KB 设置判断大小
System.out.println("找到了一个avi文件"+file.getAbsolutePath());
// file.delete();
//System.out.println(file.getAbsolutePath()+"路径下的文件以删除");
}
}else {
File[] files2 = file.listFiles();
listFile(files2);
}
}
}
}
}
运行结果：
示例：
使用文件过滤器
package Demo;
import java.io.File;
import java.io.FileFilter;
public class Demo2 {
public static void main(String[] args) {
File e = new File("e://");
//获取e盘下的第一层所有 文件（文件夹和目录）
listFiles(e);
}
private static void listFiles(File file) {
//创建一个过滤器，并描述其规则
FileFilter ileFilter = new AVIFileFilter();
// 通过问价夹获得子文件夹 此处的listFiles方法为File类的方法不是此类定义的方法
File[] files = file.listFiles(ileFilter);
for (File f : files) {
//此处判断如果是目录文件夹，则递归调用listFiles
if(f.isDirectory()){
listFiles(f);
}else {
System.out.println("发现一个avi"+f.getAbsolutePath());
}
}
}
static class AVIFileFilter implements FileFilter{
@Override
public boolean accept(File pathname) {
//如果文件是以.avi结尾的或者不是文件而是文件夹 返回ture 否则返回fase
if(pathname.getName().endsWith(".avi")|| pathname.isDirectory()){
return true;
}
return false;
}
}
}
2. 相对路径和绝对路径
绝对路径： 从盘符开始，是一个完整的路径。 例如：c://a.txt
相对路径： 在Java代码中是相对于项目目录路径，这是一个不完整的便捷路径，开发中很常用
File file1 = new File("c://a.txt");
File file2 = new File("a.txt");
System.out.println("File1的路径:"+file1.getAbsolutePath());
System.out.println("File2的路径:"+file2.getAbsolutePath());
输出的结果：
File1的路径:c:\a.txt
File2的路径:D:\Users\Administrator\IdeaProjects\Maven\io\a.txt
Javaweb项目中是：相对路径是从web文件夹开始
3. io流概述
可以将这种数据传输操作,看做一种数据的流动 , 按照流动的方向分为输入Input和输出Output Java中的IO操作主要指的是 java.io包下的一些常用类的使用. 通过这些常用类对数据进行读取(输入Input) 和 写出(输出Output)
IO流的分类: 按照流的方向来分,可以分为:输入流和输出流. 按照流动的数据类型来分,可以分为:字节流 和 字符流（生活中的文字，解决乱码问题）
字节流:
- 输入流 : InputStream
- 输出流 : OutputStream
字符流（对字节流进行了处理）:
- 输入流 : Reader
- 输出流 : Writer
一切皆字节:
计算机中的任何数据(文本,图片,视频,音乐等等)都是以二进制的形式存储的.
在数据传输时 也都是以二进制的形式存储的.
后续学习的任何流 , 在传输时底层都是二进制.
一些流是带有缓存区的，比如FileWriter，当一个文字占几个字节时，java写出时先将前面的字节缓存，当字节输出完时，一起写入，写入时间调用close方法，当程序没有调用close()方法时，这时候是看不到输出效果的，这时候就要使用flush方法 将缓存区的流 写出
OutputStream（抽象类）
-
-
变量和类型 方法 描述 voidclose()关闭此输出流并释放与此流关联的所有系统资源。
voidflush()刷新此输出流并强制写出任何缓冲的输出字节。
static OutputStreamnullOutputStream()返回一个新的
OutputStream，它丢弃所有字节。voidwrite(byte[] b)将
b.length字节从指定的字节数组写入此输出流。voidwrite(byte[] b, int off, int len)将从偏移量
off开始的指定字节数组中的len字节写入此输出流。abstract voidwrite(int b)将指定的字节写入此输出流。
-
- public abstract void write(int b) throws IOException
- 将指定的字节写入此输出流。
write的一般合同是将一个字节写入输出流。 要写入的字节是参数b的八个低位。b的24个高位被忽略。OutputStream子类必须提供此方法的实现。
- 将指定的字节写入此输出流。
FileOutputStream
继承了OutputStream流，是一个字节类型的输出流
-
-
变量和类型 方法 描述 voidclose()关闭此文件输出流并释放与此流关联的所有系统资源。
protected voidfinalize()不推荐使用，要删除：此API元素将在以后的版本中删除。 finalize方法已被弃用，将被删除。FileChannelgetChannel()返回与此文件输出流关联的唯一FileChannel对象。
FileDescriptorgetFD()返回与此流关联的文件描述符。
voidwrite(byte[] b)将指定字节数组中的
b.length字节写入此文件输出流。voidwrite(byte[] b, int off, int len)将从偏移量
off开始的指定字节数组中的len字节写入此文件输出流。voidwrite(int b)将指定的字节写入此文件输出流。
-
-
-
-
public FileOutputStream(String name) throws FileNotFoundException
创建文件输出流以写入具有指定名称的文件。 创建一个新的FileDescriptor对象来表示此文件连接。首先，如果有安全管理器，
checkWritename作为参数调用其checkWrite方法。如果文件存在但是是目录而不是常规文件，则不存在但无法创建，或者由于任何其他原因无法打开，则抛出
FileNotFoundException。 -
异常
FileNotFoundException- 如果文件存在但是是目录而不是常规文件，则不存在但无法创建，或者由于任何其他原因无法打开 SecurityException- 如果存在安全管理器且其checkWrite方法拒绝对该文件的写访问权。
-
-
package Demo;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
//OutputStream
//覆盖写入
FileOutputStream fos = new FileOutputStream("c://a.txt");
//追加写入
// FileOutputStream fos = new FileOutputStream("c://a.txt",true);
//bite数组方式写入
// byte[] bytes = {65,66,67,68,69};
// fos.write(bytes);
//bite方式写入
// byte bytes1 = 65;
// fos.write(bytes1);
//bite数组写入 指定开始下标，和写入的数量
byte[] bytes2 = "ABCDEF".getBytes();
fos.write(bytes2,2,2);
fos.close(); //写在哪在哪关闭
System.out.println("已经写出");
}
}
FileInputStream
继承了 InputStream流 (这里不再介绍InputStream抽象类)，是一个字节类型的输入流
构造方法
-
-
构造器 描述 FileInputStream(File file)通过打开与实际文件的连接来创建
FileInputStream，该文件由文件系统中的File对象file命名。FileInputStream(FileDescriptor fdObj)使用文件描述符
fdObj创建FileInputStream，该文件描述符表示与文件系统中实际文件的现有连接。FileInputStream(String name)通过打开与实际文件的连接来创建
FileInputStream，该文件由文件系统中的路径名name命名。
-
常用方法：
| 变量和类型 | 方法 | 描述 |
| void | close() | 关闭此文件输入流并释放与该流关联的所有系统资源。 |
| int | read() | 从此输入流中读取一个字节的数据。 |
| int | read(byte[] b) | 从此输入流 b.length最多 b.length字节的数据读 b.length字节数组 |
| int | read(byte[] b, int off, int len) | 从此输入流 len最多 len字节的数据读入一个字节数组。 |
-
-
-
read
public int read() throws IOException
从此输入流中读取一个字节的数据。 如果尚未提供输入，此方法将阻止。
Specified by:
结果
数据的下一个字节，如果到达文件的末尾，
-1。异常
IOException- 如果发生I / O错误。
-
read
public int read(byte[] b) throws IOException
从此输入流
b.length最多b.length个字节的数据读入一个字节数组。 此方法将阻塞，直到某些输入可用。重写：
参数
b- 读取数据的缓冲区。结果
读入缓冲区的总字节数，如果由于文件末尾已到达而没有更多数据，
-1。异常
IOException- 如果发生I / O错误。另请参见：
-
从输入流中读取一些字节数并将它们存储到缓冲区数组b 。 实际读取的字节数以整数形式返回。 此方法将阻塞，直到输入数据可用，检测到文件结尾或引发异常。
如果b的长度为零，则不读取任何字节，并返回0 ; 否则，尝试读取至少一个字节。 如果由于流位于文件末尾而没有可用字节，则返回值-1 ; 否则，至少读取一个字节并存储到b 。读取的第一个字节存储在元素b[0] ，下一个字节存入b[1] ，依此类推。 读取的字节数最多等于b的长度。 设k为实际读取的字节数; 这些字节将存储在元素b[0]到b[ k -1] ，使元素b[ k ]到b[b.length-1]不受影响。
-
参数
b - 读取数据的缓冲区。
结果
读入缓冲区的总字节数，如果由于已到达流末尾而没有更多数据， -1 。
异常
IOException - 如果由于文件末尾以外的任何原因无法读取第一个字节，如果输入流已关闭，或者发生某些其他I / O错误。
NullPointerException - 如果 b是 null
-
read
public int read(byte[] b, int off, int len) throws IOException
从此输入流
len最多len字节的数据读入一个字节数组。 如果len不为零，则该方法将阻塞，直到某些输入可用; 否则，不读取任何字节，返回0。重写：
参数
b- 读取数据的缓冲区。off- 目标阵列b的起始偏移量len- 读取的最大字节数。结果
读入缓冲区的总字节数，如果由于文件末尾已到达而没有更多数据，
-1。异常
NullPointerException- 如果b是null。IndexOutOfBoundsException- 如果off为负数，len为负数，或者len为大于b.length - offIOException- 如果发生I / O错误。另请参见：
-
-
package Demo;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo {
//InputStream
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("d://a.txt");
/*while (true){
//int b = fis.read();// 这里的int 和强转后的byte输出结果一样 不同处是， 值字节返回int ，范围为0至255
byte b = (byte) fis.read();
if(b==-1){
break;
}
System.out.println(b);
}*/
// byte[] bytes = new byte[10];
// //得到读取字节的长度
// int len = fis.read(bytes);
// //将bite类型的数组转换成String类型，从0到len
// System.out.println(new String(bytes,0,len));
// len = fis.read(bytes);
// System.out.println(new String(bytes,0,len));
// len = fis.read(bytes);
// System.out.println(new String(bytes,0,len));
// fis.close();
int b = fis.read();
System.out.println(b);
}
}
FileWriter
继承自OutputSteeamWriter ，OutputStreamWriter的父类为Writer，针对字符的输出
常用的构造方法
FileWriter(File file) r
给 File写一个 FileWriter ，使用平台的 default charset
FileWriter(File file, boolean append)
在给出要写入的 FileWriter下构造 File ，并使用平台的 default charset构造一个布尔值，指示是否附加写入的数据。
package zuoye;
import java.io.FileWriter;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
//writer
FileWriter fw = new FileWriter("c://b.txt",true);
fw.write('a'); //char 类型比int 类型小可以自动转换
fw.write("a"); //String类型
fw.append("锄禾日当午").append("，").append("汗滴禾下土"); //可以一致追加
fw.write("锄禾日当午");
fw.flush(); //刷新
fw.close();
}
}
FilterReader
继承自InputStreamReader ，InputStreamReader的父类为Reader
常用的构造方法
FileReader(File file)
使用平台 FileReader ，在 File读取时创建一个新的 FileReader 。
FileReader(String fileName)
使用平台 default charset创建一个新的 FileReader ，给定要读取的文件的 名称 。
package Demo;
import java.io.FileReader;
public class Demo {
public static void main(String[] args) throws Exception {
//reader
FileReader fr = new FileReader("b.txt");
// while (true){
// int c = fr.read();
// if(c==-1){
// break;
// }
// System.out.println((char)c);
// }
char[] chars = new char[100]; //数组默认都是0
int len = fr.read(chars);
//fr.read(chars);
String text = new String(chars, 0, len);
System.out.println(text);
System.out.println(text.length());
fr.close();
}
}字节流 转换字符流
很多时候都需要将字节流转换成可以读懂的字符，这时就需要将其转换成字符流
InputStreamReader 可以将字节输入流转化为字符输入流。
OutputStreamWriter 可以将字节输出流转化为字符输出流。
package Demo;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Demo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("b.txt");
//将字节流，转换为字符流 其实本质是装饰 ：使用的是装饰者模型
//参数1. 要转换的的字节流
//参数2. 指定的编码名称
InputStreamReader isr = new InputStreamReader(fis);
// while (true){
// int c=isr.read();
// if (c== -1){
// break;
// }
// System.out.println((char)c);
// }
char[] chars = new char[100];
int len = isr.read(chars);
System.out.println(chars);
}
}
public class Demo {
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("a.txt");
OutputStreamWriter osw =new OutputStreamWriter(fos);
osw.write("现在是2021年10月");
osw.flush();
osw.close();
}打印流和缓存读取流
PrintStream
继承了FilterOutputStream.是"装饰类"的一种,所以属于字节流体系中(与PrintStream相似的流PrintWriter继承于Writer,属于字符流体系中),为其他的输出流添加功能.使它们能够方便打印各种数据值的表示形式.此外,值得注意的是:
与其他流不同的是,PrintStream流永远不会抛出异常.因为做了try{}catch(){}会将异常捕获,出现异常情况会在内部设置标识,通过checkError()获取此标识.
PrintStream流有自动刷新机制,例如当向PrintStream流中写入一个字节数组后自动调用flush()方法
PrintWriter PrintWriter() 的作用是为了定义流输出的位置，并且此流可以正常的存储中文，减少乱码输出，同样不会抛出异常。
BufferedReader 缓存读取流，提供通用的缓冲方式文本读取,而且提供了很实用的readLine,读取一个文本行,从字符输入流中读取文本,缓存各个字符。
package Demo;
import java.io.*;
public class Demo10 {
public static void main(String[] args) throws Exception {
//字符输出 (字节打印流) 与PrintWriter效果基本相同，但是进行字符输出时还是使用后者
PrintStream ps = new PrintStream("a.txt");
ps.println("嘿嘿嘿");
ps.println(10);
ps.close();
//打印流 （字符打印流）这里没有close()方法 要加上flush()不然不会显示结果
PrintWriter pw = new PrintWriter("b.txt");
pw.println("哈哈哈");
pw.close();
FileOutputStream fos = new FileOutputStream("c.txt");
PrintWriter pw1 = new PrintWriter(fos);
pw1.println("转换流输出");
pw.flush();
pw1.close();
//缓存读取流 将字符流输入流，转换为带有缓存，可以异常读取一行的缓存字符读取流
FileReader fr = new FileReader("a.txt");
BufferedReader bf =new BufferedReader(fr);
String s = bf.readLine();
System.out.println(s);
FileInputStream fis = new FileInputStream("b.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader bf1 =new BufferedReader(isr);
String s1 = bf1.readLine();
System.out.println(s1);
}
}
总结：
FileOutputStream和FileInputStream 是字节流，前者是字节输出流，后者是字节输入流
FileWriter和FilterReader 是字符流，前者是字符输出流，后者是字符输入流
OutputStreamWriter和InputStreamReader 是字符转换输出输入流
OutputStreamWriter 可以将字节输入流转化为字符输入流
FileOutputStream fos = new FileOutputStream("a.txt");
OutputStreamWriter osw =new OutputStreamWriter(fos);
osw.write("现在是2021年10月");
osw.flush();
osw.close();
InputStreamReader 可以将字节输出流转化为字符输出流
FileInputStream fis = new FileInputStream("b.txt");
InputStreamReader isr = new InputStreamReader(fis);
char[] chars = new char[100];
int len = isr.read(chars);
System.out.println(chars);
PrintStream和PrintWriter 是打印输出流，前者是字节流，后者是字符流
PrintStream ps = new PrintStream( OutputStream类型 );
PrintWriter pw = new PrintWriter(OutputStream类型 或者 Writer类型（包含OutputStreamWriter） );
示例：
FileOutputStream fos = new FileOutputStream("a.txt");
OutputStreamWriter osw =new OutputStreamWriter(fos);
PrintWriter pw = new PrintWriter(osw);
pw3.println("嘿嘿嘿");
BufferedReader 缓存读取流
BufferedReader bf =new BufferedReader(Reader类型);
示例：
FileReader fr = new FileReader("a.txt");
BufferedReader bf =new BufferedReader(fr);
String s = bf.readLine();
System.out.println(s);
//一般不会创建个类型转来转去，看需求
FileInputStream fis = new FileInputStream("b.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader bf1 =new BufferedReader(isr);
String s1 = bf1.readLine();
System.out.println(s1);
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
