深蓝计划之java 文件工具类

package com.shop.ssm.util; 
 
import java.io.BufferedInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.RandomAccessFile; 
import java.nio.ByteBuffer; 
import java.nio.MappedByteBuffer; 
import java.nio.channels.FileChannel; 
import java.nio.channels.FileChannel.MapMode; 
 
/**	文件处理 
 *  创建人：周志刚 
 * 创建时间：2016年9月1日 
 */ 
public class FileUtil { 
 
 
    /**获取文件大小 返回 KB 保留3位小数  没有文件时返回0 
     * @param filepath 文件完整路径，包括文件名 
     * @return 
     */ 
    public static Double getFilesize(String filepath){ 
        File backupath = new File(filepath); 
        return Double.valueOf(backupath.length())/1000.000; 
    } 
 
    /** 
     * 创建目录 
     * @return 
     */ 
    public static Boolean createDir(String destDirName) { 
        File dir = new File(destDirName); 
        if(!dir.getParentFile().exists()){				//判断有没有父路径，就是判断文件整个路径是否存在 
            return dir.getParentFile().mkdirs();		//不存在就全部创建 
        } 
        return false; 
    } 
 
    /** 
     * 删除文件 
     * @param filePathAndName 
     * String 文件路径及名称 如c:/fqf.txt 
     * 
     * @return boolean 
     */ 
    public static void delFile(String filePathAndName) { 
        try { 
            String filePath = filePathAndName; 
            filePath = filePath.toString(); 
            java.io.File myDelFile = new java.io.File(filePath); 
            myDelFile.delete(); 
        } catch (Exception e) { 
            System.out.println("删除文件操作出错"); 
            e.printStackTrace(); 
        } 
    } 
 
    /** 
     * 读取到字节数组0 
     * @param filePath //路径 
     * @throws IOException 
     */ 
    public static byte[] getContent(String filePath) throws IOException { 
        File file = new File(filePath); 
        long fileSize = file.length(); 
        if (fileSize > Integer.MAX_VALUE) { 
            System.out.println("file too big..."); 
            return null; 
        } 
        FileInputStream fi = new FileInputStream(file); 
        byte[] buffer = new byte[(int) fileSize]; 
        int offset = 0; 
        int numRead = 0; 
        while (offset < buffer.length 
                && (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) { 
            offset += numRead; 
        } 
        // 确保所有数据均被读取 
        if (offset != buffer.length) { 
            throw new IOException("Could not completely read file " + file.getName()); 
        } 
        fi.close(); 
        return buffer; 
    } 
 
    /** 
     * 读取到字节数组1 
     * 
     * @param filePath 
     * @return 
     * @throws IOException 
     */ 
    public static byte[] toByteArray(String filePath) throws IOException { 
 
        File f = new File(filePath); 
        if (!f.exists()) { 
            throw new FileNotFoundException(filePath); 
        } 
        ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length()); 
        BufferedInputStream in = null; 
        try { 
            in = new BufferedInputStream(new FileInputStream(f)); 
            int buf_size = 1024; 
            byte[] buffer = new byte[buf_size]; 
            int len = 0; 
            while (-1 != (len = in.read(buffer, 0, buf_size))) { 
                bos.write(buffer, 0, len); 
            } 
            return bos.toByteArray(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
            throw e; 
        } finally { 
            try { 
                in.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
            bos.close(); 
        } 
    } 
 
    /** 
     * 读取到字节数组2 
     * 
     * @param filePath 
     * @return 
     * @throws IOException 
     */ 
    public static byte[] toByteArray2(String filePath) throws IOException { 
        File f = new File(filePath); 
        if (!f.exists()) { 
            throw new FileNotFoundException(filePath); 
        } 
        FileChannel channel = null; 
        FileInputStream fs = null; 
        try { 
            fs = new FileInputStream(f); 
            channel = fs.getChannel(); 
            ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size()); 
            while ((channel.read(byteBuffer)) > 0) { 
                // do nothing 
                // System.out.println("reading"); 
            } 
            return byteBuffer.array(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
            throw e; 
        } finally { 
            try { 
                channel.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
            try { 
                fs.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
 
    /** 
     * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能 
     * @return 
     * @throws IOException 
     */ 
    public static byte[] toByteArray3(String filePath) throws IOException { 
 
        FileChannel fc = null; 
        RandomAccessFile rf = null; 
        try { 
            rf = new RandomAccessFile(filePath, "r"); 
            fc = rf.getChannel(); 
            MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0, 
                    fc.size()).load(); 
            //System.out.println(byteBuffer.isLoaded()); 
            byte[] result = new byte[(int) fc.size()]; 
            if (byteBuffer.remaining() > 0) { 
                // System.out.println("remain"); 
                byteBuffer.get(result, 0, byteBuffer.remaining()); 
            } 
            return result; 
        } catch (IOException e) { 
            e.printStackTrace(); 
            throw e; 
        } finally { 
            try { 
                rf.close(); 
                fc.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 
 
}