缓存文件FileOutputStream ObjectOutputStream

一、对数据进行存储，提供了openFileOutput() 方法  <数据的写入>

 

  /**
     * 保存数据
     * @param context
     * @param fileName  保存文件名
     * @param data  保存的数据
     */
    public void saveFile(Context context, String fileName, String data) {
        try {
            FileOutputStream fos = context.openFileOutput(fileName, context.MODE_PRIVATE);
            fos.write(data.getBytes());
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

openFileOutput(): 第一个参数是保存的文件名，如果不存在，android 会自动创建文件；

 

  第二个参数是用于指定操作模式，有四种操作模式：

Context.MODE_PRIVATE    =  0         //为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容
Context.MODE_APPEND    =  32768      //会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。
Context.MODE_WORLD_READABLE =  1     //用来控制其他应用是否有权限读该文件，表示当前文件可以被其他应用读取
Context.MODE_WORLD_WRITEABLE =  2    //用来控制其他应用是否有权限写该文件，表示当前文件可以被其他应用写入为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容
Context.MODE_APPEND    =  32768      //会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。
Context.MODE_WORLD_READABLE =  1     //用来控制其他应用是否有权限读该文件，表示当前文件可以被其他应用读取
Context.MODE_WORLD_WRITEABLE =  2    //用来控制其他应用是否有权限写该文件，表示当前文件可以被其他应用写入

 

 

 

往sdcard 中存储文件

 

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
   File sdCardDir = Environment.getExternalStorageDirectory();//获取SDCard目录
   File saveFile = new File(sdCardDir, "a.txt");
   FileOutputStream outStream = new FileOutputStream(saveFile);
   outStream.write("test".getBytes());
   outStream.close();
}

 

 

二、对数据的读取，FileInputStream <数据的读取>

 

/**
     * 读取文件
     * @param fileName 需要读取的文件名
     */
    public void readFile(String fileName) {
        try {
            FileInputStream fis = new FileInputStream(fileName); // 读取数据 fileName 读取的文件数据 .txt  等文件
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length = -1;
            while ((length = fis.read(buffer)) != -1) {
                // buffer : 写入的数据；  0 ： 写入数据的开始位置 ；  length : 每次写入的bytes
                baos.write(buffer, 0, length);
            }

            baos.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

getCacheDir()方法用于获取/data/data/<package name>/cache目录
getFilesDir()方法用于获取/data/data/<package name>/files目录

 

 

三、对象输入输出流  ObjectInputStream ObjectOutputStream

     对象的序列化以及反序列化。主要用于对象信息的写入以及读取。 对象信息一旦写到文件上那么对象的信息就可以做到持久化了

     对象的输出流ObjectOutputStream ：将指定的对象写入到文件的过程，就是将对象序列化的过程。（对象实现Serializable）

     对象的输入流ObjctInputStream :   指将指定序列化的对象读出来的过程，就是将对象反序列化的过程。
 

1、对象的写入

 

 /**
     * 将对象信息写入到filePath文件中
     * 定义方法把对象的信息写到硬盘上------>对象的序列化。
     *
     * @param filePath 写入对象信息的文件路径
     * @param object   写入的对象
     * @return
     */
    public void saveObj(String filePath, Object object) {
        File file = new File(filePath);
        try {
            FileOutputStream fos = new FileOutputStream(file); // 创建文件字节输出流对象
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(object);
            //最后记得关闭资源，oos.close()内部已经将fos对象资源释放了，所以只需要关闭objectOutputStream即可
            oos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 

 

 

2、对象的读取

 

/**
     * 把文件中的对象信息读取出来 —— 对象的反序列化过程
     * @param filePath
     */
    private void readObj(String filePath){
        try {
            FileInputStream fis = new FileInputStream(new File(filePath)); // 创建文件字节输入流对象
            ObjectInputStream ois = new ObjectInputStream(fis);
            Object object = ois.readObject(); // 读取文件后的对象
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

 

 

 

3、对象的写入读取可能存在的异常：

    Exception in thread "main" java.io.InvalidClassException: xuliehua.User; local class incompatible: stream classdesc     serialVersionUID = 2161776237447595412, local class serialVersionUID = -3634244984882257127

 

异常信息解读：

serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是JVM(JAVA虚拟界)通过一个类的类名、成员、包名、工程名算出的一个数字。而这时候序列化文件中记录的serialVersionUID与项目中的不一致，即找不到对应的类来反序列化。

如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。

不想要某些字段序列化时候，可以用transient关键字修饰

 

class Debug implements Serializable{
        private static final  long serialVersionUID = 1L;
        private String debugInfo ;
        private int debugId;    // transient String debug; // 不需要序列化这个变量

        public Debug(String debugInfo, int debugId) {
            this.debugInfo = debugInfo;
            this.debugId = debugId;
        }

        public String getDebugInfo() {
            return debugInfo;
        }

        public void setDebugInfo(String debugInfo) {
            this.debugInfo = debugInfo;
        }

        public int getDebugId() {
            return debugId;
        }

        public void setDebugId(int debugId) {
            this.debugId = debugId;
        }
    }

 

 

4、注意点：

1）对象的反序列化创建对象的时候并不会调用到构造方法的；

2）如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口；

3）serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字；

4） 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID进行对比，如果这两个id不一致，反序列则失败；

5） 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了；

6）如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰；

7）如果一个类维护了另外一个类的引用，则另外一个类也需要实现Serializable接口。