Java操作文件，

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);
}
}