结构
字节流
输入字节流：读数据
-----|InputStream 所有输入字节流的基类。 抽象类。
----------|FileInputStream 读取文件的输入字节流。
----------|BufferedInputStream 缓冲输入字节流，为了提高读取文件数据的效率。
输出字节流: 写数据
-----|OutputStream 所有输出字节流的基类。 抽象类。
----------|FileOutputStream 向文件输出数据 的输出字节流。
----------|BufferedOutputStream 缓冲输出字节流，为了提高向文件写数据的效率
字符流
输入字符流：读数据
-----|Reader 所有输入字符流的基类。 抽象类。
----------|FileReader 读取文件字符的输入字符流。
----------|BufferedReader 缓冲输入字符流，提高读取文件字符的效率并且拓展了功能（readLine()）
输出字符流：写数据
-----|Writer 所有输出字符流的基类。 抽象类。
----------|FileWriter 向文件输出字符数据的输出字符流。
----------|BufferedWriter 缓冲输出字符流，提高写文件字符的效率并且拓展了功能（newLine()）。
File类
创建File
File file = new File("a.txt");// 默认项目路径
file.createNewFile();
file = new File("aaa");
file.mkdir();
file = new File("aaa\\\\bbb\\\\ccc");
file.mkdirs();// 创建多级目录
file.delete();
File 判断功能
File file = new File("a.txt");
System.out.println("Create:" + file.createNewFile());
System.out.println("exists():" + file.exists());// file对象是否存在
System.out.println("ifFile():" + file.isFile());// 是否文件
System.out.println("isDirectory():" + file.isDirectory());// 是否文件夹
System.out.println("isAbsolute():" + file.isAbsolute());// 是否绝对路径
System.out.println("canRead():" + file.canRead());// 可读
System.out.println("canWrite():" + file.canWrite());
System.out.println("isHidden():" + file.isHidden());// 是否隐藏
System.out.println("delete():" + file.delete());
File获取属性
File file2 = new File("hello\\\\txt");
File file = new File(file2, "a.txt");
System.out.println("mkdris(): " + file2.mkdirs());
System.out.println("createNewFile(): " + file.createNewFile());
System.out.println("getName(): " + file.getName());
System.out.println("getAbsolutePath(): " + file.getAbsolutePath());// 输出绝对路径
System.out.println("getPath: " + file.getPath());// 相对路径
System.out.println("length(): " + file.length());// 文件大小，字节单位
System.out.println("lastModified(): " + file.lastModified());// 上次修改时间毫秒值
System.out.println("delete file and rec: " + file.delete() + " " + file2.delete());
Reader
FileReader 字符输入流
public static void main(String[] args) {
// 1.一次读一个字符的方式
FileReader read = null;
try {
read= new FileReader("a.txt");
int c;
try {
// 达到流末尾返回-1
// read()自动跳转到下一个字符
while((c=read.read()) != -1){
System.out.print((char)c);
}
read.close();
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
method2();
}
// 2.一次读取一个字符数组
private static void method2() {
try {
FileReader read=new FileReader("a.txt");
char[] ch = new char[4];
int len = 0; // 实际长度
try {
while((len=read.read(ch)) != -1){
System.out.print(new String(ch, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
BufferedReader 缓冲字符输入流
- public String readLine():一次读取一行，但是不包含换行符
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
String line = "";
while((line = br.readLine()) != null){
System.out.println(line);
}
br.close();
Writer
FileWriter 字符输出流
换行Windows：\\r\\n
macOS：\\n
Linux：\\n
FileWriter w = null;
try {
// 创建字符输出流对象
w = new FileWriter("a.txt", false); // 默认：false覆盖，true追加
w.write("xyg\\r\\n");
w.flush();// 字符流需要刷新缓存流
w.close();// 释放
} catch (IOException e) {
e.printStackTrace();
} finally {
if (w != null) {
try {
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
BufferedWriter
- public void newLine():根据系统平台写入换行符
- BufferedWriter(Writer out):构造方法
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
for(int i=1;i<=5;i++){
bw.write("this is "+i+" line."); //底层调用Writer类写方法
bw.newLine();
}
bw.close();//对一个文件不能同时读写操作
InputStream
FileInputStream 字节输入流，从文件中读取
FileInputStream fis = new FileInputStream("a_copy.txt");
// 一次读一个字节
// int by;
// while((by = fis.read())!=-1){
// System.out.print((char)by);
// }
// 一次读一个字节数组
byte[] by = new byte[2024];
int len;
while( (len = fis.read(by)) != -1 ){
System.out.print(new String(by, 0, len));
}
fis.close();
BufferedInputStream 缓冲字节输入流
//接收一个字节输入流对象，字节缓冲区流仅仅提供缓冲区,真正的读写操作还是依靠基本的流对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("a.txt"));
byte[] bytes = new byte[1024];
int len = 0;
while((len = bufferedInputStream.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
bufferedInputStream.close();
OutputStream
FileOutputStream 字节输出流，写入到文件
FileOutputStream fos = new FileOutputStream("a_copy.txt");
//字节数组
byte[] by = {97,98,99,100};
//字符串转字节数组
byte[] byStr = "hello".getBytes();
//写入字节数组的一部分
fos.write(by, 0, 4);
fos.write(byStr);
fos.flush();
fos.close();
BufferedOutputStream 缓冲字节输出流
//接收一个字节输出流对象，字节缓冲区流仅仅提供缓冲区,真正的读写操作还是依靠基本的流对象
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("a.txt"));
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
bufferedOutputStream.write(line.getBytes());
bufferedOutputStream.close();
转换
InputStreamReader 输入字节流=>输入字符流
FileInputStream fileInputStream = new FileInputStream("a.txt");
// 字节输入转换流，指定编码
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "utf-8");
int content=0;
while((content=inputStreamReader.read())!=-1){
System.out.print((char)content);
}
fileInputStream.close();
OutputStreamReader 输出字节流=>输出字符流
// 字节输出流
FileOutputStream fileOutputStream = new FileOutputStream("a.txt");
// 字节输出转换流，指定编码
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
outputStreamWriter.write("你好世界"); //转换为字符流即可写入字符数据
outputStreamWriter.close(); // 关闭刷新
应用
遍历文件夹
// 遍历盘符
File[] rootArray = File.listRoots();
for (File e : rootArray)
System.out.println(e);
// 返回指定目录下文件和文件夹名称数组
File file = new File("D:\\\\");
String[] list = file.list();
for (String e : list)
System.out.println(e);
// 返回指定目录下文件和文件夹对象数组
File[] fList = file.listFiles();
for (File e : fList)
System.out.println(e.getName());
判断指定目录下指定后缀文件
File file = new File("D:\\\\");
String[] list = file.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
File fTemp = new File(file, name);
boolean flag = fTemp.isFile();// 判断是否是文件
boolean flag2 = name.endsWith(".dll");// 判断是否指定后缀
return flag2 && flag;
}
});
for (String e : list)
System.out.println(e);
拷贝文件
FileInputStream fis = new FileInputStream("b.txt");
FileOutputStream fos = new FileOutputStream("D:\\\\b_copy.txt");
byte[] by = new byte[1024];
int len;
while((len=(fis.read(by)))!=-1){
fos.write(by, 0, len);
}
fis.close();
fos.close();