Android FileUtils 文件操作类

系统路径

Context.getPackageName();           // 用于获取APP的所在包目录
Context.getPackageCodePath();       //来获得当前应用程序对应的apk文件的路径
Context.getPackageResourcePath();   // 获取该程序的安装包路径
Context.getDatabasePath();          //返回通过Context.openOrCreateDatabase创建的数据库文件

Environment.getDataDirectory().getPath(); 　　　　　　   // 获得根目录/data
Environment.getDownloadCacheDirectory().getPath();     //获得缓存目录/cache
Environment.getExternalStorageDirectory().getPath();   //获得SD卡目录/mnt/sdcard
Environment.getRootDirectory().getPath();   　　　　    // 获得系统目录/system
//File.separator 代表 "/"

文件操作

String path = File.getPath();//获得文件或文件夹的绝对路径
String path = File.getAbsoultePath();//获得文件或文件夹的相对路径

String parentPath = File.getParent();//获得文件或文件夹的父目录

String Name = File.getName();//获得文件或文件夹的名称

File.mkDir(); //建立文件夹
File.createNewFile();//建立文件

File[] files = File.listFiles();//列出文件夹下的所有文件和文件夹名

File.isDirectory();//true是文件夹,false是文件

File.renameTo(dest);//修改文件夹和文件名

File.delete();//删除文件夹或文件

资源文件assets和RW

res/raw：文件会被映射到R.java文件中，访问的时候直接通过资源ID访问，没有有目录结构

assets：不会映射到R.java文件中，通过AssetManager来访问，能有目录结构

//raw:
InputStream is =getResources().openRawResource(R.raw.filename);  

//assets:
AssetManager am =  getAssets();
InputStream is = am.open("filename");

从资源文件中获取Bitmap

Bitmap bmp=BitmapFactory.decodeResource(getResources(), R.drawable.ico);

FileUtils文件操作类

public class FileUtils {

