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

最新推荐文章于 2024-05-20 13:56:25 发布
最新推荐文章于 2024-05-20 13:56:25 发布
阅读量334 收藏
点赞数

http://www.androidchina.net/4106.html

http://www.androidchina.net/4106.html

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

打开手机设置，选择应用管理，选择任意一个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方法，我们看看它的源码：

/**
*
* @param type The type of files directory to return.  May be null for
* the root of the files directory or one of
* the following Environment constants for a subdirectory:
* {@link android.os.Environment#DIRECTORY_MUSIC},
* {@link android.os.Environment#DIRECTORY_PODCASTS},
* {@link android.os.Environment#DIRECTORY_RINGTONES},
* {@link android.os.Environment#DIRECTORY_ALARMS},
* {@link android.os.Environment#DIRECTORY_NOTIFICATIONS},
* {@link android.os.Environment#DIRECTORY_PICTURES}, or
* {@link android.os.Environment#DIRECTORY_MOVIES}.
*
* @return The path of the directory holding application files
* on external storage.  Returns null if external storage is not currently
* mounted so it could not ensure the path exists; you will need to call
* this method again when it is available.
*
* @see #getFilesDir
* @see android.os.Environment#getExternalStoragePublicDirectory
*/
@Nullable
public  abstract  File getExternalFilesDir( @Nullable  String type);

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

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

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

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

public  class  SDCardHelper {
 
      // 判断SD卡是否被挂载
      public  static  boolean  isSDCardMounted() {
          // return Environment.getExternalStorageState().equals("mounted");
          return  Environment.getExternalStorageState().equals(
          Environment.MEDIA_MOUNTED);
     }
 
     // 获取SD卡的根目录
     public  static  String getSDCardBaseDir() {
          if  (isSDCardMounted()) {
                return  Environment.getExternalStorageDirectory().getAbsolutePath();
          }
          return  null ;
     }
 
     // 获取SD卡的完整空间大小，返回MB
     public  static  long  getSDCardSize() {
          if  (isSDCardMounted()) {
               StatFs fs =  new  StatFs(getSDCardBaseDir());
               long  count = fs.getBlockCountLong();
               long  size = fs.getBlockSizeLong();
               return  count * size /  1024  /  1024 ;
          }
          return  0 ;
     }
 
     // 获取SD卡的剩余空间大小
     public  static  long  getSDCardFreeSize() {
          if  (isSDCardMounted()) {
                StatFs fs =  new  StatFs(getSDCardBaseDir());
                long  count = fs.getFreeBlocksLong();
                long  size = fs.getBlockSizeLong();
                return  count * size /  1024  /  1024 ;
          }
          return  0 ;
     }
 
     // 获取SD卡的可用空间大小
     public  static  long  getSDCardAvailableSize() {
          if  (isSDCardMounted()) {
                StatFs fs =  new  StatFs(getSDCardBaseDir());
                long  count = fs.getAvailableBlocksLong();
                long  size = fs.getBlockSizeLong();
                return  count * size /  1024  /  1024 ;
          }
          return  0 ;
     }
 
     // 往SD卡的公有目录下保存文件
     public  static  boolean  saveFileToSDCardPublicDir( byte [] data, String type, String fileName) {
          BufferedOutputStream bos =  null ;
          if  (isSDCardMounted()) {
                File file = Environment.getExternalStoragePublicDirectory(type);
                try  {
                     bos =  new  BufferedOutputStream( new  FileOutputStream( new  File(file, fileName)));
                     bos.write(data);
                     bos.flush();
                     return  true ;
                }  catch  (Exception e) {
                     e.printStackTrace();
                }  finally  {
                     try  {
                           bos.close();
                     }  catch  (IOException e) {
                           // TODO Auto-generated catch block
                           e.printStackTrace();
                     }
                }
           }
           return  false ;
      }
 
      // 往SD卡的自定义目录下保存文件
      public  static  boolean  saveFileToSDCardCustomDir( byte [] data, String dir, String fileName) {
           BufferedOutputStream bos =  null ;
           if  (isSDCardMounted()) {
                 File file =  new  File(getSDCardBaseDir() + File.separator + dir);
                 if  (!file.exists()) {
                       file.mkdirs(); // 递归创建自定义目录
                 }
                 try  {
                       bos =  new  BufferedOutputStream( new  FileOutputStream( new  File(file, fileName)));
                       bos.write(data);
                       bos.flush();
                       return  true ;
                 }  catch  (Exception e) {
                       e.printStackTrace();
                 }  finally  {
                       try  {
                             bos.close();
                       }  catch  (IOException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                       }
                 }
            }
            return  false ;
      }
 
