文件

1. 文件的一些常用方法

package com.ljw.study;

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

public class FileDemo {

public static void main(String[] args) {
// 构造文件对象
// 绝对路径，构造文件夹对象
File f1 = new File("d:/work/code/ljw/Test");
System.out.println(f1.exists()); // 文件是否存在

// 相对路径,如果是eclipse的话，就是相对于项目目录
File f2 = new File("employee.ser");
System.out.println("f2的绝对路径：" + f2.getAbsolutePath());
System.out.println(f2.exists());

// 以f1为父目录创建文件对象
File f3 = new File(f1,"LOL.exe");
System.out.println("f3的绝对路径：" + f3.getAbsolutePath());

System.out.println(f2.isDirectory()); // 是否是文件夹

System.out.println(f2.isFile()); // 是否为文件(非文件夹)

System.out.println(f2.length()); // 文件长度

System.out.println(new Date(f2.lastModified())); // 最后的修改时间

//		System.out.println(f2.renameTo(new File("employee.ser")));// 文件重命名

System.out.println(Arrays.toString(f1.list())); // 以字符串数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）

System.out.println(Arrays.toString(f1.listFiles())); // 以文件数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）

// 以字符串形式返回获取所在文件夹
System.out.println(f1.getParent());

// 以文件形式返回获取所在文件夹
f2.getParentFile();
// 创建文件夹，如果父文件夹skin不存在，创建就无效
f1.mkdir();

// 创建文件夹，如果父文件夹skin不存在，就会创建父文件夹
f1.mkdirs();

// 创建一个空文件,如果父文件夹skin不存在，就会抛出异常
f1.createNewFile();
// 所以创建一个空文件之前，通常都会创建父目录
f1.getParentFile().mkdirs();

// 列出所有的盘符c: d: e: 等等
f1.listRoots();

// 刪除文件
f.delete();

// JVM结束的时候，刪除文件，常用于临时文件的删除
f.deleteOnExit()
}
}

2. 读取和写入文件数据

2.1 以字节流方式

2.1.1 读取数据

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

