冷炳腾
- 浏览: 298619 次
- 性别:
- 来自: 广州
-
文章分类
最新评论
-
M大米饭：
19774279 写道xj1990129 写道PackageF ...
Eclipse插件开发之获得当前项目 -
zhongmin2012：
AST抽象的java语法树 -
wd3389：
好可惜，你写的文章很有帮助，谢谢！
关于博客更新 -
zxjlwt：
http://surenpi.com/2015/07/13/e ...
eclipse扩展点清单 -
zxjlwt：
学习了。http://surenpi.com
Console 控制台扩展（一）
package com.myclover.utils.file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
/**
* <pre>
* 功能描述：文件操作工具类
* 实现文件的创建、删除、复制、压缩、解压以及目录的创建、删除、复制、压缩解压等功能
* </pre>
* @author 方方 <p>
* Blog: http://myclover.iteye.com <p>
* 日 期： 2010-07-26 <p>
* @version 0.1 <p>
* {@code com.myclover.utils.file.FileOperateUtils.java}
*
*/
public class FileOperateUtils {
/**
*
* 功能描述：复制单个文件，如果目标文件存在，则不覆盖
* @param srcFileName 待复制的文件名
* @param descFileName 目标文件名
* @return 返回：
* 如果复制成功，则返回true，否则返回false
*/
public static boolean copyFile(String srcFileName , String descFileName)
{
return FileOperateUtils.copyFileCover(srcFileName, descFileName, false);
}
/**
*
* 功能描述：复制单个文件
* @param srcFileName 待复制的文件名
* @param descFileName 目标文件名
* @param coverlay 如果目标文件已存在，是否覆盖
* @return 返回：
* 如果复制成功，则返回true，否则返回false
*/
public static boolean copyFileCover(String srcFileName , String descFileName , boolean coverlay)
{
File srcFile = new File(srcFileName);
//判断源文件是否存在
if(!srcFile.exists())
{
System.out.println("复制文件失败，源文件" + srcFileName + "不存在!");
return false;
}
//判断源文件是否是合法的文件
else if(!srcFile.isFile())
{
System.out.println("复制文件失败，" + srcFileName + "不是一个文件!");
return false;
}
File descFile = new File(descFileName);
//判断目标文件是否存在
if(descFile.exists())
{
//如果目标文件存在，并且允许覆盖
if(coverlay)
{
System.out.println("目标文件已存在，准备删除!");
if(!FileOperateUtils.delFile(descFileName))
{
System.out.println("删除目标文件" + descFileName + "失败!");
return false;
}
}
else
{
System.out.println("复制文件失败，目标文件" + descFileName + "已存在!");
return false;
}
}
else
{
if(!descFile.getParentFile().exists())
{
//如果目标文件所在的目录不存在，则创建目录
System.out.println("目标文件所在的目录不存在，创建目录!");
//创建目标文件所在的目录
if(!descFile.getParentFile().mkdirs())
{
System.out.println("创建目标文件所在的目录失败!");
return false;
}
}
}
//准备复制文件
//读取的位数
int readByte = 0;
InputStream ins = null;
OutputStream outs = null;
try
{
//打开源文件
ins = new FileInputStream(srcFile);
//打开目标文件的输出流
outs = new FileOutputStream(descFile);
byte[] buf = new byte[1024];
//一次读取1024个字节，当readByte为-1时表示文件已经读取完毕
while((readByte = ins.read(buf)) != -1)
{
//将读取的字节流写入到输出流
outs.write(buf, 0, readByte);
}
System.out.println("复制单个文件" + srcFileName + "到" + descFileName + "成功!");
return true;
}
catch(Exception e)
{
System.out.println("复制文件失败：" + e.getMessage());
return false;
}
finally
{
//关闭输入输出流，首先关闭输出流，然后再关闭输入流
if(outs != null)
{
try
{
outs.close();
}
catch(IOException oute)
{
oute.printStackTrace();
}
}
if(ins != null)
{
try
{
ins.close();
}
catch(IOException ine)
{
ine.printStackTrace();
}
}
}
}
/**
*
* 功能描述：复制整个目录的内容，如果目标目录存在，则不覆盖
* @param srcDirName 源目录名
* @param descDirName 目标目录名
* @return 返回：
* 如果复制成功返回true，否则返回false
*/
public static boolean copyDirectory(String srcDirName , String descDirName)
{
return FileOperateUtils.copyDirectoryCover(srcDirName, descDirName, false);
}
/**
*
* 功能描述：复制整个目录的内容
* @param srcDirName 源目录名
* @param descDirName 目标目录名
* @param coverlay 如果目标目录存在，是否覆盖
* @return 返回：
* 如果复制成功返回true，否则返回false
*/
public static boolean copyDirectoryCover(String srcDirName , String descDirName , boolean coverlay)
{
File srcDir = new File(srcDirName);
//判断源目录是否存在
if(!srcDir.exists())
{
System.out.println("复制目录失败，源目录" + srcDirName + "不存在!");
return false;
}
//判断源目录是否是目录
else if(!srcDir.isDirectory())
{
System.out.println("复制目录失败，" + srcDirName + "不是一个目录!");
return false;
}
//如果目标文件夹名不以文件分隔符结尾，自动添加文件分隔符
if(!descDirName.endsWith(File.separator))
{
descDirName = descDirName + File.separator;
}
File descDir = new File(descDirName);
//如果目标文件夹存在
if(descDir.exists())
{
if(coverlay)
{
//允许覆盖目标目录
System.out.println("目标目录已存在，准备删除!");
if(!FileOperateUtils.delFile(descDirName))
{
System.out.println("删除目录" + descDirName + "失败!");
return false;
}
}
else
{
System.out.println("目标目录复制失败，目标目录" + descDirName + "已存在!");
return false;
}
}
else
{
//创建目标目录
System.out.println("目标目录不存在，准备创建!");
if(!descDir.mkdirs())
{
System.out.println("创建目标目录失败!");
return false;
}
}
boolean flag = true;
//列出源目录下的所有文件名和子目录名
File[] files = srcDir.listFiles();
for(int i = 0 ; i < files.length ; i++)
{
//如果是一个单个文件，则直接复制
if(files[i].isFile())
{
flag = FileOperateUtils.copyFile(files[i].getAbsolutePath(), descDirName + files[i].getName());
//如果拷贝文件失败，则退出循环
if(!flag)
{
break;
}
}
//如果是子目录，则继续复制目录
if(files[i].isDirectory())
{
flag = FileOperateUtils.copyDirectory(files[i].getAbsolutePath(), descDirName + files[i].getName());
//如果拷贝目录失败，则退出循环
if(!flag)
{
break;
}
}
}
if(!flag)
{
System.out.println("复制目录" + srcDirName + "到" + descDirName + "失败!");
return false;
}
System.out.println("复制目录" + srcDirName + "到" + descDirName + "成功!");
return true;
}
/**
*
* 功能描述：删除文件，可以删除单个文件或文件夹
* @param fileName 被删除的文件名
* @return 返回：
* 如果删除成功，则返回true，否是返回false
*/
public static boolean delFile(String fileName)
{
File file = new File(fileName);
if(!file.exists())
{
System.out.println("删除文件失败，" + fileName + "文件不存在!");
return false;
}
else
{
if(file.isFile())
{
return FileOperateUtils.deleteFile(fileName);
}
else
{
return FileOperateUtils.deleteDirectory(fileName);
}
}
}
/**
*
* 功能描述：删除单个文件
* @param fileName 被删除的文件名
* @return 返回：
* 如果删除成功，则返回true，否则返回false
*/
public static boolean deleteFile(String fileName)
{
File file = new File(fileName);
if(file.exists() && file.isFile())
{
if(file.delete())
{
System.out.println("删除单个文件" + fileName + "成功!");
return true;
}
else
{
System.out.println("删除单个文件" + fileName + "失败!");
return false;
}
}
else
{
System.out.println("删除单个文件失败，" + fileName + "文件不存在!");
return false;
}
}
/**
*
* 功能描述：删除目录及目录下的文件
* @param dirName 被删除的目录所在的文件路径
* @return 返回：
* 如果目录删除成功，则返回true，否则返回false
*/
public static boolean deleteDirectory(String dirName)
{
if(!dirName.endsWith(File.separator))
{
dirName = dirName + File.separator;
}
File dirFile = new File(dirName);
if(!dirFile.exists() || !dirFile.isDirectory())
{
System.out.println("删除目录失败" + dirName + "目录不存在!");
return false;
}
boolean flag = true;
//列出全部文件及子目录
File[] files = dirFile.listFiles();
for(int i = 0 ; i < files.length ; i++)
{
//删除子文件
if(files[i].isFile())
{
flag = FileOperateUtils.deleteFile(files[i].getAbsolutePath());
//如果删除文件失败，则退出循环
if(!flag)
{
break;
}
}
//删除子目录
else if(files[i].isDirectory())
{
flag = FileOperateUtils.deleteDirectory(files[i].getAbsolutePath());
//如果删除子目录失败，则退出循环
if(!flag)
{
break;
}
}
}
if(!flag)
{
System.out.println("删除目录失败!");
return false;
}
//删除当前目录
if(dirFile.delete())
{
System.out.println("删除目录" + dirName + "成功!");
return true;
}
else
{
System.out.println("删除目录" + dirName + "失败!");
return false;
}
}
/**
*
* 功能描述：创建单个文件
* @param descFileName 文件名，包含路径
* @return 返回：
* 如果创建成功，则返回true，否则返回false
*/
public static boolean createFile(String descFileName)
{
File file = new File(descFileName);
if(file.exists())
{
System.out.println("文件" + descFileName + "已存在!");
return false;
}
if(descFileName.endsWith(File.separator))
{
System.out.println(descFileName + "为目录，不能创建目录!");
return false;
}
if(!file.getParentFile().exists())
{
//如果文件所在的目录不存在，则创建目录
if(!file.getParentFile().mkdirs())
{
System.out.println("创建文件所在的目录失败!");
return false;
}
}
//创建文件
try
{
if(file.createNewFile())
{
System.out.println(descFileName + "文件创建成功!");
return true;
}
else
{
System.out.println(descFileName + "文件创建失败!");
return false;
}
}
catch(Exception e)
{
e.printStackTrace();
System.out.println(descFileName + "文件创建失败!");
return false;
}
}
/**
*
* 功能描述：创建目录
* @param descDirName 目录名,包含路径
* @return 返回：
* 如果创建成功，则返回true，否则返回false
*/
public static boolean createDirectory(String descDirName)
{
if(!descDirName.endsWith(File.separator))
{
descDirName = descDirName + File.separator;
}
File descDir = new File(descDirName);
if(descDir.exists())
{
System.out.println("目录" + descDirName + "已存在!");
return false;
}
//创建目录
if(descDir.mkdirs())
{
System.out.println("目录" + descDirName + "创建成功!");
return true;
}
else
{
System.out.println("目录" + descDirName + "创建失败!");
return false;
}
}
/**
*
* 功能描述：压缩文件或目录
* @param srcDirName 压缩的根目录
* @param fileName 根目录下的待压缩的文件名或文件夹名，其中*或""表示跟目录下的全部文件
* @param descFileName 目标zip文件
*/
public static void zipFiles(String srcDirName , String fileName , String descFileName)
{
//判断目录是否存在
if(srcDirName == null)
{
System.out.println("文件压缩失败，目录" + srcDirName + "不存在!");
return ;
}
File fileDir = new File(srcDirName);
if(!fileDir.exists() || !fileDir.isDirectory())
{
System.out.println("文件压缩失败，目录" + srcDirName + "不存在!");
return ;
}
String dirPath = fileDir.getAbsolutePath();
File descFile = new File(descFileName);
try
{
ZipOutputStream zouts = new ZipOutputStream(new FileOutputStream(descFile));
if("*".equals(fileName) || "".equals(fileName))
{
FileOperateUtils.zipDirectoryToZipFile(dirPath, fileDir, zouts);
}
else
{
File file = new File(fileDir , fileName);
if(file.isFile())
{
FileOperateUtils.zipFilesToZipFile(dirPath, file, zouts);
}
else
{
FileOperateUtils.zipDirectoryToZipFile(dirPath, file, zouts);
}
}
zouts.close();
System.out.println(descFileName + "文件压缩成功!");
}
catch(Exception e)
{
System.out.println("文件压缩失败：" + e.getMessage());
e.printStackTrace();
}
}
/**
* 功能描述：解压缩ZIP文件，将ZIP文件里的内容解压到descFileName目录下
* @param zipFileName 需要解压的ZIP文件
* @param descFileName 目标文件
*/
public static void unZipFiles(String zipFileName , String descFileName)
{
if(!descFileName.endsWith(File.separator))
{
descFileName = descFileName + File.separator;
}
try
{
//根据ZIP文件创建ZipFile对象
ZipFile zipFile = new ZipFile(zipFileName);
ZipEntry entry = null;
String entryName = null;
String descFileDir = null;
byte[] buf = new byte[4096];
int readByte = 0;
//获取ZIP文件里所有的entry
Enumeration enums = zipFile.entries();
//遍历所有entry
while(enums.hasMoreElements())
{
entry = (ZipEntry)enums.nextElement();
//获得entry的名字
entryName = entry.getName();
descFileDir = descFileName + entryName;
if(entry.isDirectory())
{
//如果entry是一个目录，则创建目录
new File(descFileDir).mkdirs();
continue;
}
else
{
//如果entry是一个文件，则创建父目录
new File(descFileDir).getParentFile().mkdirs();
}
File file = new File(descFileDir);
//打开文件输出流
FileOutputStream fouts = new FileOutputStream(file);
//从ZipFile对象中打开entry的输入流
InputStream ins = zipFile.getInputStream(entry);
while((readByte = ins.read(buf)) != -1)
{
fouts.write(buf, 0, readByte);
}
fouts.close();
ins.close();
}
System.out.println("文件解压成功!");
}
catch(Exception e)
{
System.out.println("文件解压失败：" + e.getMessage());
}
}
/**
*
* 功能描述：将目录压缩到ZIP输出流
* @param dirPath 目录路径
* @param fileDir 文件信息
* @param zouts 输出流
*/
public static void zipDirectoryToZipFile(String dirPath , File fileDir , ZipOutputStream zouts)
{
if(fileDir.isDirectory())
{
File[] files = fileDir.listFiles();
//空的文件夹
if(files.length == 0)
{
//目录信息
ZipEntry entry = new ZipEntry(getEntryName(dirPath , fileDir));
try
{
zouts.putNextEntry(entry);
zouts.closeEntry();
}
catch(Exception e)
{
e.printStackTrace();
}
return ;
}
for(int i = 0 ; i < files.length ; i++)
{
if(files[i].isFile())
{
//如果是文件，则调用文件压缩方法
FileOperateUtils.zipFilesToZipFile(dirPath, files[i], zouts);
}
else
{
//如果是目录，则递归调用
FileOperateUtils.zipDirectoryToZipFile(dirPath, files[i], zouts);
}
}
}
}
/**
*
* 功能描述：将文件压缩到ZIP输出流
* @param dirPath 目录路径
* @param file 文件
* @param zouts 输出流
*/
public static void zipFilesToZipFile(String dirPath , File file , ZipOutputStream zouts)
{
FileInputStream fin = null;
ZipEntry entry = null;
//创建复制缓冲区
byte[] buf = new byte[4096];
int readByte = 0;
if(file.isFile())
{
try
{
//创建一个文件输入流
fin = new FileInputStream(file);
//创建一个ZipEntry
entry = new ZipEntry(getEntryName(dirPath , file));
//存储信息到压缩文件
zouts.putNextEntry(entry);
//复制字节到压缩文件
while((readByte = fin.read(buf)) != -1)
{
zouts.write(buf, 0, readByte);
}
zouts.closeEntry();
fin.close();
System.out.println("添加文件" + file.getAbsolutePath() + "到zip文件中!");
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
/**
*
* 功能描述：获取待压缩文件在ZIP文件中entry的名字，即相对于跟目录的相对路径名
* @param dirPath 目录名
* @param file entry文件名
* @return
*/
private static String getEntryName(String dirPath , File file)
{
if(!dirPath.endsWith(File.separator))
{
dirPath = dirPath + File.separator;
}
String filePath = file.getAbsolutePath();
// 对于目录，必须在entry名字后面加上"/"，表示它将以目录项存储
if(file.isDirectory())
{
filePath += "/";
}
int index = filePath.indexOf(dirPath);
return filePath.substring(index + dirPath.length());
}
}
分享到：
发表评论
相关推荐
java文件操作工具类是java中针对文件操作的一个工具类，可以方便的读取，下载，上传文件等操作，希望可以帮到大家。
文件工具类java操作文件工具类java操作文件工具类java操作文件工具类java操作文件工具类
根据提供的文件名，我们可以假设TIo.java是一个实现了上述功能的工具类。它可能包含如下代码片段： ```java public class TIo { public static void createFile(String filePath) throws IOException { // 实现...
此工具类只用于Java后端在操作Properties文件的时候写的工具类,方便properties文件的存取操作
# java实现对文件的各种操作的工具类 ## 可以实现的操作有: 1. 删除单个文件 2. 删除文件夹及文件夹下的文件 3. 使用文件流对单个文件进行复制 4. 复制整个文件夹内容(包含子文件夹中的所有内容) 5. ...
我们将讨论核心的Java API，如`java.util.zip`包中的类，并通过一个名为`CompressFileUtils`的工具类来展示如何实现文件的解压缩功能。 首先，`java.util.zip`包提供了几个关键类，用于处理各种压缩格式，如`...
java 文件操作工具类
一个非常好用的csv文件操作工具
每个程序员都应该有一套自己的工具类，这个工具类提供很全的java文件操作方法
总结起来，"java文件上传下载工具类"是Java Web开发中不可或缺的部分，它封装了与文件操作相关的复杂逻辑，使开发者能够更专注于业务逻辑。通过创建这样的工具类，可以提高代码的可复用性和可维护性，同时降低出错的...
此文档为java中操作File对象的一个通用工具类，包含了byte数组和File类的相互转换
[工具类] 文件操作工具类 .java.txt [工具类] 序列化保存为XML文件的工具类 .java.txt [工具类] 一个压缩工具类.java.txt [工具类] 用java编写简单UDP网络通信程序 .java.txt [工具类] 中文验证.jsp.txt [工具类] ...
[工具类] 文件操作工具类 .java.txt [工具类] 序列化保存为XML文件的工具类 .java.txt [工具类] 一个压缩工具类.java.txt [工具类] 用java编写简单UDP网络通信程序 .java.txt [工具类] 中文验证.jsp.txt [工具类] ...
自定义的文件操作工具类通常是根据项目需求定制的，可能会包含上述一种或多种特性。具体实现细节，如类的结构、方法设计、异常处理机制等，都会根据实际需求而有所不同。在使用这个工具类时，需要注意其文档说明，以...
文件操作工具类主要用于简化和标准化与文件交互的流程，包括但不限于文件的创建、读取、写入、追加、删除以及更复杂的IO操作。以下是对这些知识点的详细阐述： 一、文件创建 在编程中，我们通常会使用特定的API或...
集成创建文件,创建目录,删除单个文件,删除单个目录,删除文件夹里内容,复制文件,复制文件夹,剪切文件,剪切文件夹等操作方法. 特上传分享
下面我们将详细探讨Java中28个常用的工具类，主要涉及`IO`相关的开发工具。 1. **java.lang.Math**：这个类提供了许多基础数学函数，如求平方根、最大值、最小值、随机数生成等。 2. **java.util.Arrays**：用于...
文件操作工具类是Java开发中的重要组成部分，它通常包含了打开、关闭、读写文件，以及文件复制、移动、删除等操作。这类工具类使得开发者能够方便地处理文件系统中的各种任务。 HTTP文件的队列下载工具类则是网络...
Java操作工具类是Java开发中常见的一种代码组织方式，它集合了各种常用的功能函数，以提高代码复用性和开发效率。这些工具类通常包含了对字符串、数组、集合、日期时间等基本数据类型的操作，以及文件I/O、网络通信...
Java中的`File`类是Java I/O流体系中不可或缺的一部分，它是用来操作...结合`FileUtils`这样的辅助工具类，我们可以编写出更简洁、易维护的代码。在实际开发中，还应考虑异常处理和错误恢复策略，以确保程序的健壮性。