devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【安卓常用】文件工具类FileUtils【Uri】【安卓常用文件储存】_fileutils 通过uri获取文件

作者：知新_RL | 2024-03-26 19:36:49

赞

踩

fileutils 通过uri获取文件

工作中用到的一些工具类，做一个笔记，以便日后回顾~

  1. 1，路径为：data/data/包名/app_+APP_CONFIG /APP_CONFIG ,其中包名后面的app_是为调用时，系统自己加上的
  2.         Context context ;
  3.         private final String APP_CONFIG ="config";
  4.         File dirConf= context.getDir(APP_CONFIG, Context.MODE_PRIVATE);
  5.         File conf = new File(dirConf, APP_CONFIG);
  6.  
  7.      2，/data/data/<application package>/cache目录
  8.         context.getCacheDir().getAbsolutePath();
  9.  
  10.      3，/data/data/<application package>/files目录
  11.         context.getFilesDir().getAbsolutePath();
  12.  
  13.      4，取到 SDCard/Android/data/你的应用的包名/files/ 目录，一般放一些长时间保存的数据
  14.         context.getExternalFilesDir().getAbsolutePath();
  15.  
  16.      5，取到 SDCard/Android/data/你的应用包名/cache/目录，一般存放临时缓存数据
  17.         context.getExternalCacheDir().getAbsolutePath();
  18.  
  19.      6，/storage/sdcard/0这个储存路径需要申请权限
  20.         Environment.getExternalStorageDirectory();
  21.  
  22.      7，以第一个常量为例，音乐类别的公共目录绝对路径为：/storage/emulated/0/Music。
  23.         如果你使用文件管理器打开设备的外部存储空间的话，均可以看到这些公共目录文件夹。 
  24.  
  25.         Environment.getExternalStoragePublicDirectory(String type);
  26.         Envinonment 类提供诸多 type 参数的常量，比如：
  27.  
  28.         DIRECTORY_MUSIC：Music
  29.         DIRECTORY_MOVIES：Movies
  30.         DIRECTORY_PICTURES：Pictures
  31.         DIRECTORY_DOWNLOADS：Download

 

  1. /**
  2.  * 文件工具类
  3.  *
  4.  * @author mazhanzhu 2019年8月19日17:04:11
  5.  */
  6. public class FileUtils {
  7.     public static final int SIZETYPE_B = 1;//获取文件大小单位为B的double值
  8.     public static final int SIZETYPE_KB = 2;//获取文件大小单位为KB的double值
  9.     public static final int SIZETYPE_MB = 3;//获取文件大小单位为MB的double值
  10.     public static final int SIZETYPE_GB = 4;//获取文件大小单位为GB的double值
  11.     public static final String path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getAbsolutePath();
  12.  
  13.     /**
  14.      * 格式转换文件大小
  15.      *
  16.      * @param context
  17.      * @param fileSize
  18.      * @return
  19.      */
  20.     @SuppressLint("NewApi")
  21.     public static String formatFileSize(Context context, long fileSize) {
  22.         return Formatter.formatFileSize(context, fileSize);
  23.     }
  24.  
  25.     /**
  26.      * 判断该文件是否存在
  27.      *
  28.      * @return
  29.      */
  30.     public static boolean isExist(String path) {
  31.         try {
  32.             File f = new File(path);
  33.             if (f.exists()) {
  34.                 return true;
  35.             }
  36.         } catch (Exception e) {
  37.             return false;
  38.         }
  39.         return false;
  40.  
  41.     }
  42.  
  43.     /**
  44.      * 根据文件，读取里面的内容
  45.      *
  46.      * @param context  上下文
  47.      * @param filename 文件的名字
  48.      * @return 返回文件所包含的信息
  49.      */
  50.     public static String getLocalFile(Activity context, String filename) {
  51.         String result = null;
  52.         //内置sd卡路径
  53.         File file = new File(Environment.getExternalStorageDirectory().getAbsoluteFile() + "/" + filename);
  54.         Log.e("fd", "这是文件储存的路径: " + file.toString());
  55.         if (file.exists()) {
  56.             try {
  57.                 FileInputStream fis = new FileInputStream(file);
  58.                 // 把字节流转换为字节流
  59.                 BufferedReader br = new BufferedReader(new InputStreamReader(
  60.                         fis));
  61.                 result = br.readLine();
  62.             } catch (Exception e) {
  63.                 e.printStackTrace();
  64.                 Log.e("fd", "文件读取错误: " + e.toString());
  65.             }
  66.         } else {
  67.             ToastUtils.showToast("信息获取失败");
  68.             context.finish();
  69.         }
  70.         return result;
  71.     }
  72.  
  73.     /**
  74.      * 判断手机是否安装某个应用
  75.      *
  76.      * @param context
  77.      * @param appPackageName 应用包名
  78.      * @return true：安装，false：未安装
  79.      */
  80.     public static boolean isApplicationAvilible(Context context, String appPackageName) {
  81.         // 获取packagemanager
  82.         PackageManager packageManager = context.getPackageManager();
  83.         // 获取所有已安装程序的包信息
  84.         List<PackageInfo> pinfo = packageManager.getInstalledPackages(0);
  85.         if (pinfo != null) {
  86.             for (int i = 0; i < pinfo.size(); i++) {
  87.                 String pn = pinfo.get(i).packageName;
  88.                 if (appPackageName.equals(pn)) {
  89.                     return true;
  90.                 }
  91.             }
  92.         }
  93.         return false;
  94.     }
  95.  
  96.     /**
  97.      * 保存异常信息到文件
  98.      *
  99.      * @param data
  100.      * @param file_name
  101.      * @param isAppend  是否是追加， true为追加。  false为覆盖
  102.      */
  103.     public static void saveFile(String data, String file_name, boolean isAppend) {
  104.         //内置sd卡路径
  105.         File sdPath = new File(Environment.getExternalStorageDirectory().getAbsolutePath());
  106.         if (!sdPath.exists()) {
  107.             sdPath.mkdirs();
  108.         }
  109.         Log.e("fd", "saveFile: " + sdPath.toString());
  110.         File file = new File(sdPath, file_name);
  111.         FileOutputStream fos = null;
  112.         try {
  113.             fos = new FileOutputStream(file, isAppend);
  114.             fos.write(data.getBytes("UTF-8"));
  115.         } catch (Exception e) {
  116.             e.printStackTrace();
  117.         } finally {
  118.             if (fos != null) {
  119.                 try {
  120.                     fos.close();
  121.                 } catch (IOException e) {
  122.                     e.printStackTrace();
  123.                 }
  124.             }
  125.         }
  126.     }
  127.  
  128.     /**
  129.      * 获取文件指定文件的指定单位的大小
  130.      *
  131.      * @param filePath 文件路径
  132.      * @param sizeType 获取大小的类型1为B、2为KB、3为MB、4为GB
  133.      * @return double值的大小
  134.      */
  135.     public static double getFileOrFilesSize(String filePath, int sizeType) {
  136.         File file = new File(filePath);
  137.         long blockSize = 0;
  138.         try {
  139.             if (file.isDirectory()) {
  140.                 blockSize = getFileSizes(file);
  141.             } else {
  142.                 blockSize = getFileSize(file);
  143.             }
  144.         } catch (Exception e) {
  145.             e.printStackTrace();
  146.             Log_Ma.e("获取文件大小", "获取失败!");
  147.         }
  148.         return FormetFileSize(blockSize, sizeType);
  149.     }
  150.  
  151.     /**
  152.      * 调用此方法自动计算指定文件或指定文件夹的大小
  153.      *
  154.      * @param filePath 文件路径
  155.      * @return 计算好的带B、KB、MB、GB的字符串
  156.      */
  157.     public static String getAutoFileOrFilesSize(String filePath) {
  158.         File file = new File(filePath);
  159.         long blockSize = 0;
  160.         try {
  161.             if (file.isDirectory()) {
  162.                 blockSize = getFileSizes(file);
  163.             } else {
  164.                 blockSize = getFileSize(file);
  165.             }
  166.         } catch (Exception e) {
  167.             e.printStackTrace();
  168.             Log_Ma.e("获取文件大小", "获取失败!");
  169.         }
  170.         return FormetFileSize(blockSize);
  171.     }
  172.  
  173.     /**
  174.      * 获取指定文件大小
  175.      */
  176.     public static long getFileSize(File file) {
  177.         try {
  178.             long size = 0;
  179.             if (file.exists()) {
  180.                 FileInputStream fis = null;
  181.                 fis = new FileInputStream(file);
  182.                 size = fis.available();
  183.             } else {
  184.                 file.createNewFile();
  185.                 Log_Ma.e("获取文件大小", "文件不存在!");
  186.             }
  187.             return size;
  188.         } catch (Exception e) {
  189.             return 0;
  190.         }
  191.     }
  192.  
  193.     /**
  194.      * 获取指定文件夹
  195.      *
  196.      * @param f
  197.      * @return
  198.      * @throws Exception
  199.      */
  200.     public static long getFileSizes(File f) throws Exception {
  201.         long size = 0;
  202.         File flist[] = f.listFiles();
  203.         for (int i = 0; i < flist.length; i++) {
  204.             if (flist[i].isDirectory()) {
  205.                 size = size + getFileSizes(flist[i]);
  206.             } else {
  207.                 size = size + getFileSize(flist[i]);
  208.             }
  209.         }
  210.         return size;
  211.     }
  212.  
  213.     /**
  214.      * 将long类型的数据转成相应大小的字符串
  215.      * <p>
  216.      * （例：30.05MB、1.25GB、40.87KB）
  217.      *
  218.      * @param fileS 参数
  219.      * @return 文件的大小描述
  220.      */
  221.     public static String FormetFileSize(long fileS) {
  222.         DecimalFormat df = new DecimalFormat("0.00");
  223.         String fileSizeString = "";
  224.         String wrongSize = "0B";
  225.         if (fileS == 0) {
  226.             return wrongSize;
  227.         }
  228.         if (fileS < 1024) {
  229.             fileSizeString = df.format((double) fileS) + "B";
  230.         } else if (fileS < 1048576) {
  231.             fileSizeString = df.format((double) fileS / 1024) + "KB";
  232.         } else if (fileS < 1073741824) {
  233.             fileSizeString = df.format((double) fileS / 1048576) + "MB";
  234.         } else {
  235.             fileSizeString = df.format((double) fileS / 1073741824) + "GB";
  236.         }
  237.         return fileSizeString;
  238.     }
  239.  
  240.     /**
  241.      * 转换文件大小,指定转换的类型
  242.      *
  243.      * @param fileS
  244.      * @param sizeType
  245.      * @return
  246.      */
  247.     public static double FormetFileSize(long fileS, int sizeType) {
  248.         DecimalFormat df = new DecimalFormat("0.00");
  249.         double fileSizeLong = 0;
  250.         switch (sizeType) {
  251.             case SIZETYPE_B:
  252.                 fileSizeLong = Double.valueOf(df.format((double) fileS));
  253.                 break;
  254.             case SIZETYPE_KB:
  255.                 fileSizeLong = Double.valueOf(df.format((double) fileS / 1024));
  256.                 break;
  257.             case SIZETYPE_MB:
  258.                 fileSizeLong = Double.valueOf(df.format((double) fileS / 1048576));
  259.                 break;
  260.             case SIZETYPE_GB:
  261.                 fileSizeLong = Double.valueOf(df.format((double) fileS / 1073741824));
  262.                 break;
  263.             default:
  264.                 break;
  265.         }
  266.         return fileSizeLong;
  267.     }
  268.  
  269.     //android获取一个用于打开HTML文件的intent
  270.     public static void Open_Html_File(Activity activity, File file) {
  271.         Uri uri = Uri.parse(file.toString()).buildUpon().encodedAuthority("com.android.htmlfileprovider").scheme("content").encodedPath(file.toString()).build();
  272.         Intent intent = new Intent(Intent.ACTION_VIEW);
  273.         intent.setDataAndType(uri, "text/html");
  274.         try {
  275.             activity.startActivity(intent);
  276.         } catch (Exception e) {
  277.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  278.         }
  279.     }
  280.  
  281.  
  282. --------------------注意7.0以上要配置动态SD卡动态权限，不然不好使，详情参考博客里面FileProvider配置！！！！！-------------------------------------------------
  283.  
  284.     //android获取一个用于打开图片文件的intent
  285.     public static void Open_Image_File(Activity activity, File file) {
  286.         Intent intent = new Intent(Intent.ACTION_VIEW);
  287.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  288.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  289.         Uri uri = Uri.fromFile(file);
  290.         intent.setDataAndType(uri, "image/*");
  291.         try {
  292.             activity.startActivity(intent);
  293.         } catch (Exception e) {
  294.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  295.         }
  296.     }
  297.  
  298.     //android获取一个用于打开PDF文件的intent
  299.     public static void Open_PDF_File(Activity activity, File file) {
  300.         Intent intent = new Intent(Intent.ACTION_VIEW);
  301.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  302.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  303.         Uri uri = Uri.fromFile(file);
  304.         intent.setDataAndType(uri, "application/pdf");
  305.         try {
  306.             activity.startActivity(intent);
  307.         } catch (Exception e) {
  308.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  309.         }
  310.     }
  311.  
  312.     //android获取一个用于打开文本文件的intent
  313.     public static void Open_Text_File(Activity activity, File file) {
  314.         Intent intent = new Intent(Intent.ACTION_VIEW);
  315.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  316.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  317.         Uri uri = Uri.fromFile(file);
  318.         intent.setDataAndType(uri, "text/plain");
  319.         try {
  320.             activity.startActivity(intent);
  321.         } catch (Exception e) {
  322.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  323.         }
  324.     }
  325.  
  326.     //android获取一个用于打开音频文件的intent
  327.     public static void Open_Audio_File(Activity activity, File file) {
  328.         Intent intent = new Intent(Intent.ACTION_VIEW);
  329.         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  330.         intent.putExtra("oneshot", 0);
  331.         intent.putExtra("configchange", 0);
  332.         Uri uri = Uri.fromFile(file);
  333.         intent.setDataAndType(uri, "audio/*");
  334.         try {
  335.             activity.startActivity(intent);
  336.         } catch (Exception e) {
  337.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  338.         }
  339.     }
  340.  
  341.     //android获取一个用于打开视频文件的intent
  342.     public static void Open_Video_File(Activity activity,File file) {
  343.         Intent intent = new Intent(Intent.ACTION_VIEW);
  344.         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  345.         intent.putExtra("oneshot", 0);
  346.         intent.putExtra("configchange", 0);
  347.         Uri uri = Uri.fromFile(file);
  348.         intent.setDataAndType(uri, "video/*");
  349.         try {
  350.             activity.startActivity(intent);
  351.         } catch (Exception e) {
  352.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  353.         }
  354.     }
  355.  
  356.  
  357.     //android获取一个用于打开CHM文件的intent
  358.     public static void Open_Chm_File(Activity activity, File file) {
  359.         Intent intent = new Intent(Intent.ACTION_VIEW);
  360.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  361.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  362.         Uri uri = Uri.fromFile(file);
  363.         intent.setDataAndType(uri, "application/x-chm");
  364.         try {
  365.             activity.startActivity(intent);
  366.         } catch (Exception e) {
  367.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  368.         }
  369.     }
  370.  
  371.  
  372.     //android获取一个用于打开Word文件的intent
  373.     public static void Open_Word_File(Activity activity, File file) {
  374.         Intent intent = new Intent(Intent.ACTION_VIEW);
  375.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  376.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  377.         Uri uri = Uri.fromFile(file);
  378.         intent.setDataAndType(uri, "application/msword");
  379.         try {
  380.             activity.startActivity(intent);
  381.         } catch (Exception e) {
  382.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  383.         }
  384.     }
  385.  
  386.     //android获取一个用于打开Excel文件的intent
  387.     public static void Open_Excel_File(Activity activity, File file) {
  388.         Intent intent = new Intent(Intent.ACTION_VIEW);
  389.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  390.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  391.         Uri uri = Uri.fromFile(file);
  392.         intent.setDataAndType(uri, "application/vnd.ms-excel");
  393.         try {
  394.             activity.startActivity(intent);
  395.         } catch (Exception e) {
  396.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  397.         }
  398.     }
  399.  
  400.     //android获取一个用于打开PPT文件的intent
  401.     public static void Open_PPT_File(Activity activity,File file) {
  402.         Intent intent = new Intent(Intent.ACTION_VIEW);
  403.         intent.addCategory(Intent.CATEGORY_DEFAULT);
  404.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  405.         Uri uri = Uri.fromFile(file);
  406.         intent.setDataAndType(uri, "application/vnd.ms-powerpoint");
  407.         try {
  408.             activity.startActivity(intent);
  409.         } catch (Exception e) {
  410.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  411.         }
  412.     }
  413.  
  414.     //android获取一个用于打开apk文件的intent
  415.     public static void Open_Apk_File(Activity activity, File file) {
  416.         Intent intent = new Intent();
  417.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  418.         intent.setAction(android.content.Intent.ACTION_VIEW);
  419.         intent.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
  420.         try {
  421.             activity.startActivity(intent);
  422.         } catch (Exception e) {
  423.             ToastUtils.showToast("设备中没有安装支持该格式的程序");
  424.         }
  425.     }
  426.     /**
  427.      * 获取公共目录
  428.      *
  429.      * @param type DIRECTORY_MUSIC 音乐类型
  430.      *             DIRECTORY_RINGTONES 铃声类型
  431.      *             DIRECTORY_PODCASTS 播客音频类型
  432.      *             DIRECTORY_ALARMS 闹钟提示音类型
  433.      *             DIRECTORY_NOTIFICATIONS 通知提示音类型
  434.      *             DIRECTORY_PICTURES 图片类型
  435.      *             DIRECTORY_MOVIES 电影类型
  436.      *             DIRECTORY_DOWNLOADS 下载文件类型
  437.      *             DIRECTORY_DCIM 相机照片类型
  438.      *             DIRECTORY_DOCUMENTS 文档类型
  439.      * @return 相应类型目录文件
  440.      */
  441.     public File getExternalStoragePublicDirectory(String type) {
  442.         File file = Environment.getExternalStoragePublicDirectory(type);
  443.         if (!file.exists()) {
  444.             file.mkdir();
  445.         }
  446.         return file;
  447.     }
  448.  
  449.     public static String getTime(long time) {
  450. //        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  451.         SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
  452.         Date date = new Date(time);
  453.         String name = dateFormat.format(date);
  454.         return name;
  455.     }
  456.  
  457.     /**
  458.      * 获取文件指定文件的指定单位的大小
  459.      *
  460.      * @param filePath 文件路径
  461.      * @param sizeType 获取大小的类型1为B、2为KB、3为MB、4为GB
  462.      * @return double值的大小
  463.      */
  464.     public static double getFileOrFilesSize(String filePath, int sizeType) {
  465.         File file = new File(filePath);
  466.         long blockSize = 0;
  467.         try {
  468.             if (file.isDirectory()) {
  469.                 blockSize = getFileSizes(file);
  470.             } else {
  471.                 blockSize = getFileSize(file);
  472.             }
  473.         } catch (Exception e) {
  474.             e.printStackTrace();
  475.             Log_Ma.Companion.e("获取文件大小", "获取失败!");
  476.         }
  477.         return FormetFileSize(blockSize, sizeType);
  478.     }
  479.  
  480.     /**
  481.      * 获取指定文件夹
  482.      */
  483.     private static long getFileSizes(File f) throws Exception {
  484.         long size = 0;
  485.         File flist[] = f.listFiles();
  486.         for (int i = 0; i < flist.length; i++) {
  487.             if (flist[i].isDirectory()) {
  488.                 size = size + getFileSizes(flist[i]);
  489.             } else {
  490.                 size = size + getFileSize(flist[i]);
  491.             }
  492.         }
  493.         return size;
  494.     }
  495.  
  496.     /**
  497.      * 将long类型的数据转成相应大小的字符串
  498.      * <p>
  499.      * （例：30.05MB、1.25GB、40.87KB）
  500.      *
  501.      * @param fileS 参数
  502.      * @return 文件的大小描述
  503.      */
  504.     private static String FormetFileSize(long fileS) {
  505.         DecimalFormat df = new DecimalFormat("0.00");
  506.         String fileSizeString = "";
  507.         String wrongSize = "0B";
  508.         if (fileS == 0) {
  509.             return wrongSize;
  510.         }
  511.         if (fileS < 1024) {
  512.             fileSizeString = df.format((double) fileS) + "B";
  513.         } else if (fileS < 1048576) {
  514.             fileSizeString = df.format((double) fileS / 1024) + "KB";
  515.         } else if (fileS < 1073741824) {
  516.             fileSizeString = df.format((double) fileS / 1048576) + "MB";
  517.         } else {
  518.             fileSizeString = df.format((double) fileS / 1073741824) + "GB";
  519.         }
  520.         return fileSizeString;
  521.     }
  522.  
  523.     /**
  524.      * 转换文件大小,指定转换的类型
  525.      */
  526.     private static double FormetFileSize(long fileS, int sizeType) {
  527.         DecimalFormat df = new DecimalFormat("0.00");
  528.         double fileSizeLong = 0;
  529.         switch (sizeType) {
  530.             case SIZETYPE_B:
  531.                 fileSizeLong = Double.valueOf(df.format((double) fileS));
  532.                 break;
  533.             case SIZETYPE_KB:
  534.                 fileSizeLong = Double.valueOf(df.format((double) fileS / 1024));
  535.                 break;
  536.             case SIZETYPE_MB:
  537.                 fileSizeLong = Double.valueOf(df.format((double) fileS / 1048576));
  538.                 break;
  539.             case SIZETYPE_GB:
  540.                 fileSizeLong = Double.valueOf(df.format((double) fileS / 1073741824));
  541.                 break;
  542.             default:
  543.                 break;
  544.         }
  545.         return fileSizeLong;
  546.     }
  547.  
  548.     /**
  549.      * 将指定的文件按着给定的文件的字节数进行分割文件
  550.      *
  551.      * @param filepath 源文件的路径
  552.      * @param fileSize 指定的小文件的大小[MB] 0：默认等分4份
  553.      */
  554.     public static ArrayList<File> divide(String filepath, int fileSize) {
  555.         ArrayList<File> fileArrayList = new ArrayList<>();
  556.         if (!isExist(filepath)) {
  557.             ToastUtils.showToast("指定文件不存在");
  558.         } else {
  559.             FileInputStream in = null;
  560.             try {
  561.                 File file = new File(filepath);
  562.                 long fileLength = getFileSize(file);
  563.                 long size = fileSize * 1024 * 1024;// MB-->byte
  564.                 if (size <= 0) {
  565.                     size = fileLength / 4;
  566.                 }
  567.                 byte[] bytes = new byte[(int) size];
  568.                 // 取得被分割后的小文件的数目
  569.                 int num = (fileLength % size != 0) ? (int) (fileLength / size + 1) : (int) (fileLength / size);
  570.                 //输入文件流，即被分割的文件
  571.                 in = new FileInputStream(file);
  572.                 // 根据要分割的数目输出文件
  573.                 for (int i = 0; i < num; i++) {
  574.                     File outFile;
  575.                     try {
  576.                         //fixme 特殊分割字符需要添加\\
  577.                         String[] split = file.getName().split("\\.");
  578.                         if (split.length == 2) {
  579.                             outFile = new File(downpath, split[0] + "_" + i + ".part");
  580.                         } else {
  581.                             throw new Exception("");
  582.                         }
  583.                     } catch (Exception e) {
  584.                         outFile = new File(downpath, file.getName() + "_" + i + ".part");
  585.                     }
  586.                     if (outFile.exists()) {
  587.                         outFile.delete();
  588.                     }
  589.                     outFile.createNewFile();
  590.                     // 构建小文件的输出流
  591.                     FileOutputStream out = new FileOutputStream(outFile);
  592.                     out.write(bytes, 0, in.read(bytes));
  593.                     out.flush();
  594.                     out.close();
  595.                     fileArrayList.add(new File(outFile.getAbsolutePath()));
  596.                 }
  597.             } catch (Exception e) {
  598.                 Log_Ma.Companion.e("Error[divide]:", e.toString());
  599.             } finally {
  600.                 try {
  601.                     if (in != null) {
  602.                         in.close();
  603.                     }
  604.                 } catch (IOException e) {
  605.                     e.printStackTrace();
  606.                 }
  607.             }
  608.         }
  609.         return fileArrayList;
  610.     }
  611.  
  612.     /**
  613.      * @param filepath 源文件的路径
  614.      * @param destDir  目标文件夹
  615.      * @param fileSize 拆分大小【单位MB】
  616.      * @throws Exception
  617.      */
  618.     public static ArrayList<File> split(String filepath, String destDir, int fileSize) {
  619.         ArrayList<File> list = new ArrayList<>();
  620.         RandomAccessFile rand = null;
  621.         try {
  622.             // 创建文件对象
  623.             File src = new File(filepath);
  624.             File destFolder = new File(destDir);
  625.             if (!destFolder.exists()) {
  626.                 destFolder.mkdirs();
  627.             }
  628.             rand = new RandomAccessFile(src, "r");// 输入流
  629.             // 计算拆分后文件的: 个数
  630.             double size = fileSize * 1024 * 1024;// MB-->byte
  631.             int count = (int) Math.ceil(src.length() / size);
  632.  
  633.             byte[] buf = new byte[(int) size];
  634.             int len = 0;
  635.             for (int i = 1; i <= count; i++) {
  636.                 // 定义拆分后的文件
  637.                 File destFile;
  638.                 try {
  639.                     //fixme 特殊分割字符需要添加\\
  640.                     String[] split = src.getName().split("\\.");
  641.                     destFile = new File(destDir, split[0] + "_" + i + "." + split[1]);
  642.                 } catch (Exception e) {
  643.                     destFile = new File(destDir, src.getName() + "_" + i + ".mp4");
  644.                 }
  645.                 destFile.createNewFile();// 创建空的目标文件
  646.                 RandomAccessFile dest = new RandomAccessFile(destFile, "rw");// 输出流
  647.                 // 拷贝文件
  648.                 len = rand.read(buf);
  649.                 dest.write(buf, 0, len);
  650.                 dest.close();
  651.                 list.add(destFile);
  652.             }
  653.             return list;
  654.         } catch (Exception e) {
  655.             Log_Ma.Companion.e("Error[split]:", e.toString());
  656.             // 关闭资源
  657.             if (rand != null) {
  658.                 try {
  659.                     rand.close();
  660.                 } catch (IOException ex) {
  661.                     ex.printStackTrace();
  662.                 }
  663.             }
  664.             return list;
  665.         }
  666.     }
  667.  
  668.     //合并文件
  669.     public static void merge(String srcDir, String destDir) throws Exception {
  670.         // 多个输入流==>一个输出流
  671.         File src = new File(srcDir);
  672.         File[] files = src.listFiles();
  673.         Arrays.sort(files, new Comparator<File>() {
  674.  
  675.             public int compare(File f1, File f2) {
  676.                 int index = f1.getName().lastIndexOf(".part");
  677.                 int num = Integer.parseInt(f1.getName().substring(index + 5));
  678.                 int index2 = f2.getName().lastIndexOf(".part");
  679.                 int num2 = Integer.parseInt(f2.getName().substring(index2 + 5));
  680.  
  681.                 return num - num2;
  682.             }
  683.         });
  684.         String formerName = "";
  685.         for (File f : files) {
  686.             if (f.isFile() && f.getName().lastIndexOf(".part") != -1) {
  687.                 formerName = f.getName().replaceAll(".part\\d", "");
  688.                 break;
  689.             }
  690.         }
  691.         // 创建:一个输入流
  692.         File formerFile = new File(destDir, formerName);
  693.         System.out.println("原文件名===" + formerName);
  694.  
  695.         File parentFile = formerFile.getParentFile();
  696.         if (!parentFile.exists()) {
  697.             parentFile.mkdirs();// 创建父目录
  698.         }
  699.         if (!formerFile.exists()) {
  700.             formerFile.createNewFile();
  701.         }
  702.         RandomAccessFile randTo = new RandomAccessFile(formerFile, "rw");// 输入流
  703.  
  704.         // 创建:多个输出流
  705.         byte[] buf = new byte[1024];
  706.         int len = 0;
  707.         for (File f : files) {
  708.             if (f.isFile() && f.getName().lastIndexOf(".part") != -1) {
  709.                 System.out.println("merge拆分的文件----" + f.getName());
  710.                 ;
  711.                 RandomAccessFile source = new RandomAccessFile(f, "r");// 输入流
  712.                 while ((len = source.read(buf)) != -1) {
  713.                     randTo.write(buf, 0, len);
  714.                 }
  715.                 source.close();// 关闭资源
  716.             }
  717.         }
  718.         randTo.close();// 关闭资源
  719.         System.out.println("merge ok...");
  720.     }
  721. /**
  722.      * 通知android媒体库更新文件夹
  723.      *
  724.      * @param filePath ilePath 文件绝对路径，、/sda/aaa/jjj.jpg
  725.      */
  726.     public static void scanFile(Context context, String filePath) {
  727.         try {
  728.             MediaScannerConnection.scanFile(context, new String[]{filePath}, null,
  729.                     new MediaScannerConnection.OnScanCompletedListener() {
  730.                         public void onScanCompleted(String path, Uri uri) {
  731.                             Log.i("*******", "Scanned " + path + ":");
  732.                             Log.i("*******", "-> uri=" + uri);
  733.                         }
  734.                     });
  735.         } catch (Exception e) {
  736.             e.printStackTrace();
  737.         }
  738.     }
  739.     /**
  740.      * Uri转file文件
  741.      */
  742.     public static File getFile(Activity activity, Uri uri) {
  743.         String[] arr = {MediaStore.Images.Media.DATA};
  744.         Cursor cursor = activity.getContentResolver().query(uri, arr, null, null, null);
  745.         int imgIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
  746.         cursor.moveToFirst();
  747.         String imgPath = cursor.getString(imgIndex);
  748.         File file = new File(imgPath);
  749.         return file;
  750.     }
  751. }
  1. /**
  2.      * Uri转file文件
  3.      */
  4.     public static File getFile(Activity activity, Uri uri) {
  5.         String[] arr = {MediaStore.Images.Media.DATA};
  6.         Cursor cursor = activity.getContentResolver().query(uri, arr, null, null, null);
  7.         int imgIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
  8.         cursor.moveToFirst();
  9.         String imgPath = cursor.getString(imgIndex);
  10.         File file = new File(imgPath);
  11.         return file;
  12.     }

 

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号