Java操作文件

package com.hansy.collectionInfo.test;

/*
* F.java
*
* Created on 2007年11月21日, 下午7:23
*在做一个项目时，发现需要大量的操作文件。
这些操作包括读取文件中的内容，写入文件内容，
复制文件，删除文件，更新文件，获取文件尺寸大小等。
这里指的文件不仅仅是真真的文件，还有可能是目录。
为此，本人专门写了一个只有静态方法的类用来处理这些事务。
感觉效率还可以，遂发布于此，供大家学习使用。
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

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;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URI;
import java.nio.channels.FileChannel;
import java.security.interfaces.DSAKey;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* 文件处理类（最终类），本类仅包含一系列的静态最终方法，不允许继承和修改这些方法
*
*/
public final class F {
/**
* Log4j日志对象
*/
private static final Log log=LogFactory.getLog("F");
/**
* 根据对象获取文件
* @param file 文件对象（可以是三种对象：File、String、URI）
* @return 返回文件对象
*/
private static final File getFile(Object file){
try{
File f=null;
if(file instanceof File){
f=(File) file;
}
else if(file instanceof String){
f=new File((String) file);
}
else if(file instanceof URI){
f=new File((URI) file);
}
else {
log.error("以\""+file+"\"无法构建文件对象");
}
return f;
}catch(Exception ex){
log.error("以\""+file+"\"构建文件对象时发生异常："+ex);
return null;
}
}
/**
* 无损复制文件方法
* @param f1 原始文件
* @param f2 目标文件
* @return 复制成功则返回真，否则返回假
*/
private static final boolean copyFile(File f1,File f2){
if(!f1.isFile()){
return false;
}
try {
FileChannel in=new FileInputStream(f1).getChannel();
FileChannel out=new FileOutputStream(f2).getChannel();
in.transferTo(0,in.size(),out);
System.out.println("已成功复制文件\""+f1.getAbsolutePath()+"\"到文件\""+f2.getAbsolutePath()+"\"中");

return true;
} catch (Exception ex) {
System.out.println("复制文件\""+f1.getAbsolutePath()+"\"到文件\""+f2.getAbsolutePath()+"\"时发生如下异常："+ex);
return false;
}
}
/**
* 拷贝目录方法
* @param d1 原始目录
* @param d2 目标目录
* @return 拷贝成功则返回真，否则返回假
*/
private static final boolean copyDirectory(File d1,File d2){
try{
System.out.println("即将复制目录\""+d1.getAbsolutePath()+"\"到目录\""+d2.getAbsolutePath()+"\"中");

if(d1.isDirectory()){
File fs[]=d1.listFiles();
if(!d2.isDirectory()){
if(d2.mkdir()){
System.out.println("创建目录\""+d2.getAbsolutePath()+"\"成功");
}
}
for(int i=0;i<fs.length;i++){
if(fs[i].isFile()){
File nf=new File(d2.getAbsolutePath()+"/"+fs[i].getName());
if(!copyFile(fs[i],nf))return false;
}
else {
File nd=new File(d2.getAbsolutePath()+"/"+fs[i].getName());
if(!copyDirectory(fs[i],nd))return false;
}
}
}
System.out.println("已经成功复制目录\""+d1.getAbsolutePath()+"\"到目录\""+d2.getAbsolutePath()+"\"中");
return true;

} catch(Exception ex){
System.out.println("复制目录\""+d1.getAbsolutePath()+"\"到目录\""+d2.getAbsolutePath()+"\"时发生如下异常："+ex);
return false;
}
}
/**
* 无损拷贝文件或目录
* @param f1 原始文件或目录的对象（可以是路径名或直接是File对象或资源对象URI，其它对象将返回假）
* @param f2 目标文件或目录的对象（可以是路径名或直接是File对象或资源对象URI，其它对象将返回假）
* @return 拷贝成功则返回真，否则返回假
*/
public static final boolean copy(Object f1,Object f2){
File d1=getFile(f1),d2=getFile(f2);
if(d1==null||d2==null){
return false;
}
if(d1.isFile()){
return copyFile(d1,d2);
}
else {
return copyDirectory(d1,d2);
}
}
/**
* 删除文件或目录
* @param file 文件或目录对象
* @return 如果删除成功，则返回真，否则返回假！
*/
public static final boolean delete(Object file){
boolean flag=false;
try{
File f=getFile(file);
if(f==null)return false;
if(f.isFile()){
System.out.println("即将删除文件\""+f.getAbsolutePath()+"\"");
flag=f.delete();
if(flag){
System.out.println("文件\""+f.getAbsolutePath()+"\"删除成功");
}
return flag;
}
else {
System.out.println("即将删除目录\""+f.getAbsolutePath()+"\"");
File[] fs=f.listFiles();
for(int i=0;i<fs.length;i++)
if(!delete(fs[i])){
return false;
}
flag=f.delete();
if(flag){
System.out.println("目录\""+f.getAbsolutePath()+"\"删除成功");
}
return flag;
}
}catch(Exception ex){
System.out.println("删除文件或目录时发生如下异常："+ex);
return false;
}
}
/**
* 删除符合条件的文件或目录，注意过滤器支持正则表达式，请谨慎使用通配符！其中将以
* 过滤器的字符串形式进行过滤。
* @param file 查找的目录文件范围
* @param filter 过滤器（文件或目录名匹配，支持正则表达式和通配符*）
* @return 删除成功则返回真，否则返回假
*/
public static final boolean delete(Object file,String filter){
File[] fs=search(file,filter);
for(int i=0;i<fs.length;i++){
if(!delete(fs[i])){
return false;
}
}
return true;
}
/**
* 读取文件内容并以String类型返回
* @param file 文件对象（可以是文件路径或File对象）
* @return 返回String表示的该文件的内容
*/
public static final String readFileToString(Object file){
StringBuilder sb=new StringBuilder();
try{
File f=getFile(file);
//BufferedReader br=new BufferedReader(new FileReader(f.getAbsoluteFile()),"GB2312");
InputStreamReader isr = new InputStreamReader(new FileInputStream(f), "UTF-8");
BufferedReader read = new BufferedReader(isr);
try{
String s;
while((s=read.readLine())!=null){
sb.append(s);
sb.append("\r\n");
}
}finally{
read.close();
}
}catch(Exception ex){
log.error("读取文件时发生如下异常："+ex);
throw new RuntimeException(ex);
}
return sb.toString();
}
/**
* 用于以一定的内容创建文件
* @param file 文件对象（可以是文件路径或File对象）
* @param text 要写入文件的内容
*/
public static final void creatFileByString(Object file,Object text){
try{
File f=getFile(file);
PrintWriter pw=new PrintWriter(f.getAbsoluteFile());
try{
pw.write(text.toString());
}finally{
pw.close();
}
}catch(Exception ex){
log.error("读取文件时发生如下异常："+ex);
throw new RuntimeException(ex);
}
}
/**
* 用于更新指定文件的内容，其中内容匹配采用正则表达式方式。
* @param file 要更新内容的文件，可以是文件路径名或者文件对象，必须是文件并且具有可读可写权限！
* @param regex 要替换掉的内容，可以是任何对象。原则是取该对象的字符串形式来匹配（正则表达式形式的匹配）！
* @param replacement 要替换成的内容，可以是任何对象。原则是取该对象的字符串形式来替换！
* @return 更新成功则返回真，否则返回假
*/
public static final boolean update(Object file,Object regex, Object replacement){
try{
File f=getFile(file);
if(f==null||!f.isFile()){
return false;
}
String r=regex.toString(),rm=replacement.toString();
System.out.println("文件\""+f.getAbsolutePath()+"\"的内容中的所有\""+r+"\"即将被替换为\""+rm+"\"");

creatFileByString(f.getAbsolutePath(),readFileToString(f.getAbsolutePath()).replaceAll(r,rm));
System.out.println("文件"+f.getAbsolutePath()+"的内容更新成功");
return true;
}catch(Exception ex){
log.error("更新文件时发生如下异常："+ex);
return false;
}
}
/**
* 查找符合条件的文件或目录
* @param file 查找的目录文件范围
* @param filter 过滤器（文件或目录名匹配，支持正则表达式和通配符*）
* @return 返回所有符合条件的文件对象数组
*/
public static final File[] search(Object file,String filter){
try{
File f=getFile(file);
if(f==null||!f.isDirectory()){
return null;
}
String fil=filter;
if(fil!=null&&fil.charAt(0)=='*'){
fil="."+fil;
}
if(f.getName().matches(fil)){
return new File[]{f};
}
else if(f.isDirectory()){
List li=new ArrayList();
File[] fs=f.listFiles();
for(int i=0;fs!=null&&i<fs.length;i++){
if(fs[i].isFile()){
if(fs[i].getName().matches(fil)){
li.add(fs[i]);
}
}
else {
File[] rfs=search(fs[i],filter);
for(int j=0;rfs!=null&&j<rfs.length;j++){
li.add(rfs[j]);
}
}
}
File[] rs=new File[li.size()];
for(int i=0;i<rs.length;i++){
rs[i]=(File) li.get(i);
}
return rs;
}
}catch(Exception ex){
log.error("查找文件时发生如下异常："+ex);
throw new RuntimeException(ex);

}
return null;
}
/**
* 本方法用于获取文件。如果输入的是一个目录，则将返回该目录中所有的文件（包括文件和子目录）。
* @param file 目录或文件
* @return 其包含的所有文件
*/
public static final File[] getFiles(Object file){
try{
File f=getFile(file);
if(f==null){
return null;
}
if(f.isFile()){
return new File[]{f};
}
else if(f.isDirectory()){
List li=new ArrayList();
li.add(f);
File[] fs=f.listFiles();
for(int i=0;fs!=null&&i<fs.length;i++){
if(fs[i].isFile()){
li.add(fs[i]);
}
else {
File[] rfs=getFiles(fs[i]);
for(int j=0;rfs!=null&&j<rfs.length;j++){
li.add(rfs[j]);
}
}
}
File[] rs=new File[li.size()];
for(int i=0;i<rs.length;i++){
rs[i]=(File) li.get(i);

}
return rs;
}


}catch(Exception ex){
log.error("查找文件时发生如下异常："+ex);
throw new RuntimeException(ex);
}
return null;
}
/**
* 获取文件或目录的尺寸
* @param file 文件或目录
* @return 返回long类型的尺寸大小值
*/
public static final long getFileSize(Object file){
File[] fs=getFiles(file);
if(fs==null)return 0L;
long size=0L;
for(int i=0;i<fs.length;i++){
size+=fs[i].length();
}
return size;
}
public static void main(String[] args) {
F f=new F();
File d1=new File("c:/test/java.txt");
File d2=new File("d:/test/");
long l= f.getFileSize(d1);
System.out.println(l);
}
}

猜你喜欢