彻底理解android中的内部存储与外部存储

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了彻底理解android中的内部存储与外部存储相关的知识,希望对你有一定的参考价值。

我们先来考虑这样一个问题:

打开手机设置,选择应用管理,选择任意一个App,然后你会看到两个按钮,一个是清除缓存,另一个是清除数据,那么当我们点击清除缓存的时候清除的是哪里的数据?当我们点击清除数据的时候又是清除的哪里的数据?读完本文相信你会有答案。

android开发中我们常常听到这样几个概念,内存,内部存储,外部存储,很多人常常将这三个东西搞混,那么我们今天就先来详细说说这三个东西是怎么回事?

内存,我们在英文中称作memory,内部存储,我们称为InternalStorage,外部存储我们称为ExternalStorage,这在英文中本不会产生歧义,但是当我们翻译为中文之后,前两个都简称为内存,于是,混了。

那么究竟什么是内部存储什么是外部存储呢?

首先我们打开DDMS,有一个File Explorer,如下:

技术分享

这里有三个文件夹需要我们重视,一个是data,一个是mnt,一个是storage,我们下面就详细说说这三个文件夹。

1.内部存储

data文件夹就是我们常说的内部存储,当我们打开data文件夹之后(没有root的手机不能打开该文件夹),里边有两个文件夹值得我们关注,如下:

技术分享

一个文件夹是app文件夹,还有一个文件夹就是data文件夹,app文件夹里存放着我们所有安装的app的apk文件,其实,当我们调试一个app的时候,可以看到控制台输出的内容,有一项是uploading .....就是上传我们的apk到这个文件夹,上传成功之后才开始安装。另一个重要的文件夹就是data文件夹了,这个文件夹里边都是一些包名,打开这些包名之后我们会看到这样的一些文件:

1.data/data/包名/shared_prefs
2.data/data/包名/databases
3.data/data/包名/files

4.data/data/包名/cache

如果打开过data文件,应该都知道这些文件夹是干什么用的,我们在使用sharedPreferenced的时候,将数据持久化存储于本地,其实就是存在这个文件中的xml文件里,我们App里边的数据库文件就存储于databases文件夹中,还有我们的普通数据存储在files中,缓存文件存储在cache文件夹中,存储在这里的文件我们都称之为内部存储。

2.外部存储

外部存储才是我们平时操作最多的,外部存储一般就是我们上面看到的storage文件夹,当然也有可能是mnt文件夹,这个不同厂家有可能不一样。

一般来说,在storage文件夹中有一个sdcard文件夹,这个文件夹中的文件又分为两类,一类是公有目录,还有一类是私有目录,其中的公有目录有九大类,比如DCIM、DOWNLOAD等这种系统为我们创建的文件夹,私有目录就是Android这个文件夹,这个文件夹打开之后里边有一个data文件夹,打开这个data文件夹,里边有许多包名组成的文件夹。

 

说到这里,我想大家应该已经可以分清楚什么是内部存储什么是外部存储了吧?好,分清楚之后我们就要看看怎么来操作内部存储和外部存储了。

3.操作存储空间

首先,经过上面的分析,大家已经明白了,什么是内部存储,什么是外部存储,以及这两种存储方式分别存储在什么位置,一般来说,我们不会自己去操作内部存储空间,没有root权限的话,我们也没法操作内部存储空间,事实上内部存储主要是由系统来维护的。不过在代码中我们是可以访问到这个文件夹的。由于内部存储空间有限,在开发中我们一般都是操作外部存储空间,Google官方建议我们App的数据应该存储在外部存储的私有目录中该App的包名下,这样当用户卸载掉App之后,相关的数据会一并删除,如果你直接在/storage/sdcard目录下创建了一个应用的文件夹,那么当你删除应用的时候,这个文件夹就不会被删除。

经过以上的介绍,我们可以总结出下面一个表格:

技术分享

一目了然,什么是内部存储,什么是外部存储。

如果按照路径的特征,我们又可以将文件存储的路径分为两大类,一类是路径中含有包名的,一类是路径中不含有包名的,含有包名的路径,因为和某个App有关,所以对这些文件夹的访问都是调用Context里边的方法,而不含有包名的路径,和某一个App无关,我们可以通过Environment中的方法来访问。如下图:

技术分享