      // 往SD卡的私有Files目录下保存文件
      public  static  boolean  saveFileToSDCardPrivateFilesDir( byte [] data, String type, String fileName, Context context) {
          BufferedOutputStream bos =  null ;
          if  (isSDCardMounted()) {
                File file = context.getExternalFilesDir(type);
                try  {
                       bos =  new  BufferedOutputStream( new  FileOutputStream( new  File(file, fileName)));
                       bos.write(data);
                       bos.flush();
                       return  true ;
                }  catch  (Exception e) {
                       e.printStackTrace();
                }  finally  {
                       try  {
                             bos.close();
                       }  catch  (IOException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                       }
                }
           }
           return  false ;
      }
 
      // 往SD卡的私有Cache目录下保存文件
      public  static  boolean  saveFileToSDCardPrivateCacheDir( byte [] data, String fileName, Context context) {
           BufferedOutputStream bos =  null ;
           if  (isSDCardMounted()) {
                 File file = context.getExternalCacheDir();
                 try  {
                       bos =  new  BufferedOutputStream( new  FileOutputStream( new  File(file, fileName)));
                       bos.write(data);
                       bos.flush();
                       return  true ;
                 }  catch  (Exception e) {
                       e.printStackTrace();
                 }  finally  {
                       try  {
                             bos.close();
                       }  catch  (IOException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                       }
                }
           }
           return  false ;
      }
 
      // 保存bitmap图片到SDCard的私有Cache目录
      public  static  boolean  saveBitmapToSDCardPrivateCacheDir(Bitmap bitmap, String fileName, Context context) {
           if  (isSDCardMounted()) {
                 BufferedOutputStream bos =  null ;
                 // 获取私有的Cache缓存目录
                 File file = context.getExternalCacheDir();
 
                 try  {
                        bos =  new  BufferedOutputStream( new  FileOutputStream( new  File(file, fileName)));
                        if  (fileName !=  null && (fileName.contains( ".png" ) || fileName.contains( ".PNG" ))) {
                               bitmap.compress(Bitmap.CompressFormat.PNG,  100 , bos);
                        }  else  {
                               bitmap.compress(Bitmap.CompressFormat.JPEG,  100 , bos);
                        }
                        bos.flush();
                 }  catch  (Exception e) {
                        e.printStackTrace();
                 }  finally  {
                        if  (bos !=  null ) {
                             try  {
                                  bos.close();
                             }  catch  (IOException e) {
                                  e.printStackTrace();
                             }
                        }
                  }
                  return  true ;
           }  else  {
                 return  false ;
           }
      }
 
      // 从SD卡获取文件
      public  static  byte [] loadFileFromSDCard(String fileDir) {
           BufferedInputStream bis =  null ;
           ByteArrayOutputStream baos =  new  ByteArrayOutputStream();
 
           try  {
                 bis =  new  BufferedInputStream( new  FileInputStream( new  File(fileDir)));
                 byte [] buffer =  new  byte [ 8  *  1024 ];
                 int  c =  0 ;
                 while  ((c = bis.read(buffer)) != - 1 ) {
                      baos.write(buffer,  0 , c);
                      baos.flush();
                 }
                 return  baos.toByteArray();
           }  catch  (Exception e) {
                 e.printStackTrace();
           }  finally  {
                 try  {
                      baos.close();
                      bis.close();
                 }  catch  (IOException e) {
                      e.printStackTrace();
                 }
           }
           return  null ;
      }
 
      // 从SDCard中寻找指定目录下的文件，返回Bitmap
      public  Bitmap loadBitmapFromSDCard(String filePath) {
           byte [] data = loadFileFromSDCard(filePath);
           if  (data !=  null ) {
                Bitmap bm = BitmapFactory.decodeByteArray(data,  0 , data.length);
                if  (bm !=  null ) {
                      return  bm;
                }
           }
           return  null ;
      }
 
