Android基础#45：Android数据存储之文件存储数据

Bertha 。 2023-10-17 14:49 78阅读 0赞

内容简介：

Android系统当然支持文件系统。在Android系统中，除了Preference文件外，普通的文件读取方式，和java几乎一样。需要注意的是，  
Android系统中的文件的存储路径和读取权限。  
Android系统中，既提供了App的私有的存储路径，也提供了诸如sdcard相关的公共路径的数据读取接口。例如，  
openFileInput()，openFileOutput()方法，getCacheDir()，getExternalFilesDir等等，

示例：

这里，给出一些代码示例，分别针对内部存储器，外部存储器进行操作：  
１.　内部数据存储器的操作例子，主要调用了openFileOutput， openFileInput。  
  
　　这组例子中，实现了下面三个函数：  
　　writeInternalStoragePrivate：写数据到内部存储器  
　　readInternalStoragePrivate：　从内部存储器读数据到指定的buffer中  
　　deleteInternalStoragePrivate：从内部存储器删除数据

/* Writes content to internal storage making the content private to
     * the application. The method can be easily changed to take the MODE
     * as argument and let the caller dictate the visibility:
     * MODE_PRIVATE, MODE_WORLD_WRITEABLE, MODE_WORLD_READABLE, etc.
     *
     * @param filename - the name of the file to create
     * @param content - the content to write
     */
     public void writeInternalStoragePrivate(
            String filename, byte[] content) {
        try {
            //MODE_PRIVATE creates/replaces a file and makes
            //  it private to your application. Other modes:
            //    MODE_WORLD_WRITEABLE
            //    MODE_WORLD_READABLE
            //    MODE_APPEND
          	FileOutputStream fos = openFileOutput(filename, Context.MODE_PRIVATE);
            fos.write(content); //将content数组的内容写到filename指定的文件中。
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //从内部私有存储器读取数据；注意 openFileInput() 的使用。
    /**
     * Reads a file from internal storage
     * @param filename the file to read from
     * @return the file content
     */
    public byte[] readInternalStoragePrivate(String filename) {
        int len = 1024;
        byte[] buffer = new byte[len];
        try {
            FileInputStream fis = openFileInput(filename);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int nrb = fis.read(buffer, 0, len); // read up to len bytes
            while (nrb != -1) {
                baos.write(buffer, 0, nrb);
                nrb = fis.read(buffer, 0, len);
            }
            buffer = baos.toByteArray();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }
    
    /**
     * Delete internal private file
     * @param filename - the filename to delete
     */
    public void deleteInternalStoragePrivate(String filename) {
        File file = getFileStreamPath(filename);
        if (file != null) {
            file.delete();
        }
    }

说明：

openFileInput()，openFileOutput()是ContextWrapper类的成员函数，所以可以直接在Activity中调用，因为Activity是ContextWrapper的子类。

２.　外部数据存储器的操作例子，主要用到了下面这些函数：  
　　　getExternalStorageState()  
　　　getExternalFilesDir()　　  
　　　getExternalStorageDirectory()  
　　　getExternalStoragePublicDirectory()

这组例子中，实现了下面几个函数：  
　　　isExternalStorageAvailable： 外部存储器是否可用  
　　　isExternalStorageReadOnly： 　外部存储器是否只可读  
　　　writeToExternalStoragePublic：写数据到外部存储器  
　　　readExternallStoragePublic：　从外部存储器读数据到指定的buffer中  
　　　deleteExternalStoragePublicFile：删除外部存储器代码：

/**
     * Helper Method to Test if external Storage is Available
     */
    public boolean isExternalStorageAvailable() {
        boolean state = false;
        String extStorageState = Environment.getExternalStorageState();
        if (Environment.MEDIA_MOUNTED.equals(extStorageState)) {
            state = true;
        }
        return state;
    }
    
    /**
     * Helper Method to Test if external Storage is read only
     */
    public boolean isExternalStorageReadOnly() {
        boolean state = false;
        String extStorageState = Environment.getExternalStorageState();
        if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(extStorageState)) {
            state = true;
        }
        return state;
    }
    
    /**
     * Write to external public directory
     * @param filename - the filename to write to
     * @param content - the content to write
     */
    public void writeToExternalStoragePublic(String filename, byte[] content) {
    
        // API Level 7 or lower, use getExternalStorageDirectory()
        //  to open a File that represents the root of the external
        // storage, but writing to root is not recommended, and instead
    // application should write to application-specific directory, as shown below.
    
        String packageName = this.getPackageName();
        String path = "/Android/data/" + packageName + "/files/";
    
        if (isExternalStorageAvailable() &&
           !isExternalStorageReadOnly()) {
            try {
                File file = new File(path, filename);
    　　　　　　file.mkdirs();
                FileOutputStream fos = new FileOutputStream(file);
                fos.write(content);
                fos.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * Reads a file from internal storage
     * @param filename - the filename to read from
     * @return the file contents
     */
    public byte[] readExternallStoragePublic(String filename) {
        int len = 1024;
        byte[] buffer = new byte[len];
        String packageName = this.getPackageName();
        String path = "/Android/data/" + packageName + "/files/";
    　　if (!isExternalStorageReadOnly()) {    
            try {
                File file = new File(path, filename);           
                FileInputStream fis = new FileInputStream(file);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int nrb = fis.read(buffer, 0, len); //read up to len bytes
                while (nrb != -1) {
                    baos.write(buffer, 0, nrb);
                    nrb = fis.read(buffer, 0, len);
                }
    　　　　buffer = baos.toByteArray();
                fis.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return buffer;
    }
    
    /**
     * Delete external public file
     * @param filename - the filename to write to
     */
    void deleteExternalStoragePublicFile(String filename) {
        String packageName = this.getPackageName();
        String path = "/Android/data/" + packageName + "/files/"+filename;
        File file = new File(path, filename);
        if (file != null) {
            file.delete();
        }
    }

注意：　需要添加外部存储器需要特殊的权限 WRITE\_EXTERNAL\_STORAGE：  
<uses-permission android:name="android.permission.WRITE\_EXTERNAL\_STORAGE"/>

３.　高速缓存的操作示例：  
如果您具有不需要长期永久保存的临时文件，那么可以将这些文件存储在高速缓存中。高速缓存是一种特殊的内存，可以用于存储中小型数据（少于兆字节），但是您一定要知道，取决于有多少内存可用，高速缓存的内容任何时候都可能被清除。

相关方法：  
getCacheDir：　得到内部高速缓存  
getExternalCacheDir：得到外部高速缓存

代码：

/**
     * Helper method to retrieve the absolute path to the application
     * specific internal cache directory on the file system. These files
     * will be ones that get deleted when the application is uninstalled or when
     * the device runs low on storage. There is no guarantee when these
     * files will be deleted.
     *
     * Note: This uses a Level 8+ API.
     *
     * @return the absolute path to the application specific cache  directory
     */
    public String getInternalCacheDirectory() {
        String cacheDirPath = null;
        File cacheDir = getCacheDir();
        if (cacheDir != null) {
            cacheDirPath = cacheDir.getPath();
        }
        return cacheDirPath;       
    }
    
    /**
     * Helper method to retrieve the absolute path to the application
     * specific external cache directory on the file system. These files
     * will be ones that get deleted when the application is uninstalled or when
     * the device runs low on storage. There is no guarantee when these
     * files will be deleted.
     *
     * Note: This uses a Level 8+ API.
     *
     * @return the absolute path to the application specific cache
    directory
     */
    public String getExternalCacheDirectory() {
        String extCacheDirPath = null;
        File cacheDir = getExternalCacheDir();
        if (cacheDir != null) {
            extCacheDirPath = cacheDir.getPath();
        }
        return extCacheDirPath;    
    }