    //检查SDCard存在并且可以读写
    public static boolean isSDCardState(){
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

    /**
     * 判断文件是否已经存在
     *@param fileName 要检查的文件名
     * @return boolean, true表示存在，false表示不存在
     */
    public static boolean isFileExist(String fileName) {
        File file = new File("绝对路径" + fileName);
        return file.exists();
    }

     /**
     * 新建目录
     * @param path 目录的绝对路径
     * @return 创建成功则返回true
     */
    public static boolean createFolder(String path){
        File file = new File(path);
        return file.mkdir();
    }

    /**
     * 创建文件
     *@param path 文件所在目录的目录名
     * @param fileName 文件名
     * @return 文件新建成功则返回true
     */
    public static boolean createFile(String path, String fileName) {
        File file = new File(path + File.separator + fileName);
        if (file.exists()) {
            return false;
        } else {
            try {
                return file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    /**
     * 删除单个文件
     * @param path 文件所在的绝对路径
     * @param fileName 文件名
     * @return 删除成功则返回true
     */
    public static boolean deleteFile(String path, String fileName) {
        File file = new File(path + File.separator + fileName);
        return file.exists() && file.delete();
    }

    /**
     * 删除一个目录（可以是非空目录）
     * @param dir 目录绝对路径
     */
    public static boolean deleteDirection(File dir) {
        if (dir == null || !dir.exists() || dir.isFile()) {
            return false;
        }
        for (File file : dir.listFiles()) {
            if (file.isFile()) {
                file.delete();
            } else if (file.isDirectory()) {
                deleteDirection(file);//递归
            }
        }
        dir.delete();
        return true;
    }

    /**
     * 将字符串写入文件
     *@param text  写入的字符串
     * @param fileStr 文件的绝对路径
     * @param isAppend true从尾部写入，false从头覆盖写入
     */
    public static void writeFile(String text, String fileStr, boolean isAppend) {
        try {
            File file = new File(fileStr);
            File parentFile = file.getParentFile();
            if (!parentFile.exists()) {
                parentFile.mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            FileOutputStream f = new FileOutputStream(fileStr, isAppend);
            f.write(text.getBytes());
            f.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
     }

    /**
     * 拷贝文件
     *@param srcPath 绝对路径
     * @param destDir 目标文件所在目录
     * @return boolean true拷贝成功
     */
    public static boolean copyFile(String srcPath, String destDir){
        boolean flag = false;
        File srcFile = new File(srcPath); // 源文件
        if (!srcFile.exists()){
            Log.i("FileUtils is copyFile：","源文件不存在");
            return false;
        }
        // 获取待复制文件的文件名
        String fileName = srcPath.substring(srcPath.lastIndexOf(File.separator));
        String destPath = destDir + fileName;
        if (destPath.equals(srcPath)){
            Log.i("FileUtils is copyFile：","源文件路径和目标文件路径重复");
            return false;
        }
        File destFile = new File(destPath); // 目标文件
        if (destFile.exists() && destFile.isFile()){
            Log.i("FileUtils is copyFile：","该路径下已经有一个同名文件");
            return false;
        }
        File destFileDir = new File(destDir);
        destFileDir.mkdirs();
        try{
            FileInputStream fis = new FileInputStream(srcPath);
            FileOutputStream fos = new FileOutputStream(destFile);
            byte[] buf = new byte[1024];
            int c;
            while ((c = fis.read(buf)) != -1) {
                fos.write(buf, 0, c);
            }
            fis.close();
            fos.close();
            flag = true;
        }catch (IOException e){
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 重命名文件
     *@param oldPath 旧文件的绝对路径
     * @param newPath 新文件的绝对路径
     * @return 文件重命名成功则返回true
     */
    public static boolean renameTo(String oldPath, String newPath){
        if (oldPath.equals(newPath)){
            Log.i("FileUtils is renameTo：","文件重命名失败：新旧文件名绝对路径相同");
            return false;
        }
        File oldFile = new File(oldPath);
        File newFile = new File(newPath);

        return oldFile.renameTo(newFile);
    }

    /**
     * 计算某个文件的大小
     *@param path 文件的绝对路径
     *@return 文件大小
     */
    public static long getFileSize(String path){
        File file = new File(path);
        return file.length();
    }

    /**
     *计算某个文件夹的大小
     *@param  file 目录所在绝对路径
     * @return 文件夹的大小
     */
    public static double getDirSize(File file) {
        if (file.exists()) {
            //如果是目录则递归计算其内容的总大小
            if (file.isDirectory()) {
                File[] children = file.listFiles();
                double size = 0;
                for (File f : children)
                    size += getDirSize(f);
                return size;
            } else {//如果是文件则直接返回其大小,以“兆”为单位
                return (double) file.length() / 1024 / 1024;
            }
        } else {
            return 0.0;
        }
    }

    /**
     * 获取某个路径下的文件列表
     * @param path 文件路径
     * @return 文件列表File[] files
     */
    public static File[] getFileList(String path) {
        File file = new File(path);
        if (file.isDirectory()){
            File[] files = file.listFiles();
            if (files != null){
                return files;
            }else{
                return null;
            }
        }else{
            return null;
        }
    }

    /**
     * 计算某个目录包含的文件数量
     *@param path 目录的绝对路径
     * @return  文件数量
     */
    public static int getFileCount(String path){
        File directory = new File(path);
        File[] files = directory.listFiles();
        return files.length;
    }

    /**
     * 获取SDCard 总容量大小(MB)
     *@param path 目录的绝对路径
     * @return 总容量大小
     * */
    public long getSDCardTotal(String path){

        if(null != path&&path.equals("")){

            StatFs statfs = new StatFs(path);
            //获取SDCard的Block总数
            long totalBlocks = statfs.getBlockCount();
            //获取每个block的大小
            long blockSize = statfs.getBlockSize();
            //计算SDCard 总容量大小MB
            return totalBlocks*blockSize/1024/1024;

        }else{
            return 0;
        }
    }

    /**
     * 获取SDCard 可用容量大小(MB)
     *@param path 目录的绝对路径
     * @return 可用容量大小
     * */
    public long getSDCardFree(String path){

        if(null != path&&path.equals("")){

            StatFs statfs = new StatFs(path);
            //获取SDCard的Block可用数
            long availaBlocks = statfs.getAvailableBlocks();
            //获取每个block的大小
            long blockSize = statfs.getBlockSize();
            //计算SDCard 可用容量大小MB
            return availaBlocks*blockSize/1024/1024;

        }else{
            return 0;
        }
    }
}