效果图：

android中对文件进行复制，粘贴，删除等操作，需要在文件清单中添加权限：

 
  
  1. <uses-permission android:name="android.permission.WRITE_OWNER_DATA"></uses-permission> 
  2. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission> 
 
  
核心代码：
 
  
 
  
  1. package com.tarena.filemanger.fileutil;  
  2.  
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.OutputStream;  
  8.  
  9. import com.tarena.filemanger.util.MIMEType;  
  10.  
  11. import android.content.Context;  
  12. import android.content.Intent;  
  13. import android.net.Uri;  
  14. import android.os.Environment;  
  15.  
  16. public class FileHelper {  
  17.     private Context context;  
  18.     private String SDPATH;  
  19.     private String FILESPATH;  
  20.  
  21.     public FileHelper(Context context) {  
  22.         this.context = context;  
  23.         SDPATH = Environment.getExternalStorageDirectory().getPath() + "//";  
  24.     }  
  25.  
  26.     /**  
  27.      * 打开文件  
  28.      * @param file  
  29.      */  
  30.     public static void openFile(Context context,File file){  
  31.         //Uri uri = Uri.parse("file://"+file.getAbsolutePath());  
  32.         Intent intent = new Intent();  
  33.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
  34.         //设置intent的Action属性  
  35.         intent.setAction(Intent.ACTION_VIEW);  
  36.         //获取文件file的MIME类型  
  37.         String type = MIMEType.getMiMeType(file);  
  38.         //设置intent的data和Type属性。  
  39.         intent.setDataAndType(/*uri*/Uri.fromFile(file), type);  
  40.         //跳转  
  41.         context.startActivity(intent);      
  42.     }  
  43.     /**  
  44.      * 在SD卡上创建文件  
  45.      *   
  46.      * @throws IOException  
  47.      */  
  48.     public File creatSDFile(String fileName) throws IOException {  
  49.         File file = new File(SDPATH + fileName);  
  50.         file.createNewFile();  
  51.         return file;  
  52.     }  
  53.  
  54.     /**  
  55.      * 删除SD卡上的文件  
  56.      *   
  57.      * @param fileName  
  58.      */  
  59.     public boolean delSDFile(String fileName) {  
  60.         File file = new File(SDPATH + fileName);  
  61.         if (file == null || !file.exists() || file.isDirectory())  
  62.             return false;  
  63.         file.delete();  
  64.         return true;  
  65.     }  
  66.  
  67.     /**  
  68.      * 在SD卡上创建目录  
  69.      *   
  70.      * @param dirName  
  71.      */  
  72.     public File creatSDDir(String dirName) {  
  73.         File dir = new File(SDPATH + dirName);  
  74.         dir.mkdir();  
  75.         return dir;  
  76.     }  
  77.  
  78.     /**  
  79.      * 删除SD卡上的目录  
  80.      *   
  81.      * @param dirName  
  82.      */  
  83.     public boolean delSDDir(String dirName) {  
  84.         File dir = new File(SDPATH + dirName);  
  85.         return delDir(dir);  
  86.     }  
  87.     /**  
  88.      * 修改SD卡上的文件或目录名  
  89.      * @param fileName  
  90.      */  
  91.     public boolean renameSDFile(String oldfileName, String newFileName) {  
  92.         File oleFile = new File(oldfileName);  
  93.         File newnewFile = new File(newFileName);  
  94.         return oleFile.renameTo(newFile);  
  95.     }  
  96.  
  97.     /**  
  98.      * 拷贝SD卡上的单个文件  
  99.      * @param path  
  100.      * @throws IOException  
  101.      */  
  102.     public boolean copySDFileTo(String srcFileName, String destFileName,String filename)  
  103.             throws IOException {  
  104.         File srcFile = new File(srcFileName);  
  105.         File destFile = new File(destFileName+"/"+filename);  
  106.         return copyFileTo(srcFile, destFile);  
  107.     }  
  108.  
  109.     /**  
  110.      * 拷贝SD卡上指定目录的所有文件  
  111.      *   
  112.      * @param srcDirName  
  113.      * @param destDirName  
  114.      * @return  
  115.      * @throws IOException  
  116.      */  
  117.     public boolean copySDFilesTo(String srcDirName, String destDirName,String filename)  
  118.             throws IOException {  
  119.         File srcDir = new File(srcDirName);  
  120.         File destDir = new File(destDirName+"/"+filename);  
  121.         return copyFilesTo(srcDir, destDir);  
  122.     }  
  123.  
  124.     /**  
  125.      * 移动SD卡上的单个文件  
  126.      *   
  127.      * @param srcFileName  
  128.      * @param destFileName  
  129.      * @return  
  130.      * @throws IOException  
  131.      */  
  132.     public boolean moveSDFileTo(String srcFileName, String destFileName)  
  133.             throws IOException {  
  134.         File srcFile = new File(SDPATH + srcFileName);  
  135.         File destFile = new File(SDPATH + destFileName);  
  136.         return moveFileTo(srcFile, destFile);  
  137.     }  
  138.  
  139.     /**  
  140.      * 移动SD卡上的指定目录的所有文件  
  141.      * @param srcDirName  
  142.      * @param destDirName  
  143.      * @return  
  144.      * @throws IOException  
  145.      */  
  146.     public boolean moveSDFilesTo(String srcDirName, String destDirName)  
  147.             throws IOException {  
  148.         File srcDir = new File(SDPATH + srcDirName);  
  149.         File destDir = new File(SDPATH + destDirName);  
  150.         return moveFilesTo(srcDir, destDir);  
  151.     }  
  152.  
  153.  
  154.     /*  
  155.      * 将文件写入sd卡。如:writeSDFile("test.txt");  
  156.      */  
  157. //  public Output writeSDFile(String fileName) throws IOException {  
  158. //      File file = new File(SDPATH + fileName);  
  159. //      FileOutputStream fos = new FileOutputStream(file);  
  160. //      return new Output(fos);  
  161. //  }  
  162.  
  163.     /*  
  164.      * 在原有文件上继续写文件。如:appendSDFile("test.txt");  
  165.      */  
  166. //  public Output appendSDFile(String fileName) throws IOException {  
  167. //      File file = new File(SDPATH + fileName);  
  168. //      FileOutputStream fos = new FileOutputStream(file, true);  
  169. //      return new Output(fos);  
  170. //  }  
  171.  
  172.     /*  
  173.      * 从SD卡读取文件。如:readSDFile("test.txt");  
  174.      */  
  175. //  public Input readSDFile(String fileName) throws IOException {  
  176. //      File file = new File(SDPATH + fileName);  
  177. //      FileInputStream fis = new FileInputStream(file);  
  178. //      return new Input(fis);  
  179. //  }  
  180.       
  181.       
  182.     /**  
  183.      * 建立私有文件  
  184.      *   
  185.      * @param fileName  
  186.      * @return  
  187.      * @throws IOException  
  188.      */  
  189.     public File creatDataFile(String fileName) throws IOException {  
  190.         File file = new File(FILESPATH + fileName);  
  191.         file.createNewFile();  
  192.         return file;  
  193.     }  
  194.  
  195.     /**  
  196.      * 建立私有目录  
  197.      *   
  198.      * @param dirName  
  199.      * @return  
  200.      */  
  201.     public File creatDataDir(String dirName) {  
  202.         File dir = new File(FILESPATH + dirName);  
  203.         dir.mkdir();  
  204.         return dir;  
  205.     }  
  206.  
  207.     /**  
  208.      * 删除私有文件  
  209.      *   
  210.      * @param fileName  
  211.      * @return  
  212.      */  
  213.     public boolean delDataFile(String fileName) {  
  214.         File file = new File(FILESPATH + fileName);  
  215.         return delFile(file);  
  216.     }  
  217.  
  218.     /**  
  219.      * 删除私有目录  
  220.      *   
  221.      * @param dirName  
  222.      * @return  
  223.      */  
  224.     public boolean delDataDir(String dirName) {  
  225.         File file = new File(FILESPATH + dirName);  
  226.         return delDir(file);  
  227.     }  
  228.  
  229.     /**  
  230.      * 更改私有文件名  
  231.      *   
  232.      * @param oldName  
  233.      * @param newName  
  234.      * @return  
  235.      */  
  236.     public boolean renameDataFile(String oldName, String newName) {  
  237.         File oldFile = new File(FILESPATH + oldName);  
  238.         File newnewFile = new File(FILESPATH + newName);  
  239.         return oldFile.renameTo(newFile);  
  240.     }  
  241.  
  242.     /**  
  243.      * 在私有目录下进行文件复制  
  244.      *   
  245.      * @param srcFileName  
  246.      *            ： 包含路径及文件名  
  247.      * @param destFileName  
  248.      * @return  
  249.      * @throws IOException  
  250.      */  
  251.     public boolean copyDataFileTo(String srcFileName, String destFileName)  
  252.             throws IOException {  
  253.         File srcFile = new File(FILESPATH + srcFileName);  
  254.         File destFile = new File(FILESPATH + destFileName);  
  255.         return copyFileTo(srcFile, destFile);  
  256.     }  
  257.  
  258.     /**  
  259.      * 复制私有目录里指定目录的所有文件  
  260.      *   
  261.      * @param srcDirName  
  262.      * @param destDirName  
  263.      * @return  
  264.      * @throws IOException  
  265.      */  
  266.     public boolean copyDataFilesTo(String srcDirName, String destDirName)  
  267.             throws IOException {  
  268.         File srcDir = new File(FILESPATH + srcDirName);  
  269.         File destDir = new File(FILESPATH + destDirName);  
  270.         return copyFilesTo(srcDir, destDir);  
  271.     }  
  272.  
  273.     /**  
  274.      * 移动私有目录下的单个文件  
  275.      *   
  276.      * @param srcFileName  
  277.      * @param destFileName  
  278.      * @return  
  279.      * @throws IOException  
  280.      */  
  281.     public boolean moveDataFileTo(String srcFileName, String destFileName)  
  282.             throws IOException {  
  283.         File srcFile = new File(FILESPATH + srcFileName);  
  284.         File destFile = new File(FILESPATH + destFileName);  
  285.         return moveFileTo(srcFile, destFile);  
  286.     }  
  287.  
  288.     /**  
  289.      * 移动私有目录下的指定目录下的所有文件  
  290.      *   
  291.      * @param srcDirName  
  292.      * @param destDirName  
  293.      * @return  
  294.      * @throws IOException  
  295.      */  
  296.     public boolean moveDataFilesTo(String srcDirName, String destDirName)  
  297.             throws IOException {  
  298.         File srcDir = new File(FILESPATH + srcDirName);  
  299.         File destDir = new File(FILESPATH + destDirName);  
  300.         return moveFilesTo(srcDir, destDir);  
  301.     }  
  302.  
  303.     /*  
  304.      * 将文件写入应用私有的files目录。如:writeFile("test.txt");  
  305.      */  
  306.     public OutputStream wirteFile(String fileName) throws IOException {  
  307.         OutputStream os = context.openFileOutput(fileName,  
  308.                 Context.MODE_WORLD_WRITEABLE);  
  309.         return  os;  
  310.     }  
  311.  
  312.     /*  
  313.      * 在原有文件上继续写文件。如:appendFile("test.txt");  
  314.      */  
  315. //  public Output appendFile(String fileName) throws IOException {  
  316. //      OutputStream os = context.openFileOutput(fileName, Context.MODE_APPEND);  
  317. //      return new Output(os);  
  318. //  }  
  319.  
  320.     /*  
  321.      * 从应用的私有目录files读取文件。如:readFile("test.txt");  
  322.      */  
  323. //  public Input readFile(String fileName) throws IOException {  
  324. //      InputStream is = context.openFileInput(fileName);  
  325. //      return new Input(is);  
  326. //  }  
  327.       
  328.       
  329.       
  330.     /**********************************************************************************************************/  
  331.     /*********************************************************************************************************/  
  332.     /**  
  333.      * 删除一个文件  
  334.      *   
  335.      * @param file  
  336.      * @return  
  337.      */  
  338.     public boolean delFile(File file) {  
  339.         if (file.isDirectory())  
  340.             return false;  
  341.         return file.delete();  
  342.     }  
  343.  
  344.     /**  
  345.      * 删除一个目录（可以是非空目录）  
  346.      * @param dir  
  347.      */  
  348.     public boolean delDir(File dir) {  
  349.         if (dir == null || !dir.exists() || dir.isFile()) {  
  350.             return false;  
  351.         }  
  352.         for (File file : dir.listFiles()) {  
  353.             if (file.isFile()) {  
  354.                 file.delete();  
  355.             } else if (file.isDirectory()) {  
  356.                 delDir(file);// 递归  
  357.             }  
  358.         }  
  359.         dir.delete();  
  360.         return true;  
  361.     }  
  362.  
  363.     /**  
  364.      * 拷贝一个文件,srcFile源文件，destFile目标文件  
  365.      * @param path  
  366.      * @throws IOException  
  367.      */  
  368.     public boolean copyFileTo(File srcFile, File destFile) throws IOException {  
  369.         if (srcFile.isDirectory() || destFile.isDirectory())  
  370.             return false;// 判断是否是文件  
  371.         FileInputStream fis = new FileInputStream(srcFile);  
  372.         FileOutputStream fos = new FileOutputStream(destFile);  
  373.         int readLen = 0;  
  374.         byte[] buf = new byte[1024];  
  375.         while ((readLen = fis.read(buf)) != -1) {  
  376.             fos.write(buf, 0, readLen);  
  377.         }  
  378.         fos.flush();  
  379.         fos.close();  
  380.         fis.close();  
  381.         return true;  
  382.     }  
  383.  
  384.     /**  
  385.      * 拷贝目录下的所有文件到指定目录  
  386.      *   
  387.      * @param srcDir  
  388.      * @param destDir  
  389.      * @return  
  390.      * @throws IOException  
  391.      */  
  392.     public boolean copyFilesTo(File srcDir, File destDir) throws IOException {  
  393.         if (!destDir.exists()) {  
  394.             destDir.mkdirs();  
  395.          }  
  396.         if (!srcDir.isDirectory() || !destDir.isDirectory())  
  397.             return false;// 判断是否是目录   
  398.         File[] srcFiles = srcDir.listFiles();  
  399.         for (int i = 0; i < srcFiles.length; i++) {  
  400.             if (srcFiles[i].isFile()) {  
  401.                 // 获得目标文件  
  402.                 File destFile = new File(destDir.getPath() + "//"  
  403.                         + srcFiles[i].getName());  
  404.                 copyFileTo(srcFiles[i], destFile);  
  405.             } else if (srcFiles[i].isDirectory()) {  
  406.                 File theDestDir = new File(destDir.getPath() + "//"  
  407.                         + srcFiles[i].getName());  
  408.                 copyFilesTo(srcFiles[i], theDestDir);  
  409.             }  
  410.         }  
  411.         return true;  
  412.     }  
  413.  
  414.     /**  
  415.      * 移动一个文件  
  416.      *   
  417.      * @param srcFile  
  418.      * @param destFile  
  419.      * @return  
  420.      * @throws IOException  
  421.      */  
  422.     public boolean moveFileTo(File srcFile, File destFile) throws IOException {  
  423.         boolean iscopy = copyFileTo(srcFile, destFile);  
  424.         if (!iscopy)  
  425.             return false;  
  426.         delFile(srcFile);  
  427.         return true;  
  428.     }  
  429.  
  430.     /**  
  431.      * 移动目录下的所有文件到指定目录  
  432.      * @param srcDir  
  433.      * @param destDir  
  434.      * @return  
  435.      * @throws IOException  
  436.      */  
  437.     public boolean moveFilesTo(File srcDir, File destDir) throws IOException {  
  438.         if (!srcDir.isDirectory() || !destDir.isDirectory()) {  
  439.             return false;  
  440.         }  
  441.         File[] srcDirsrcDirFiles = srcDir.listFiles();  
  442.         for (int i = 0; i < srcDirFiles.length; i++) {  
  443.             if (srcDirFiles[i].isFile()) {  
  444.                 File oneDestFile = new File(destDir.getPath() + "//"  
  445.                         + srcDirFiles[i].getName());  
  446.                 moveFileTo(srcDirFiles[i], oneDestFile);  
  447.                 delFile(srcDirFiles[i]);  
  448.             } else if (srcDirFiles[i].isDirectory()) {  
  449.                 File oneDestFile = new File(destDir.getPath() + "//"  
  450.                         + srcDirFiles[i].getName());  
  451.                 moveFilesTo(srcDirFiles[i], oneDestFile);  
  452.                 delDir(srcDirFiles[i]);  
  453.             }  
  454.  
  455.         }  
  456.         return true;  
  457.     }  
  458. }