大家看到,有包名的路径我们都是调用Context中的方法来获得,没有包名的路径,我们直接调用Environment中的方法获得,那么其中有两个方法需要传入一个String类型的参数,这个参数我们使用了Environment中的常量,参数的意思是我们要访问这个路径下的哪个文件夹,比如getExternalFilesDir方法,我们看看它的源码:

 

[java] view plain?
  1. /** 
  2.  * 
  3.  * @param type The type of files directory to return.  May be null for 
  4.  * the root of the files directory or one of 
  5.  * the following Environment constants for a subdirectory: 
  6.  * {@link android.os.Environment#DIRECTORY_MUSIC}, 
  7.  * {@link android.os.Environment#DIRECTORY_PODCASTS}, 
  8.  * {@link android.os.Environment#DIRECTORY_RINGTONES}, 
  9.  * {@link android.os.Environment#DIRECTORY_ALARMS}, 
  10.  * {@link android.os.Environment#DIRECTORY_NOTIFICATIONS}, 
  11.  * {@link android.os.Environment#DIRECTORY_PICTURES}, or 
  12.  * {@link android.os.Environment#DIRECTORY_MOVIES}. 
  13.  * 
  14.  * @return The path of the directory holding application files 
  15.  * on external storage.  Returns null if external storage is not currently 
  16.  * mounted so it could not ensure the path exists; you will need to call 
  17.  * this method again when it is available. 
  18.  * 
  19.  * @see #getFilesDir 
  20.  * @see android.os.Environment#getExternalStoragePublicDirectory 
  21.  */  
  22. @Nullable  
  23. public abstract File getExternalFilesDir(@Nullable String type);  

它的注释非常多,我这里只列出其中一部分,我们看到,我们可以访问files文件夹下的Music文件夹、Movies文件夹等等好几种。

 

说到这里,我想大家对内部存储、外部存储该有了一个清晰的认识了吧。我们在开发中,不建议往内部存储中写太多的数据,毕竟空间有限。外部存储在使用的时候最好能够将文件存放在私有目录下,这样有利于系统维护,也避免用户的反感。

现在我们再来看看我们一开始提出的问题,当我们点击清除数据的时候清除的是哪里的数据呢?毫无疑问,当然是内部存储目录中相应的files和cache文件夹中的文件和外部存储中相应的files和cache文件夹中的文件,至于这些文件夹的路径我想你应该已经明白了。

 

 

好了,最后再送给大家一个文件操作工具类:

 