      // 获取SD卡公有目录的路径
      public  static  String getSDCardPublicDir(String type) {
           return  Environment.getExternalStoragePublicDirectory(type).toString();
      }
 
      // 获取SD卡私有Cache目录的路径
      public  static  String getSDCardPrivateCacheDir(Context context) {
           return  context.getExternalCacheDir().getAbsolutePath();
      }
 
      // 获取SD卡私有Files目录的路径
      public  static  String getSDCardPrivateFilesDir(Context context, String type) {
           return  context.getExternalFilesDir(type).getAbsolutePath();
      }
 
      public  static  boolean  isFileExist(String filePath) {
           File file =  new  File(filePath);
           return  file.isFile();
      }
 
      // 从sdcard中删除文件
      public  static  boolean  removeFileFromSDCard(String filePath) {
           File file =  new  File(filePath);
           if  (file.exists()) {
                try  {
                      file.delete();
                      return  true ;
                }  catch  (Exception e) {
                      return  false ;
                }
           }  else  {
                return  false ;
           }
      }
}
本文相关笔记和源码下载http://download.csdn.net/detail/u012702547/9348985


含着泪笑
关注
android拷贝数据到外部存储,Android复制数据库从内部存储到外部存储
weixin_28222493的博客
05-27 829
此程序可以将名为“您的数据库名称”的数据库从Android应用程序的内部存储复制到外部存储。它创建一个名为“文件夹名称”的文件夹，然后将数据库复制到该文件夹​​中名为“备份数据库名称”的文件中这个程序兼容android marshmallow2.使用MediaScannerConnection时，您可以立即从具有Windows操作系统的计算机复制备份文件，而无需重新启动系统。3.如果“文件夹名称”...
08读取内部存储空间大小
10-12
08读取内部存储空间大小，代码简洁，注释详细
AndroidQ沙盒机制之分区存储适配
08-19
主要介绍了AndroidQ沙盒机制之分区存储适配，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
内存储与外存储（IO流的应用）
weixin_33721344的博客
08-15 90
存储分为内存储，外存储（Sd卡存储），其中还涉及IO流的应用。 我们先来看内存储，在布局中EditView中输入的内容，通过点击按钮，分别进行保存，读取，删除的操作，读取时显示在下面的TextView中。 布局如下： <?xml version="1.0" encoding="utf-8"?><RelativeLayout xmlns:android="http://sch...
Android内部存储与外部存储
最新发布
顺其自然~专栏
05-20 681
另外，因为“内部存储”对用户来说是不可见的（需 ROOT 权限），如果你希望比较方便地浏览或操作应用的某些数据，那么就应该选择将这类数据存储到“外部存储”的“私有目录”或“其他目录”。应用程序在 Android 系统运行过程中产生的用户数据、日志、下载的图片、文件等都需要存储在 Android 系统提供的存储空间里，所以有必要了解 Android 系统下存储空间的概念、分类、特点以及使用方法，在实际应用中采用适合的方式保存数据。），并且目录名称就是该应用的包名，所以每个应用都有专属的内部存储目录。
Android的内部存储和外部存储
shengjiaxin的博客
03-13 3191
Android内部存储和外部存储
Android中的内部存储和外部存储
09-09
总的来说，内部存储和外部存储在Android中各有其适用场景。内部存储适合保存私密数据，保证应用的数据安全；外部存储则适用于大文件和需要共享的数据。理解这两种存储方式的差异和使用方法，可以帮助开发者更高效、...
Android App将数据写入内部存储和外部存储的示例
09-02
总结起来，Android应用可以通过内部存储来保存私有数据，而外部存储则用于存储需要与其他应用或用户共享的数据。正确地使用这两种存储方式，可以有效地管理应用程序的数据，并确保数据的安全性和可访问性。
Android 8.0 读取内部和外部存储以及外置SDcard的方法
08-27
在 Android 8.0 中，读取内部和外部存储空间的方法需要申请权限。 1. App 私有目录 app 自己的私有目录是/data/data/目录>，读写这个目录不需要单独的权限。每个 app 均只能读写自己的目录，而不能读写其他 app 的...
Android文件存储：内部存储，外部存储及其路径
01-03
Android系统数据存储分为内部存储和外部存储，内部存储是手机系统自带的存储，一般空间都不大，外部存储一般是SD卡的存储，空间一般都比较大。一般我们会把存储内容放在外部存储空间里。在使用过程需要注意事项： 先...
浅析Android 内部存储&&外部存储区别
Name Yan
03-28 3503
浅析Android 内部存储&&外部存储区别
storage/emulated/0是什么？
m0_38094058的博客
11-06 14万+
storage/emulated/0 是手机内部存储根目录 个人总结： 手机内部存储是storage/emulated/0，而手机SD卡的存储是storage/emulated/1 前面部分不一定相同 (如果本人理解有误，希望大家能指出 谢谢) RAM表示手机的运行内存 ROM是手机的存储内存，相当于电脑的硬盘 Android开发中容易混淆的是内部存储和外部储存(这个内部存储和外部存储不要跟上面...
Android 手机存储及路径
ezconn的博客
11-28 3万+
Android手机存储分类 分为：内部存储和外部存储 如何区分内部存储和外部存储：可以从物理和逻辑区分 从物理的角度区分，内部存储就是手机自带存储空间，外部存储就是外部接入的存储空间例如SD卡 从逻辑意义上区分，data，system 目录就是手机的内部存储，而 mnt 或者 storage目录下的sdcard0指向的sdcard目录就是外部存储。如果是手机自带的外部存储被称为机身外部存储...
storage/emulated/0.到底在哪儿
热门推荐
gislaozhang
07-31 20万+
问题： 通过logcat读出的sdcard根目录的路径名是/storage/emulated/0/. 但是我不知道这个路径到底是在哪儿？ 解答： android的API的得到的就是/storage/emulated/0/，这个路径我们用的时候一般直接进/sdcard/或者/mnt/sdcard/，其实是一个相同的位置； 通过Device File Explorer查找到/mnt/sd...
Android存储分类，内部存储、外部存储的区别
qq_41904106的博客
07-16 1588
前言   本文大量借鉴一位大佬的博客解析Android内部存储、外部存储的区别   本文仅作为个人学习记录，如有错误，欢迎指正，非常感谢。   Android项目开发必定使用到本地存储一些应用相关的数据，以及访问其他应用或者系统自带的公有共享文件（比如手机相册的图片）。所以对于内部存储和外部存储需要格外熟悉。 Android物理存储上目录的划分   Android系统采用的Linux内核，所以数据存储的目录也和Linux系统相似，一般文件目录如下图所示： 1.内部存储：   /data/data/ (黄线
android基础总结-内部存储和外部存储的大局观
sjy0118的博客
12-05 5268
开胃菜—android的存储题： 1.SharedPreferences和SQLite的数据存储路径，怎么获取，存在什么位置？ 2.今年android主流机型支持双卡，小卡的位置支持扩展第二张SD卡，那么，用代码如何区分内置/扩展SD卡的路径？ 3.用Environment操作创建的路径文件，会不会污染SD卡？一android中存储操作的相关类关于android存储操作，一般就是路径的操作，比
Android内、外存储 易混淆点剖析（/mnt/sdcard、/storage/sdcard0、/storage/emulated/0等区别）
u010227042的博客
03-30 1万+
向原创者致敬！自己感觉好转载了！ 说起Android“内部存储”，对于开发者而言可以毫不犹豫地脱口而出，不就是/data/data目录嘛，也不尽然，/data/user/0/又如何解释？那说起“外部存储”，例如sd卡目录获取值，更是众说纷纭，是/mnt/sdcard？还是/storage/sdcard0？莫非是/storage/emulated/0？ 此疑问起源要追溯到笔者在写上一篇博文，即以...
CPU，寄存器，一缓二缓.... RAM ROM 外部存储器等简介
baeryu4478的博客
07-30 939
自我学习：一.线程安全日期格式化操作的几种方式：1.每次new一个新对象：public static Date parse(String date) throws ParseException { return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(date);} 2.通过ThreadLocal进行处理priv...
Android数据存储：内部与外部存储详解
改变应用的安装位置，可以在AndroidManifest.xml的清单文件中通过`android:installLocation`属性设置，可选值有"auto"（系统选择）、"internalOnly"（仅内部存储）和"preferExternal"（优先外部存储）。 了解并熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值