public class TestStream {

public static void main(String[] args) {
try {
//准备文件lol.txt其中的内容是AB，对应的ASCII分别是65 66
File f =new File("d:/lol.txt");
//创建基于文件的输入流
FileInputStream fis =new FileInputStream(f);
//创建字节数组，其长度就是文件的长度
byte[] all =new byte[(int) f.length()];
//以字节流的形式读取文件所有内容
fis.read(all);
for (byte b : all) {
//打印出来是65 66
System.out.println(b);
}

//每次使用完流，都应该进行关闭
fis.close();

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2.1.2 写入数据

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
File f = new File("d:/xyz/abc/def/lol2.txt");
f.getParentFile().mkdirs();

try {
FileOutputStream outputFile = new FileOutputStream(f);
String s = "秋天，多了一些思念";
byte[] b = s.getBytes(); // 将字符串转换为字节数组byte[]
outputFile.write(b);
outputFile.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

2.2 以字符流方式

2.2.1 读取数据

package com.ljw.practice;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) {
File f = new File("d:/lol.txt");

try(FileReader fr = new FileReader(f)){ // 数据流写在try()里面，系统会帮我们自动关闭数据流
char[] c = new char[(int) f.length()];
fr.read(c);
for(char i:c) {
System.out.print(i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2.2.2 写入数据

package com.ljw.practice;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) {
File f = new File("d:/lol.txt");
File f2 = new File("d:/lol2.txt");

try(FileReader fr = new FileReader(f);FileWriter fw = new FileWriter(f2)){
char[] c = new char[(int) f.length()];
fr.read(c); // 读出数据到字符数组
fw.write(c); // 写入数据从数组到文件
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2.3 以缓存流方式

• 缓存流必须建立在一个存在的流的基础上
• 以介质是硬盘为例，字节流和字符流的弊端：在每一次读写的时候，都会访问硬盘。 如果读写的频率比较高的时候，其性能表现不佳。
• 为了解决以上弊端，采用缓存流。缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。
• 如果需要立即将缓存中的数据写入硬盘，可以使用flush()方法

2.3.1 读取数据

package stream;

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

public class TestStream {
public static void main(String[] args) {
File f = new File("d:/lol.txt");
// 创建文件字符流
// 缓存流必须建立在一个存在的流的基础上
try (
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
)
{
while (true) {
// 一次读一行
String line = br.readLine();
if (null == line)
break;
System.out.println(line);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

2.3.2 写入数据

package com.ljw.practice;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class FileDemo {

public static void main(String[] args) {
File f = new File("d:/lol2.txt");

try (
// 创建文件字符流
FileWriter fw = new FileWriter(f);
// 缓存流必须建立在一个存在的流的基础上
PrintWriter pw = new PrintWriter(fw);
) {
pw.println("garen kill teemo");
pw.println("teemo revive after 1 minutes");
pw.println("teemo try to garen, but killed again");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2.4 以数据流方式

• 使用数据流的writeUTF()和readUTF() 可以进行数据的格式化顺序读写
• 要用DataInputStream 读取一个文件，这个文件必须是由DataOutputStream 写出的，否则会出现EOFException，因为DataOutputStream 在写出的时候会做一些特殊标记，只有DataInputStream 才能成功的读取。

2.4.1 实例

• 以数据流的方式读写数据

package com.ljw.practice;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) {
write();
read();
}

private static void read() {
File f = new File("d:/lol2.txt");
try(
FileInputStream fi = new FileInputStream(f);
DataInputStream di = new DataInputStream(fi); // 创建一个数据流对象
)
{
boolean b = di.readBoolean();
int i = di.readInt();
String s = di.readUTF();
System.out.println(b);
System.out.println(i);
System.out.println(s);

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}

}

private static void write() {
File f = new File("d:/lol2.txt");

try(
FileOutputStream fo = new FileOutputStream(f);
DataOutputStream dos = new DataOutputStream(fo);
)
{
dos.writeBoolean(false);
dos.writeInt(200);
dos.writeUTF("中国");

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

2.5 以对象流(序列化对象)

• 把一个对象序列化有一个前提是：这个对象的类，必须实现了Serializable接口

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import charactor.Hero;

public class TestStream {

public static void main(String[] args) {
//创建一个Hero garen
//要把Hero对象直接保存在文件上，务必让Hero类实现Serializable接口
Hero h = new Hero();
h.name = "garen";
h.hp = 616;

//准备一个文件用于保存该对象
File f =new File("d:/garen.lol");

try(
//创建对象输出流
FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream oos =new ObjectOutputStream(fos);
//创建对象输入流
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois =new ObjectInputStream(fis);
) {
oos.writeObject(h);
Hero h2 = (Hero) ois.readObject();
System.out.println(h2.name);
System.out.println(h2.hp);

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

3. 拆分文件 和 合并文件

3.1 拆分文件

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
File file = new File("d:/F.docx");

try {
FileInputStream inFile = new FileInputStream(file);
int i = 1;
while(true) {
byte[] b = new byte[1024*100];
int n = inFile.read(b);
if(n==-1) {  // 没有读到数据返回 -1
break;
}
File f1 = new File(String.format("d:/F-%d.docx",i)); // 占位符
FileOutputStream outFile = new FileOutputStream(f1);
outFile.write(b);
i++;
}

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

3.2 合并文件

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
File newF = new File("d:/newF.docx");
try {
FileOutputStream outNewF = new FileOutputStream(newF);
for(int i=1;i<5;i++) {
File f = new File(String.format("d:/F-%d.docx", i));
byte[] b = new byte[(int) f.length()];
FileInputStream inf = new FileInputStream(f);
inf.read(b);
outNewF.write(b);
inf.close();
}
outNewF.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

4. 中文问题

package com.ljw.practice;

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

public class FileDemo {

public static void main(String[] args) {
File f = new File("d:/lol.txt");
try (FileInputStream fis = new FileInputStream(f);) {
byte[] all = new byte[(int) f.length()];
fis.read(all);

//文件中读出来的数据是
System.out.println("文件中读出来的数据是：");
for (byte b : all)
{
int i = b&0xff;  //只取16进制的后两位
System.out.println(Integer.toHexString(i));
}
System.out.println("把这个数字，放在GBK的棋盘上去：");
String str = new String(all,"GBK");
System.out.println(str);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

综合练习

• 复制文件或文件夹
• 查找指定的内容

package com.ljw.practice;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

public class FilePractice {

public static void main(String[] args) {
//----------复制文件--------------
File srcFile = new File("d:/lol.txt");
File destFile = new File("d:/lol3.txt");
copyFile(srcFile,destFile);

//----------复制文件夹------------
File srcFolder = new File("d:/xyz");
File destFolder = new File("d:/xyz-副本");
copyFolder(srcFolder,destFolder);

//----------查找---------------
String s = "hello";
findFileContent(s, srcFolder);

}

/**
* 复制文件
* @param srcFile：源文件
* @param destFile：目标文件
* @return void
*/
public static void copyFile(File srcFile, File destFile) {
if(srcFile.exists()) {
try(
// 创建读取文件流对象
FileInputStream fi = new FileInputStream(srcFile);
// 创建写入文件流对象
FileOutputStream fo = new FileOutputStream(destFile);

)
{
byte[] b = new byte[10];
int i;
while(true) {
i = fi.read(b);
if(-1==i) {
break;
}
fo.write(b,0,i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
System.out.println("文件不存在");
}
}

/**
* 复制文件夹
* @param srcFile
* @param destFile
*/
public static void copyFolder(File srcFile, File destFile) {
if(srcFile.isDirectory()) {
File[] files = srcFile.listFiles();
destFile.mkdir();
for(File f:files) {
if(f.isDirectory()) {
String newFolderPath = destFile.getAbsolutePath()+"\\"+f.getName();
File newFolder = new File(newFolderPath);
newFolder.mkdir();
System.out.println("新文件夹的位置是："+newFolderPath);
copyFolder(f,newFolder);
}else {
String newFilePath = destFile.getAbsolutePath()+"\\"+f.getName();
System.out.println("新文件的位置是："+newFilePath);
File newF = new File(newFilePath);
copyFile(f,newF);
}
}
}else {
copyFile(srcFile, destFile);
}
}

/**
* 查找指定的文件内容
* @param s：要查找的字符串
* @param file：要查找的文件对象
*/
public static void findFileContent(String s,File file) {
if(file.isDirectory()) {
File[] files = file.listFiles();
for(File f:files) {
findFileContent(s,f);
}
}else {
try(
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
) {

while(true) {
String str = br.readLine();
if(null == str) {break;}
if(str.contains(s)) {
System.out.println("找到目标字符串"+s+",在文件："+file.getAbsolutePath());
break;
}
}

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
}