[java] view plain?
  1. public class SDCardHelper {  
  2.   
  3.     // 判断SD卡是否被挂载  
  4.     public static boolean isSDCardMounted() {  
  5.         // return Environment.getExternalStorageState().equals("mounted");  
  6.         return Environment.getExternalStorageState().equals(  
  7.                 Environment.MEDIA_MOUNTED);  
  8.     }  
  9.   
  10.     // 获取SD卡的根目录  
  11.     public static String getSDCardBaseDir() {  
  12.         if (isSDCardMounted()) {  
  13.             return Environment.getExternalStorageDirectory().getAbsolutePath();  
  14.         }  
  15.         return null;  
  16.     }  
  17.   
  18.     // 获取SD卡的完整空间大小,返回MB  
  19.     public static long getSDCardSize() {  
  20.         if (isSDCardMounted()) {  
  21.             StatFs fs = new StatFs(getSDCardBaseDir());  
  22.             long count = fs.getBlockCountLong();  
  23.             long size = fs.getBlockSizeLong();  
  24.             return count * size / 1024 / 1024;  
  25.         }  
  26.         return 0;  
  27.     }  
  28.   
  29.     // 获取SD卡的剩余空间大小  
  30.     public static long getSDCardFreeSize() {  
  31.         if (isSDCardMounted()) {  
  32.             StatFs fs = new StatFs(getSDCardBaseDir());  
  33.             long count = fs.getFreeBlocksLong();  
  34.             long size = fs.getBlockSizeLong();  
  35.             return count * size / 1024 / 1024;  
  36.         }  
  37.         return 0;  
  38.     }  
  39.   
  40.     // 获取SD卡的可用空间大小  
  41.     public static long getSDCardAvailableSize() {  
  42.         if (isSDCardMounted()) {  
  43.             StatFs fs = new StatFs(getSDCardBaseDir());  
  44.             long count = fs.getAvailableBlocksLong();  
  45.             long size = fs.getBlockSizeLong();  
  46.             return count * size / 1024 / 1024;  
  47.         }  
  48.         return 0;  
  49.     }  
  50.   
  51.     // 往SD卡的公有目录下保存文件  
  52.     public static boolean saveFileToSDCardPublicDir(byte[] data, String type,  
  53.             String fileName) {  
  54.         BufferedOutputStream bos = null;  
  55.         if (isSDCardMounted()) {  
  56.             File file = Environment.getExternalStoragePublicDirectory(type);  
  57.             try {  
  58.                 bos = new BufferedOutputStream(new FileOutputStream(new File(  
  59.                         file, fileName)));  
  60.                 bos.write(data);  
  61.                 bos.flush();  
  62.                 return true;  
  63.             } catch (Exception e) {  
  64.                 e.printStackTrace();  
  65.             } finally {  
  66.                 try {  
  67.                     bos.close();  
  68.                 } catch (IOException e) {  
  69.                     // TODO Auto-generated catch block  
  70.                     e.printStackTrace();  
  71.                 }  
  72.             }  
  73.         }  
  74.         return false;  
  75.     }  
  76.   
  77.     // 往SD卡的自定义目录下保存文件  
  78.     public static boolean saveFileToSDCardCustomDir(byte[] data, String dir,  
  79.             String fileName) {  
  80.         BufferedOutputStream bos = null;  
  81.         if (isSDCardMounted()) {  
  82.             File file = new File(getSDCardBaseDir() + File.separator + dir);  
  83.             if (!file.exists()) {  
  84.                 file.mkdirs();// 递归创建自定义目录  
  85.             }  
  86.             try {  
  87.                 bos = new BufferedOutputStream(new FileOutputStream(new File(  
  88.                         file, fileName)));  
  89.                 bos.write(data);  
  90.                 bos.flush();  
  91.                 return true;  
  92.             } catch (Exception e) {  
  93.                 e.printStackTrace();  
  94.             } finally {  
  95.                 try {  
  96.                     bos.close();  
  97.                 } catch (IOException e) {  
  98.                     // TODO Auto-generated catch block  
  99.                     e.printStackTrace();  
  100.                 }  
  101.             }  
  102.         }  
  103.         return false;  
  104.     }  
  105.   
  106.     // 往SD卡的私有Files目录下保存文件  
  107.     public static boolean saveFileToSDCardPrivateFilesDir(byte[] data,  
  108.             String type, String fileName, Context context) {  
  109.         BufferedOutputStream bos = null;  
  110.         if (isSDCardMounted()) {  
  111.             File file = context.getExternalFilesDir(type);  
  112.             try {  
  113.                 bos = new BufferedOutputStream(new FileOutputStream(new File(  
  114.                         file, fileName)));  
  115.                 bos.write(data);  
  116.                 bos.flush();  
  117.                 return true;  
  118.             } catch (Exception e) {  
  119.                 e.printStackTrace();  
  120.             } finally {  
  121.                 try {  
  122.                     bos.close();  
  123.                 } catch (IOException e) {  
  124.                     // TODO Auto-generated catch block  
  125.                     e.printStackTrace();  
  126.                 }  
  127.             }  
  128.         }  
  129.         return false;  
  130.     }  
  131.   
  132.     // 往SD卡的私有Cache目录下保存文件  
  133.     public static boolean saveFileToSDCardPrivateCacheDir(byte[] data,  
  134.             String fileName, Context context) {  
  135.         BufferedOutputStream bos = null;  
  136.         if (isSDCardMounted()) {  
  137.             File file = context.getExternalCacheDir();  
  138.             try {  
  139.                 bos = new BufferedOutputStream(new FileOutputStream(new File(  
  140.                         file, fileName)));  
  141.                 bos.write(data);  
  142.                 bos.flush();  
  143.                 return true;  
  144.             } catch (Exception e) {  
  145.                 e.printStackTrace();  
  146.             } finally {  
  147.                 try {  
  148.                     bos.close();  
  149.                 } catch (IOException e) {  
  150.                     // TODO Auto-generated catch block  
  151.                     e.printStackTrace();  
  152.                 }  
  153.             }  
  154.         }  
  155.         return false;  
  156.     }  
  157.   
  158.     // 保存bitmap图片到SDCard的私有Cache目录  
  159.     public static boolean saveBitmapToSDCardPrivateCacheDir(Bitmap bitmap,  
  160.             String fileName, Context context) {  
  161.         if (isSDCardMounted()) {  
  162.             BufferedOutputStream bos = null;  
  163.             // 获取私有的Cache缓存目录  
  164.             File file = context.getExternalCacheDir();  
  165.   
  166.             try {  
  167.                 bos = new BufferedOutputStream(new FileOutputStream(new File(  
  168.                         file, fileName)));  
  169.                 if (fileName != null  
  170.                         && (fileName.contains(".png") || fileName  
  171.                                 .contains(".PNG"))) {  
  172.                     bitmap.compress(Bitmap.CompressFormat.PNG, 100, bos);  
  173.                 } else {  
  174.                     bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);  
  175.                 }  
  176.                 bos.flush();  
  177.             } catch (Exception e) {  
  178.                 e.printStackTrace();  
  179.             } finally {  
  180.                 if (bos != null) {  
  181.                     try {  
  182.                         bos.close();  
  183.                     } catch (IOException e) {  
  184.                         e.printStackTrace();  
  185.                     }  
  186.                 }  
  187.             }  
  188.             return true;  
  189.         } else {  
  190.             return false;  
  191.         }  
  192.     }  
  193.   
  194.     // 从SD卡获取文件  
  195.     public static byte[] loadFileFromSDCard(String fileDir) {  
  196.         BufferedInputStream bis = null;  
  197.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  198.   
  199.         try {  
  200.             bis = new BufferedInputStream(  
  201.                     new FileInputStream(new File(fileDir)));  
  202.             byte[] buffer = new byte[8 * 1024];  
  203.             int c = 0;  
  204.             while ((c = bis.read(buffer)) != -1) {  
  205.                 baos.write(buffer, 0, c);  
  206.                 baos.flush();  
  207.             }  
  208.             return baos.toByteArray();  
  209.         } catch (Exception e) {  
  210.             e.printStackTrace();  
  211.         } finally {  
  212.             try {  
  213.                 baos.close();  
  214.                 bis.close();  
  215.             } catch (IOException e) {  
  216.                 e.printStackTrace();  
  217.             }  
  218.         }  
  219.         return null;  
  220.     }  
  221.   
  222.     // 从SDCard中寻找指定目录下的文件,返回Bitmap  
  223.     public Bitmap loadBitmapFromSDCard(String filePath) {  
  224.         byte[] data = loadFileFromSDCard(filePath);  
  225.         if (data != null) {  
  226.             Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length);  
  227.             if (bm != null) {  
  228.                 return bm;  
  229.             }  
  230.         }  
  231.         return null;  
  232.     }  
  233.   
  234.     // 获取SD卡公有目录的路径  
  235.     public static String getSDCardPublicDir(String type) {  
  236.         return Environment.getExternalStoragePublicDirectory(type).toString();  
  237.     }  
  238.   
  239.     // 获取SD卡私有Cache目录的路径  
  240.     public static String getSDCardPrivateCacheDir(Context context) {  
  241.         return context.getExternalCacheDir().getAbsolutePath();  
  242.     }  
  243.   
  244.     // 获取SD卡私有Files目录的路径  
  245.     public static String getSDCardPrivateFilesDir(Context context, String type) {  
  246.         return context.getExternalFilesDir(type).getAbsolutePath();  
  247.     }  
  248.   
  249.     public static boolean isFileExist(String filePath) {  
  250.         File file = new File(filePath);  
  251.         return file.isFile();  
  252.     }  
  253.   
  254.     // 从sdcard中删除文件  
  255.     public static boolean removeFileFromSDCard(String filePath) {  
  256.         File file = new File(filePath);  
  257.         if (file.exists()) {  
  258.             try {  
  259.                 file.delete();  
  260.                 return true;  
  261.             } catch (Exception e) {  
  262.                 return false;  
  263.             }  
  264.         } else {  
  265.             return false;  
  266.         }  
  267.     }  
  268. }  


本文相关笔记和源码下载http://download.csdn.net/detail/u012702547/9348985

以上是关于彻底理解android中的内部存储与外部存储的主要内容,如果未能解决你的问题,请参考以下文章

android内部存储与外部存储理解

Android中的内部存储与外部存储

Android 文件保存

android内部存储与外部存储

安卓内外部存储完全解析 -- 别再弄混了

将文件从内部存储复制到Android中的外部存储