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

Posted 2020-06-13

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

打开手机设置，选择应用管理，选择任意一个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