Android文件操作工具类详解

本文实例为大家分享了android文件操作工具类的具体代码，供大家参考，具体内容如下

贴上我写的一个文件操作工具类，基本上覆盖了各种文件操作：

1、文件的新建、删除；

2、文件的复制；

3、获取文件扩展名；

4、文件的重命名；

5、获取某个文件的详细信息；

6、计算某个文件的大小；

7、文件大小的格式化；

8、获取某个路径下的文件列表；

9、获取某个目录下的文件列表；

10、目录的新建、删除;

11、目录的复制；

12、计算某个目录包含的文件数量；

13、计算某个目录包含的文件大小；

代码如下：

1、fileutil.java

package com.ctgu.filemaster.utils;
 
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.text.decimalformat;
import java.text.simpledateformat;
import java.util.arraylist;
import java.util.collections;
import java.util.date;
import java.util.list;
import java.util.locale;
 
import android.os.environment;
import android.util.log;
 
 
public class fileutil
{
  private static final string[][] mime_maptable =
  {
    // {后缀名， mime类型}
    { ".3gp", "video/3gpp" }, { ".apk", "application/vnd.android.package-archive" },
    { ".asf", "video/x-ms-asf" }, { ".avi", "video/x-msvideo" },
    { ".bin", "application/octet-stream" }, { ".bmp", "image/bmp" }, { ".c", "text/plain" },
    { ".class", "application/octet-stream" }, { ".conf", "text/plain" }, { ".cpp", "text/plain" },
    { ".doc", "application/msword" },
    { ".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
    { ".xls", "application/vnd.ms-excel" },
    { ".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
    { ".exe", "application/octet-stream" }, { ".gif", "image/gif" },
    { ".gtar", "application/x-gtar" }, { ".gz", "application/x-gzip" }, { ".h", "text/plain" },
    { ".htm", "text/html" }, { ".html", "text/html" }, { ".jar", "application/java-archive" },
    { ".java", "text/plain" }, { ".jpeg", "image/jpeg" }, { ".jpg", "image/jpeg" },
    { ".js", "application/x-javascript" }, { ".log", "text/plain" }, { ".m3u", "audio/x-mpegurl" },
    { ".m4a", "audio/mp4a-latm" }, { ".m4b", "audio/mp4a-latm" }, { ".m4p", "audio/mp4a-latm" },
    { ".m4u", "video/vnd.mpegurl" }, { ".m4v", "video/x-m4v" }, { ".mov", "video/quicktime" },
    { ".mp2", "audio/x-mpeg" }, { ".mp3", "audio/x-mpeg" }, { ".mp4", "video/mp4" },
    { ".mpc", "application/vnd.mpohun.certificate" }, { ".mpe", "video/mpeg" },
    { ".mpeg", "video/mpeg" }, { ".mpg", "video/mpeg" }, { ".mpg4", "video/mp4" },
    { ".mpga", "audio/mpeg" }, { ".msg", "application/vnd.ms-outlook" }, { ".ogg", "audio/ogg" },
    { ".pdf", "application/pdf" }, { ".png", "image/png" },
    { ".pps", "application/vnd.ms-powerpoint" }, { ".ppt", "application/vnd.ms-powerpoint" },
    { ".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
    { ".prop", "text/plain" }, { ".rc", "text/plain" }, { ".rmvb", "audio/x-pn-realaudio" },
    { ".rtf", "application/rtf" }, { ".sh", "text/plain" }, { ".tar", "application/x-tar" },
    { ".tgz", "application/x-compressed" }, { ".txt", "text/plain" }, { ".wav", "audio/x-wav" },
    { ".wma", "audio/x-ms-wma" }, { ".wmv", "audio/x-ms-wmv" },
    { ".wps", "application/vnd.ms-works" }, { ".xml", "text/plain" },
    { ".z", "application/x-compress" }, { ".zip", "application/x-zip-compressed" }, { "", "*/*" }
  };
 
  /**
   * 根据文件后缀名获得对应的mime类型
   *
   * @param file
   *      文件对象
   */
  public static string getmimetype(file file)
  {
    string type = "*/*";
    string filename = file.getname();
    int dotindex = filename.lastindexof("."); // 获取后缀名前的分隔符"."在filename中的位置
    if (dotindex < 0)
    {
      return type;
    }
 
    string end = filename.substring(dotindex, filename.length()).tolowercase(locale.getdefault()); // 获取文件的后缀名
    if (end.length() == 0)
    {
      return type;
    }
 
    // 在mime和文件类型的匹配表中找到对应的mime类型
    for (int i = 0; i < mime_maptable.length; i++)
    {
      if (end.equals(mime_maptable[i][0]))
      {
        type = mime_maptable[i][1];
      }
    }
    return type;
  }
 
  /**
   * 创建文件
   *
   * @param path
   *      文件所在目录的目录名，如/java/test/0.txt,要在当前目录下创建一个文件名为1.txt的文件，<br>
   *      则path为/java/test，filename为1.txt
   * @param filename
   *      文件名
   * @return 文件新建成功则返回true
   */
  public static boolean createfile(string path, string filename)
  {
    file file = new file(path + file.separator + filename);
    if (file.exists())
    {
      log.w(util.tag, "新建文件失败：file.exist()=" + file.exists());
      return false;
    }
    else
    {
      try
      {
        boolean iscreated = file.createnewfile();
        return iscreated;
      }
      catch (ioexception e)
      {
        e.printstacktrace();
      }
    }
    return false;
  }
 
  /**
   * 删除单个文件
   *
   * @param file
   *      要删除的文件对象
   * @return 文件删除成功则返回true
   */
  public static boolean deletefile(file file)
  {
    if (file.exists())
    {
      boolean isdeleted = file.delete();
      log.w(util.tag, file.getname() + "删除结果：" + isdeleted);
      return isdeleted;
    }
    else
    {
      log.w(util.tag, "文件删除失败：文件不存在！");
      return false;
    }
  }
 
  /**
   * 删除单个文件
   *
   * @param path
   *      文件所在路径名
   * @param filename
   *      文件名
   * @return 删除成功则返回true
   */
  public static boolean deletefile(string path, string filename)
  {
    file file = new file(path + file.separator + filename);
    if (file.exists())
    {
      boolean isdeleted = file.delete();
      return isdeleted;
    }
    else
    {
      return false;
    }
  }
 
  /**
   * 复制文件
   *
   * @param srcpath
   *      源文件绝对路径
   * @param destdir
   *      目标文件所在目录
   * @return boolean
   */
  public static boolean copyfile(string srcpath, string destdir)
  {
    boolean flag = false;
    file srcfile = new file(srcpath); // 源文件
    if (!srcfile.exists())
    {
      // 源文件不存在
      util.toast("源文件不存在");
      return false;
    }
    // 获取待复制文件的文件名
    string filename = srcpath.substring(srcpath.lastindexof(file.separator));
    string destpath = destdir + filename;
    if (destpath.equals(srcpath))
    {
      // 源文件路径和目标文件路径重复
      util.toast("源文件路径和目标文件路径重复!");
      return false;
    }
    file destfile = new file(destpath); // 目标文件
    if (destfile.exists() && destfile.isfile())
    {
      // 该路径下已经有一个同名文件
      util.toast("目标目录下已有同名文件!");
      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();
    }
    if (flag)
    {
      util.toast("复制文件成功!");
    }
    return flag;
  }
 
  /**
   * 根据文件名获得文件的扩展名
   *
   * @param filename
   *      文件名
   * @return 文件扩展名（不带点）
   */
  public static string getfilesuffix(string filename)
  {
    int index = filename.lastindexof(".");
    string suffix = filename.substring(index + 1, filename.length());
    return suffix;
  }
 
  /**
   * 重命名文件
   *
   * @param oldpath
   *      旧文件的绝对路径
   * @param newpath
   *      新文件的绝对路径
   * @return 文件重命名成功则返回true
   */
  public static boolean renameto(string oldpath, string newpath)
  {
    if (oldpath.equals(newpath))
    {
      log.w(util.tag, "文件重命名失败：新旧文件名绝对路径相同！");
      return false;
    }
    file oldfile = new file(oldpath);
    file newfile = new file(newpath);
 
    boolean issuccess = oldfile.renameto(newfile);
    log.w(util.tag, "文件重命名是否成功：" + issuccess);
    return issuccess;
  }
 
  /**
   * 重命名文件
   *
   * @param oldfile
   *      旧文件对象
   * @param newfile
   *      新文件对象
   * @return 文件重命名成功则返回true
   */
  public static boolean renameto(file oldfile, file newfile)
  {
    if (oldfile.equals(newfile))
    {
      log.w(util.tag, "文件重命名失败：旧文件对象和新文件对象相同！");
      return false;
    }
    boolean issuccess = oldfile.renameto(newfile);
    log.w(util.tag, "文件重命名是否成功：" + issuccess);
    return issuccess;
  }
 
  /**
   * 重命名文件
   *
   * @param oldfile
   *      旧文件对象，file类型
   * @param newname
   *      新文件的文件名，string类型
   * @return 重命名成功则返回true
   */
  public static boolean renameto(file oldfile, string newname)
  {
    file newfile = new file(oldfile.getparentfile() + file.separator + newname);
    boolean flag = oldfile.renameto(newfile);
    system.out.println(flag);
    return flag;
  }
 
  /**
   * 计算某个文件的大小
   *
   * @param file
   *      文件对象
   * @return 文件大小，如果file不是文件，则返回-1
   */
  public static long getfilesize(file file)
  {
    if (file.isfile())
    {
      return file.length();
    }
    else
    {
      return -1;
    }
  }
 
  /**
   * 计算某个文件的大小
   *
   * @param path
   *      文件的绝对路径
   * @return
   */
  public static long getfilesize(string path)
  {
    file file = new file(path);
    long size = file.length();
    return size;
  }
 
  /**
   * 文件大小的格式化
   *
   * @param size
   *      文件大小，单位为byte
   * @return 文件大小格式化后的文本
   */
  public static string formatsize(long size)
  {
    decimalformat df = new decimalformat("####.00");
    if (size < 1024) // 小于1kb
    {
      return size + "byte";
    }
    else if (size < 1024 * 1024) // 小于1mb
    {
      float ksize = size / 1024f;
      return df.format(ksize) + "kb";
    }
    else if (size < 1024 * 1024 * 1024) // 小于1gb
    {
      float msize = size / 1024f / 1024f;
      return df.format(msize) + "mb";
    }
    else if (size < 1024l * 1024l * 1024l * 1024l) // 小于1tb
    {
      float gsize = size / 1024f / 1024f / 1024f;
      return df.format(gsize) + "gb";
    }
    else
    {
      return "size: error";
    }
  }
 
  /**
   * 格式化文件最后修改时间字符串
   *
   * @param time
   * @return
   */
  public static string formattime(long time)
  {
    date date = new date(time);
    simpledateformat sdf = new simpledateformat("yyyy-mm-dd,hh:mm:ss", locale.getdefault());
    string formatedtime = sdf.format(date);
    return formatedtime;
  }
 
  /**
   * 获取某个路径下的文件列表
   *
   * @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 directory
   *      目录
   * @return 文件列表file[] files
   */
  public static file[] getfilelist(file directory)
  {
    file[] files = directory.listfiles();
    if (files != null)
    {
      return files;
    }
    else
    {
      return null;
    }
  }
 
  /**
   * 获得根目录文件列表
   *
   * @param showhidden
   * @param object
   * @param showhidden
   *      是否显示隐藏文件
   * @return
   */
  public static list<file> getsdcardfilelist(boolean showhidden)
  {
    list<file> list = new arraylist<>();
    file files[];
    if (environment.getexternalstoragestate().equals(environment.media_mounted))
    {
      file extdir = environment.getexternalstoragedirectory();
      files = extdir.listfiles();
      for (file file : files)
      {
        list.add(file);
      }
      if (showhidden)
      {
        //
      }
      else
      {
        for (int i = 0; i < list.size(); i++)
        {
          file file = list.get(i);
          if (file.ishidden() || file.getname().startswith("."))
          {
            list.remove(file);
          }
        }
      }
    }
    else
    {
      util.toast("sd卡未挂载！");
    }
    return list;
  }
 
  /**
   * 新建目录
   *
   * @param path
   *      目录的绝对路径
   * @return 创建成功则返回true
   */
  public static boolean createfolder(string path)
  {
    file file = new file(path);
    boolean iscreated = file.mkdir();
    return iscreated;
  }
 
  /**
   * 新建目录
   *
   * @param file
   * @return
   */
  public static boolean createfolder(file file)
  {
    boolean iscreated = file.mkdir();
    return iscreated;
  }
 
  /**
   * 删除文件夹及其包含的所有文件
   *
   * @param file
   * @return
   */
  public static boolean deletefolder(file file)
  {
    boolean flag = false;
    file files[] = file.listfiles();
    if (files != null && files.length >= 0) // 目录下存在文件列表
    {
      for (int i = 0; i < files.length; i++)
      {
        file f = files[i];
        if (f.isfile())
        {
          // 删除子文件
          flag = deletefile(f);
          if (flag == false)
          {
            return flag;
          }
        }
        else
        {
          // 删除子目录
          flag = deletefolder(f);
          if (flag == false)
          {
            return flag;
          }
        }
      }
    }
    flag = file.delete();
    if (flag == false)
    {
      return flag;
    }
    else
    {
      return true;
    }
  }
 
  /**
   * 复制目录
   *
   * @param srcpath
   *      源文件夹路径
   * @param destpath
   *      目标文件夹所在目录
   * @return 复制成功则返回true
   */
  public static boolean copyfolder(string srcpath, string destdir)
  {
    util.toast("复制文件夹开始!");
    boolean flag = false;
 
    file srcfile = new file(srcpath);
    if (!srcfile.exists())
    {
      // 源文件夹不存在
      util.toast("源文件夹不存在");
      return false;
    }
    string dirname = getdirname(srcpath); // 获得待复制的文件夹的名字，比如待复制的文件夹为"e://dir"则获取的名字为"dir"
 
    string destpath = destdir + file.separator + dirname; // 目标文件夹的完整路径
    // util.toast("目标文件夹的完整路径为：" + destpath);
    if (destpath.equals(srcpath))
    {
      util.toast("目标文件夹与源文件夹重复");
      return false;
    }
    file destdirfile = new file(destpath);
    if (destdirfile.exists())
    {
      // 目标位置有一个同名文件夹
      util.toast("目标位置已有同名文件夹!");
      return false;
    }
    destdirfile.mkdirs(); // 生成目录
 
    file[] files = srcfile.listfiles(); // 获取源文件夹下的子文件和子文件夹
    if (files.length == 0)
    {
      // 如果源文件夹为空目录则直接设置flag为true，这一步非常隐蔽，debug了很久
      flag = true;
    }
    else
    {
      for (file temp : files)
      {
        if (temp.isfile())
        {
          // 文件
          flag = copyfile(temp.getabsolutepath(), destpath);
        }
        else if (temp.isdirectory())
        {
          // 文件夹
          flag = copyfolder(temp.getabsolutepath(), destpath);
        }
        if (!flag)
        {
          break;
        }
      }
    }
    if (flag)
    {
      util.toast("复制文件夹成功!");
    }
    return flag;
  }
 
  /**
   * 获取待复制文件夹的文件夹名
   *
   * @param dir
   * @return string
   */
  public static string getdirname(string dir)
  {
    if (dir.endswith(file.separator))
    {
      // 如果文件夹路径以"//"结尾，则先去除末尾的"//"
      dir = dir.substring(0, dir.lastindexof(file.separator));
    }
    return dir.substring(dir.lastindexof(file.separator) + 1);
  }
 
  /**
   * 计算某个目录包含的文件数量
   *
   * @param directory
   * @return
   */
  public static int getfilecount(file directory)
  {
    file[] files = directory.listfiles();
    int count = files.length;
    return count;
  }
 
  /**
   * 计算某个路径下所包含的文件数量
   *
   * @param path
   * @return
   */
  public static int getfilecount(string path)
  {
    file file = new file(path);
    file[] files = file.listfiles();
    int count = files.length;
    return count;
  }
 
  /**
   * 计算某个目录的大小
   *
   * @param file
   * @return
   */
  public static long getfoldersize(file directory)
  {
    file[] files = directory.listfiles();
    if (files != null && files.length >= 0)
    {
      long size = 0;
      for (file f : files)
      {
        if (f.isfile())
        {
          // 获得子文件的大小
          size = size + getfilesize(f);
        }
        else
        {
          // 获得子目录的大小
          size = size + getfoldersize(f);
        }
      }
      return size;
    }
    return -1;
  }
 
  /**
   * 获得某个文件或目录的大小
   *
   * @param file
   * @return
   */
  public static long getfileorfoldersize(file file)
  {
    long size = 0;
    if (file.isdirectory())
    {
      size = getfoldersize(file);
    }
    else
    {
      size = getfilesize(file);
    }
    return size;
  }
}

以上各方法均在windows平台系统下测试过，基本上没问题，如果你碰到什么问题，可以在评论里给我留言，欢迎斧正！

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。