package testfile;
/**
* @author:
* @version:2018年7月16日 上午11:58:26
* description:
*/
import java.io.IOException;
import java.util.ArrayList;
/**
* <pre>
* 文件操作工具实现类：
* 1.复制单个文件
* 2.复制文件夹(包括里边的文件)
* 3.删除单个文件
* 4.删除文件夹(包括里边的文件)
* 5.重名单个文件
* 6.重命名文件夹中相同类型的文件格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg
* 7.剪切单个文件到指定文件夹
* 8.剪切文件夹到指定文件夹(包含里边的文件)
* 9.指定文件夹下指定类型文件统计数量(包含里边文件夹下的符合条件文件)，并返回每个符合条件的文件的绝对路径字符串ArrayList
* 10.指定目录下查找符合条件的文件，并返回包含符合条件的文件绝对路径字符串ArrayList
* 11.读取文件的内容
* 12.判断文件的编码格式 发现处理不了 doc的编码格式 。
* </pre>
*
*/
public interface FilesOperationInterface {
/**
* 1.复制单个文件 <br>
* 2.复制文件夹(包括里边的文件)
*
* @param sorFile
* 需要复制的文件或文件夹绝对路径
* @param toFile
* 目标文件夹绝对路径
* @return <br>
* boolean true 复制成功 false 复制失败
*/
public abstract boolean copyFils(String sorFile, String toFile,String rename)
throws IOException;
/**
* 3.删除单个文件 <br>
* 4.删除文件夹(包括里边的文件)
*
* @param delFile
* 需要删除的文件绝对路径或文件夹绝对路径
* @return <br>
* boolean true 删除成功 false 删除失败
*/
public abstract boolean deleteFiles(String delFile) throws IOException;
/**
* 5.重名单个文件
*
* @param oldFile
* 需要重命名的文件绝对路径
* @param newName
* 新的文件名
* @return <br>
* boolean true 重命名成功 false 重命名失败
*/
public abstract boolean renameFile(String oldFile, String newName)
throws IOException;
/**
* 6.重命名文件夹中相同类型的文件格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg
*
* @param files
* 文件所在的文件夹绝对路径
* @param type
* 指定类型的文件
* @param name
* 指定文件名的前一部分
* @return <br>
* boolean true 重命名成功 false 重命名失败
*/
public abstract boolean renameFile(String files, String type, String name)
throws IOException;
/**
* 7.剪切单个文件到指定文件夹 <br>
* 8.剪切文件夹到指定文件夹(包含里边的文件)
*
* @param file
* 需要剪切的文件或文件夹所在绝对路径
* @param toFiles
* 剪切到的文件夹绝对路径
* @return <br>
* boolean true 剪切成功 false 剪切失败
*/
public abstract boolean clipFile(String file, String toFiles)
throws IOException;
/**
* 9.指定文件夹下指定类型文件统计数量(包含里边文件夹下的符合条件文件)，并返回每个符合条件的文件的绝对路径字符串ArrayList
*
* @param findFiles
* 查找的目录绝对路径
* @param type
* 查找的文件类型 格式：.jpg、.exe(不区分大小写)
* @return <br>
* ArrayList<String> 返回所有符合条件的文件绝对路径的字符串ArrayList<br>
* 注意：返回值ArrayList<String>对象的xX.get(0)是统计的数量，即就是第一个存储的是统计结果
*/
public abstract ArrayList<String> findFileType(String findFiles, String type)
throws IOException;
/**
* 10.指定目录下查找符合条件的文件，并返回包含符合条件的文件绝对路径字符串ArrayList
*
* @param findFiles
* 查找的目录绝对路径
* @param file
* 查找的文件名，可以是一部分也可以全名
* @return <br>
* ArrayList<String> <br>
* 返回所有符合条件的文件绝对路径的字符串ArrayList
*/
public abstract ArrayList<String> findFile(String findFiles, String file)
throws IOException;
public String readFile(String desFile) throws IOException；
public static String getFileEncode(String path)；
private static String getEncode(int flag1, int flag2, int flag3);
}
package testfile;
/**
* @author:
* @version:2018年7月16日 上午11:59:16
* description:
*/
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import org.apache.commons.lang.StringUtils;
/**
* <pre>
* 文件操作工具实现类：
* 1.复制单个文件
* 2.复制文件夹(包括里边的文件)
* 3.删除单个文件
* 4.删除文件夹(包括里边的文件)
* 5.重名单个文件
* 6.重命名文件夹中相同类型的文件格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg
* 7.剪切单个文件到指定文件夹
* 8.剪切文件夹到指定文件夹(包含里边的文件)
* 9.指定文件夹下指定类型文件统计数量(包含里边文件夹下的符合条件文件)，并返回每个符合条件的文件的绝对路径字符串ArrayList
* 10.指定目录下查找符合条件的文件，并返回包含符合条件的文件绝对路径字符串ArrayList
* 11.read file
* 12.获取 文件编码
* </pre>
*
*/
public class FilesOperationTools implements FilesOperationInterface {
// 创建ArrayList对象保存数量及查找到的路径
private static ArrayList<String> list = null;
// 创建intb变量保存查找数量
private int sum = 0;
public FilesOperationTools() {
super();
list = new ArrayList<>();
list.add(0, "-1");
}
//复制文件到指定的路径下
@Override
public boolean copyFils(String sorFile, String toFile,String rename ) throws IOException {
// 定义返回值变量
boolean flag = false;
// 封装字符路径为File对象
File sorfile = new File(sorFile);
File tofile = new File(toFile);
// 声明字节流
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
System.out.println("isFile:"+sorfile.isFile()+","+sorfile.getName());
System.out.println("toFile:isFile:"+tofile.isFile()+","+tofile.getName());
System.out.println("toFile:isDirectory:"+tofile.isDirectory()+","+tofile.getName()+","+tofile.getAbsolutePath());
if (sorfile.isFile()) {
// 创建FileInputStream字节流读取文件对象
fileInputStream = new FileInputStream(sorfile);
String sorname=rename;
if(StringUtils.isEmpty(rename)) sorname=sorfile.getName();
// 创建FileOutputStream字节流写入文件对象
File temp = new File(tofile.getAbsolutePath()
.concat(File.separator).concat(sorname));
if(tofile.isDirectory()&& !tofile.exists()){
tofile.mkdirs();
}
//如果文件夹 不错在就创建
if(!temp.getParentFile().exists()){
temp.getParentFile().mkdirs();
System.out.println("absolute:"+tofile.getAbsolutePath());
}
fileOutputStream = new FileOutputStream(temp);
// 定义字节数组变量，每次都读进字节数组
byte[] by = new byte[1024 * 1000 * 2];
// 定义每次真实读取到的字节长度变量
int len = 0;
// 循环复制文件
while ((len = fileInputStream.read(by)) != -1) {
fileOutputStream.write(by, 0, len);
}
// 关闭流
fileInputStream.close();
fileOutputStream.close();
// 如果源文件长度等于复制后的文件长度，则设置返回变量 true
return true;
} else {
// 获取源文件夹下的所有文件包含文件夹的File列表
File[] files = sorfile.listFiles();
// 判断是否获取到的List对象为null,null说明是特殊文件或没权限访问
if (files != null) {
// 拼接新的文件夹路径并创建
File temp = new File(tofile.getAbsolutePath()
.concat(File.separator).concat(sorfile.getName()));
temp.mkdirs();
// 循环调用方法本身
for (File file : files) {
flag = copyFils(file.getAbsolutePath(),
temp.getAbsolutePath(),"");
}
} else {
System.out.println("文件夹下有特殊文件夹！可能是隐藏的垃圾桶文件。 "
+ sorfile.getAbsolutePath());
}
}
return flag;
}
@Override
public boolean deleteFiles(String delFile) throws IOException {
System.out.println("delFile:"+delFile);
// 定义返回值标志
boolean flag = false;
// 封装字符串路径为File对象
File delfile = new File(delFile);
System.out.println(delfile.getName()+","+delfile.isFile()+","+delfile.isDirectory());
// 判断是否为文件，若是则直接删除
if (!delfile.isDirectory()) {
return delfile.delete();
} else {
// 不是文件，则获取当前文件夹下所有文件组成的File对象
File[] files = delfile.listFiles();
// 判断是否null,null则是特殊文件夹
if (files != null) {
// 循环调用方法自己
for (File file : files) {
flag = deleteFiles(file.getAbsolutePath());
}
// 当前文件夹下的文件删完后，删除当前文件夹
delfile.delete();
} else {
System.out.println("文件夹下有特殊文件夹！可能是隐藏的垃圾桶文件，不能删除！ "
+ delfile.getAbsolutePath());
}
}
return flag;
}
@Override
public boolean renameFile(String oldFile, String newName)
throws IOException {
// 定义返回值标志
boolean flag = false;
// 封装字符创路径为File对象
File oldfile = new File(oldFile);
File newfile = new File(oldfile.getParent().concat(File.separator)
.concat(newName));
if (oldfile.isFile()) {
System.out.println("oldfile:");
flag = oldfile.renameTo(newfile);
} else {
System.out.println("指定的文件绝对路径有误！ " + oldFile);
}
return flag;
}
@Override
public boolean renameFile(String files, String type, String name)
throws IOException {
// 返回值标志
boolean flag = false;
// 传进来的类型文件名变量转为常量，不然之后的匿名问价过滤内部类不能使用
final String typ = type.contains(".") ? type : ".".concat(type);
// 封装路径为File对象
File file = new File(files);
// 获取文件夹下所有符合条件的文件数组
File[] fil = file.listFiles(new FileFilter() {
@Override
public boolean accept(File path) {
return path.isFile()
&& path.getName().toLowerCase()
.endsWith((typ.toLowerCase()));
}
});
int i = 1;
for (File fi : fil) {
flag = fi.renameTo(new File(fi.getParent().concat(File.separator)
.concat(name).concat("_")
+ (i++) + typ));
}
return flag;
}
@Override
public boolean clipFile(String file, String toFiles) throws IOException {
boolean flag = false;
// 封装目录
File sfile = new File(file);
File tofile = new File(toFiles);
System.out.println("sfile.isFile():"+sfile.isFile());
// 判断需要剪切的是否单个文件
if (sfile.isFile()) {
flag = sfile.renameTo(new File(toFiles.concat(File.separator)
.concat(sfile.getName())));
} else {
// 调用本类中的复制文件方法
flag = copyFils(sfile.getAbsolutePath(), tofile.getAbsolutePath(),"");
System.out.println("flag:"+flag);
if (flag) {
// 文件夹复制完成后，删除原文件夹
flag = deleteFiles(sfile.getAbsolutePath());
}
}
return flag;
}
@Override
public ArrayList<String> findFileType(String findFiles, String type)
throws IOException {
// 类型type字符串转为常量，便于匿名内部类使用
final String typ = type.contains(".") ? type : ".".concat(type);
// 封装查找的目录为File对象
File findfiles = new File(findFiles);
// 获取当前目录下File数组
File[] findfile = findfiles.listFiles();
if (findfiles != null) {
for (File find : findfile) {
if (find.isDirectory()) {
findFileType(find.getAbsolutePath(), typ);
} else {
if (find.getName().toLowerCase()
.endsWith(typ.toLowerCase())) {
list.add(find.getAbsolutePath());
sum++;
}
}
}
}
list.set(0, String.valueOf(sum));
return list;
}
@Override
public ArrayList<String> findFile(String findFiles, String file)
throws IOException {
// 封装路径
File findfiles = new File(findFiles);
// 判断是否查找指定类型的
if ("*.".equals(file.substring(0, 2))) {
// 调用上边查找指定类型的方法
findFileType(findFiles, file.substring(1));
} else {
// 调用分离出去的方法
getFile(findfiles, file);
}
// 移除索引是0的元素
list.remove(0);
return list;
}
// findFile(String findFiles, String file)方法，当查找的是包含某个字符串是，分离便于递归调用<br>
private void getFile(File findFiles, String file) {
File[] files = findFiles.listFiles();
if (files != null) {
for (File f : files) {
if (f.isFile()
&& f.getName().toLowerCase()
.contains(file.toLowerCase())) {
list.add(f.getAbsolutePath());
} else {
if (f.getName().toLowerCase().contains(file.toLowerCase())) {
list.add(f.getAbsolutePath());
}
getFile(f, file);
}
}
}
}
public String readFile(String desFile) throws IOException{
//第一步：定义文件路径
File file = new File(desFile); // 定义文件路径
String context="";
if (file.exists()) { // 文件存在则可以读取
//第二步：实例化输入流
InputStream input = new FileInputStream(file);
//第三步：读取数据到字节数组
byte data[] = new byte[1024]; // 假设要读的长度是1024
int len = input.read(data); // 读取数据，返回读取个数
//第四步：关闭资源
input.close();
context=new String(data, 0, len);
System.out.println("读取的数据是：【" + context+ "】");
}
return context;
}
public static String getFileEncode(String path) {
String charset ="asci";
byte[] first3Bytes = new byte[3];
BufferedInputStream bis = null;
try {
boolean checked = false;
bis = new BufferedInputStream(new FileInputStream(path));
bis.mark(0);
int read = bis.read(first3Bytes, 0, 3);
if (read == -1)
return charset;
if (first3Bytes[0] == (byte) 0xFF && first3Bytes[1] == (byte) 0xFE) {
charset = "Unicode";//UTF-16LE
checked = true;
} else if (first3Bytes[0] == (byte) 0xFE && first3Bytes[1] == (byte) 0xFF) {
charset = "Unicode";//UTF-16BE
checked = true;
} else if (first3Bytes[0] == (byte) 0xEF && first3Bytes[1] == (byte) 0xBB && first3Bytes[2] == (byte) 0xBF) {
charset = "UTF8";
checked = true;
}
bis.reset();
if (!checked) {
int len = 0;
int loc = 0;
while ((read = bis.read()) != -1) {
loc++;
if (read >= 0xF0)
break;
if (0x80 <= read && read <= 0xBF) //单独出现BF以下的，也算是GBK
break;
if (0xC0 <= read && read <= 0xDF) {
read = bis.read();
if (0x80 <= read && read <= 0xBF)
//双字节 (0xC0 - 0xDF) (0x80 - 0xBF),也可能在GB编码内
continue;
else
break;
} else if (0xE0 <= read && read <= 0xEF) { //也有可能出错，但是几率较小
read = bis.read();
if (0x80 <= read && read <= 0xBF) {
read = bis.read();
if (0x80 <= read && read <= 0xBF) {
charset = "UTF-8";
break;
} else
break;
} else
break;
}
}
//TextLogger.getLogger().info(loc + " " + Integer.toHexString(read));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bis != null) {
try {
bis.close();
} catch (IOException ex) {
}
}
}
return charset;
}
private static String getEncode(int flag1, int flag2, int flag3) {
String encode="";
// txt文件的开头会多出几个字节，分别是FF、FE（Unicode）,
// FE、FF（Unicode big endian）,EF、BB、BF（UTF-8）
if (flag1 == 255 && flag2 == 254) {
encode="Unicode";
}
else if (flag1 == 254 && flag2 == 255) {
encode="UTF-16";
}
else if (flag1 == 239 && flag2 == 187 && flag3 == 191) {
encode="UTF8";
}
else {
encode="asci";// ASCII码
}
return encode;
}
}
test案例
package testfile;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import org.junit.Test;
/**
* @author:
* @version:2018年7月16日 上午11:56:54
* description:
*/
public class TestFile {
/**
* FilesOperationTools 测试类
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File file=new File("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx");
System.out.println(file.getParent());
// 创建FilesOperationTools对象
FilesOperationTools fileOperation = new FilesOperationTools();
boolean f = false;
System.out.println("codeType:"+fileOperation.getFileEncode("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx"));
String result=fileOperation.readFile("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx");
System.out.println("result:"+new String(result.getBytes("GBK"),"UTF-8"));
System.out.println("codeType:"+fileOperation.getFileEncode("C:\\Users\\Administrator\\Desktop\\报文.txt"));
String resultTXT=fileOperation.readFile("C:\\Users\\Administrator\\Desktop\\报文.txt");
System.out.println(resultTXT);
// 测试查找指定类型文件
ArrayList<String> lis = fileOperation.findFile("D:\\temp", "*.mp3");
// 测试查找包含指定字符的文件
// ArrayList<String> lis = fileOperation.findFile("D:\\temp", "mp3");
System.out.println(lis);
}
@Test
public void testcopy() throws IOException{
// 创建FilesOperationTools对象
FilesOperationTools fileOperation = new FilesOperationTools();
boolean f = false;
// 测试复制单个文件
f = fileOperation.copyFils( "C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx", "C:\\Users\\Administrator\\Desktop\\","ELK入门及集群搭建快速实践1(修改1).docx");
f = fileOperation.copyFils("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx", "E:\\temp","");
// 测试复制文件夹包含所有文件
f = fileOperation.copyFils("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx", "D:\\temp\\file","a.docx");
if (f) {
System.out.println("复制完成！\n");
}
}
@Test
public void testdelete() throws IOException{
// 创建FilesOperationTools对象
FilesOperationTools fileOperation = new FilesOperationTools();
boolean f = false;
// 测试删除单个文件
f = fileOperation.deleteFiles("E:\\temp\\");
// 测试删除文件
f = fileOperation.deleteFiles("D:\\temp\\file\\");
if (f) {
System.out.println("删除完成！");
}
}
//在Windows上试了几次都失败了
@Test
public void testrename() throws IOException{
// 创建FilesOperationTools对象
FilesOperationTools fileOperation = new FilesOperationTools();
boolean f = false;
// 测试重命名单个文件
f = fileOperation.renameFile("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx", "ELK入门及集群搭建快速实践(修改1).docx");
if (f) {
System.out.println("重命名完毕！");
}
// 测试重命名同种类型的文件
f = fileOperation.renameFile("D:\\temp", "Mp3", "");
if (f) {
System.out.println("多个文件重命名完成！");
}
}
@Test
public void findFileByType() throws IOException{
// 创建FilesOperationTools对象
FilesOperationTools fileOperation = new FilesOperationTools();
boolean f = false;
// 测试查找指定类型的文件
ArrayList<String> list = fileOperation.findFileType("D:\\temp", "Mp3");
System.out.println("mp3数量：" + list.get(0));
for (int i = 1; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
@Test
public void testClipFile() throws IOException{
// 创建FilesOperationTools对象
FilesOperationTools fileOperation = new FilesOperationTools();
boolean f = false;
// 测试剪切单个文件 单个测试失败
f = fileOperation.clipFile("C:\\Users\\Administrator\\Desktop\\ELK入门及集群搭建快速实践(修改).docx", "D:\\temp");
System.out.println(f);
// 测试剪切整个文件夹
f = fileOperation.clipFile("D:\\temp\\file",
"C:\\Users\\Administrator\\Desktop\\联泰基金开户测试\\");
if (f) {
System.out.println("剪切成功！");
}
}
}