1. File类
- File将文件或者目录封装为对象,从而对文件或者目录进行创建或删除
- 对于File而言,其封装的仅仅是一个路径名而已。它可以是存在的,也可以是不存在的
1.1 File类的构造方法
绝对路径:是一个完整的路径,从盘符开始
相对路径:是一个简化的路径,相对当前项目下的路径
方法名 | 说明 |
---|---|
File(String pathname) | 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 |
File(String parent, String child) | 从父路径名字符串和子路径名字符串创建新的 File实例 |
File(File parent, String child) | 从父抽象路径名和子路径名字符串创建新的 File实例 |
public class MyFileDemo01 {
public static void main(String[] args) {
String path1 = "D:\\yulufeng";
String path2 = "\\aaa.txt";
//使用两个字符串拼接创建 File实例
File file = new File(path1, path2);
//通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File file1 = new File(path1);
//使用字符串和File对象,创建File实例
File file2 = new File(file1, path2);
System.out.println(file);//D:\yulufeng\aaa.txt
System.out.println(file2);//D:\yulufeng\aaa.txt
//相对路径:是一个简化的路径,相对当前工程下的路径
String path3 = "day11_exercise\\day11.txt";
File file3 = new File(path3);
//获取绝对路径
System.out.println(file3.getAbsolutePath());
//F:\employment_class\IdeaProjects\AdvanceCode\day11_exercise\day11.txt
}
}
1.2 File类的创建功能
方法名 | 说明 |
---|---|
public boolean createNewFile() | 当具有该名称的文件不存在时,创建一个新空文件,只能创建文件 |
public boolean mkdir() | 只能创建单级文件夹,只能创建文件夹 |
public boolean mkdirs() | 可以创建单级文件夹和多级文件夹,只能创建文件夹 |
import java.io.File;
import java.io.IOException;
public class MyFileDemo02 {
public static void main(String[] args) throws IOException {
//相对路径:是一个简化的路径,相对当前项目下的路径
String path1 = "D:\\yulu\\feng";
File file1 = new File(path1);
//创建多级文件夹
boolean result1 = file1.mkdirs();
System.out.println(result1);//true
//创建文件aaa.txt
String path2 = "\\aaa.txt";
File file2 = new File(file1, path2);
boolean result2 = file2.createNewFile();
System.out.println(result2);//true
}
}
1.3 File类的删除功能和判断获取功能
删除方法:public boolean delete() 删除由此抽象路径名表示的文件或目录
- delete() 方法直接删除,不走回收站
- 如果删除的是文件,直接删除;如果删除的是文件夹必须为空
- 如果文件夹不为空,使用递归删除
判断方法:
方法名 | 说明 |
---|---|
public boolean isDirectory() | 测试此抽象路径名表示的File是否为目录 |
public boolean isFile() | 测试此抽象路径名表示的File是否为文件 |
public boolean exists() | 测试此抽象路径名表示的File是否存在 |
获取方法:
方法名 | 说明 |
---|---|
public String getAbsolutePath() | 返回此抽象路径名的绝对路径名字符串 |
public String getPath() | 将此抽象路径名转换为路径名字符串 |
public String getName() | 返回由此抽象路径名表示的文件或目录的名称 |
public File[] listFiles() | 返回此抽象路径名表示的目录中的文件和目录的File对象数组 |
案例一:递归删除非空文件夹
import java.io.File;
public class MyFileDemo01 {
public static void main(String[] args) {
//递归删除非空目录
File src = new File("D:\\yulu\\feng");
deleteFile(src);
}
private static void deleteFile(File src) {
//得到src文件夹中的所有file对象
File[] files = src.listFiles();
//遍历files删除src中的文件和文件夹
for (File file : files) {
//判断,如果是文件直接删除
if (file.isFile()){
file.delete();
}
//判断,如果是目录,调用删除目录方法
if (file.isDirectory()){
deleteFile(file);
}
}
//删除src空文件夹
src.delete();
}
}
案例二:统计一个文件夹中每种文件的个数并打印
public class Test2 {
public static void main(String[] args) {
//统计一个文件夹中,每种文件出现的次数.
//统计 --- 定义一个变量用来统计. ---- 弊端:同时只能统计一种文件
//利用map集合进行数据统计,键 --- 文件后缀名 值 ---- 次数
File file = new File("filemodule");
HashMap<String, Integer> hm = new HashMap<>();
getCount(hm, file);
System.out.println(hm);
}
//1.定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
private static void getCount(HashMap<String, Integer> hm, File file) {
//2.遍历File对象,获取它下边的每一个文件和文件夹对象
File[] files = file.listFiles();
for (File f : files) {
//3.判断当前File对象是文件还是文件夹
if(f.isFile()){
//如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过
String fileName = f.getName();
String[] fileNameArr = fileName.split("\\.");
if(fileNameArr.length == 2){
String fileEndName = fileNameArr[1];
if(hm.containsKey(fileEndName)){
//出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中
Integer count = hm.get(fileEndName);
//这种文件又出现了一次.
count++;
//把已经出现的次数给覆盖掉.
hm.put(fileEndName,count);
}else{
// 没出现过,将这种类型文件的后缀名存入集合中,次数存1
hm.put(fileEndName,1);
}
}
}else{
//如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象代码实现
getCount(hm,f);
}
}
}
}
2. IO流的概述和分类
IO流介绍:
- IO:输入/输出(Input/Output)
- 流:数据在设备间的传输称为流,流的本质是数据传输
- IO流就是用来处理设备间数据传输问题的。常见的应用: 文件复制; 文件上传; 文件下载
IO流的分类 :
输入输出都是相对于内存而言:
- 输入流:读数据(内存读入数据)
- 输出流:写数据(内存向磁盘写数据)
按照数据类型来分
- 字节流:字节输入流和字节输出流
- 字符流:字符输入流和字符输出流(字符流:纯文本文件,可以用记事本打开)
IO流的使用场景:
- 如果操作的是纯文本文件,优先使用字符流
- 如果操作的是图片、视频、音频等二进制文件,优先使用字节流
- 如果不确定文件类型,优先使用字节流。字节流是万能的流
3. 字节流
3.1 字节输出流(写数据)
使用字节输出流写数据的步骤:
- 创建字节输出流(FileOutputStream)对象,让字节输出流对象指向文件
- 调用字节输出流对象的写数据方法
- 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
输出流写数据的方法分类:
方法名 | 说明 |
---|---|
void write(int b) | 将指定的字节写入此文件输出流 一次写一个字节数据 |
void write(byte[] b) | 将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据 |
void write(byte[] b, int off, int len) | 将 len字节从指定的字节数组开始,从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据 |
代码示例:
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutPutDemo {
public static void main(String[] args) throws IOException {
//创建输出流对象fos,参数可以是String或者是File对象
OutputStream fos = new FileOutputStream("day11_exercise\\aaa.txt");
byte[] bt = {97,98,99,100,101,102,103,104};
int a = 97;
//写数据的三种方法
//file.write(a);
//file.write(bt);
fos.write(bt, 0, 5);
//释放资源
fos.close();
}
}
字节输出流写数据实现换行和不覆盖写入:
import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节输出流对象,第二个参数传入true可以实现数据追加输入
FileOutputStream fos = new FileOutputStream("day11_exercise\\fos.txt",true);
/* 写数据实现换行
- windows:\r\n
- linux:\n
- mac:\r
*/
for (int i = 0; i < 10; i++) {
//必须以字节类型写入调用getBytes方法,返回的是一个byte型数组
fos.write("hello".getBytes());
fos.write("\r\n".getBytes());
}
//释放资源
fos.close();
}
}
3.2 字节输出流写数据的异常处理
异常处理格式:try-catch-finally(被finally控制的语句一定会执行,用于实现资源释放 )
try{
可能出现异常的代码;
}catch(异常类名 变量名){
异常的处理代码;
}finally{
执行所有清除操作;
}
示例代码:
public class FileOutputStreamDemo04 {
public static void main(String[] args) {
//加入finally来实现释放资源
FileOutputStream fos = null;
try {
fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.3 字节输入流(读取数据)
字节输入流,以实际存在文件路径作为参数,创建一个FileInputStream对象,该路径可以是String类型也可以是File类型
字节输入流读取数据的步骤:
- 创建字节输入流对象(FileInputStream)
- 调用字节输入流对象的读数据方法
- 释放资源
read一次读取一个字节:
import java.io.FileInputStream;
import java.io.IOException;
public class InputDemo {
public static void main(String[] args) throws IOException {
//创建一个字节输入流对象fis
FileInputStream fis = new FileInputStream("day11_exercise\\aaa.txt");
int b ;//用于记录读入内存的字节
//若文件读取完毕会返回-1
while((b = fis.read()) != -1){
System.out.println((char)b);
}
//释放资源
fis.close();
}
}
read一次读入一个字节数组:
import java.io.FileInputStream;
import java.io.IOException;
public class InputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
byte[] bys = new byte[1024]; //临时存放读入内存的字节,一次读取1024字节
int len;//若文件读取完毕返回-1
//循环读取
while ((len=fis.read(bys))!=-1) {
//使用平台的默认字符集解码指定的字节子阵列来构造新的String对象,并打印
System.out.print(new String(bys,0,len));
}
//释放资源
fis.close();
}
}
3.4 利用字节输入和输出流复制文件
实现步骤:
- 根据数据源地址创建字节输入流对象
- 根据目的地地址创建字节输出流对象
- 读写数据,复制图片(一次读取一个字节数组,一次写入一个字节数组)
- 释放资源
实现代码:
import java.io.*;
public class copyDemo {
public static void main(String[] args) throws IOException {
File file = new File("E:\\网络图片\\05.jpg");
//创建输入流对象
FileInputStream fis = new FileInputStream(file);
//创建输出流对象
FileOutputStream fos = new FileOutputStream("day11_exercise\\" + file.getName());
int len;
byte[] bys = new byte[1024];
//一次读入一个字节数组
while((len = fis.read(bys))!=-1){
//一次写入一个字节数组
fos.write(bys);
}
//释放资源
fis.close();
fos.close();
}
}
4. 字节缓冲流
字节缓冲流介绍:
-
lBufferOutputStream:字节缓冲输入流,提高了字节输入流的读取效率
-
lBufferedInputStream:字节缓冲输出流,提高了字节输出流的写数据效率
构造方法:
方法名 | 说明 |
---|---|
BufferedOutputStream(OutputStream out) | 创建字节缓冲输出流对象 |
BufferedInputStream(InputStream in) | 创建字节缓冲输入流对象 |
使用字节缓冲流复制视频:
import java.io.*;
public class CopyDemo03 {
public static void main(String[] args) throws IOException {
//字节缓冲输入流对象bis
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("E:\\视频\\夏目友人帐第一季-001.mp4"));
//字节缓冲输出流bos
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("E:\\视频\\copy夏目友人帐第一季-001.mp4"));
long l1 = System.currentTimeMillis();
byte[] bytes = new byte[1024];
int len;
//一次读入1024字节
while((len = bis.read(bytes)) != -1){
bos.write(bytes, 0, len);
}
long l2 = System.currentTimeMillis();
bos.close();
bis.close();
System.out.println(l2-l1);
}
}
使用字节缓冲流实现文件夹的复制:
import java.io.*;
public class CopyFile1 {
public static void main(String[] args) throws IOException {
//将F盘的CSDN材料复制到D盘
File file1 = new File("F:\\CSDN材料");
File file2 = new File("D:");
copyAllFile(file1, file2);
}
private static void copyAllFile(File file1, File file2) throws IOException {
//D: + CSDN材料
File parent = new File(file2, file1.getName());
//创建 D:\\CSDN材料
parent.mkdirs();
File[] files = file1.listFiles();
for (File file : files) {
if (file.isFile()){
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
//如果是文件需要得到关联地址 D:\\CSDN材料 + 文件名
File newf = new File(parent, file.getName());
FileOutputStream fos = new FileOutputStream(newf);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//复制文件
int b;
while ((b = bis.read())!=-1){
bos.write(b);
}
bos.close();
bis.close();
}else {
//如果遇到文件夹,相当于又是一次复制一个文件夹
copyAllFile(file,parent);
}
}
}
}
如有错误欢迎留言评论,及时更正。 2021年六月七日 羽露风