android 类文件,Android文件存储类

1.先将要保存的对象序列化

这里实现了Serializable接口，如果是实现Parcelable，写法就不同了。Serializable优点在于节省代码量，但是速度上要与Parcelable差不少。若果数据量并不是很多的话两者之间的差距是可以忽略的。

public class LoginModel implements Serializable {

@Expose

@SerializedName("phone")

public String phone;

@Expose

@SerializedName("accessToken")

public String accessToken;

@Expose

@SerializedName("bankNum")

public int bankNum;

@Expose

@SerializedName("realName")

public String realName;

}

public class SdegModel implements Parcelable {

private String phone;

public String getPhone(){

return phone;

}

public void setPhone(String phone){

this.phone = phone;

}

@Override

public int describeContents() {

return 0;

}

@Override

public void writeToParcel(Parcel dest, int flags) {

dest.writeString(phone);

}

}

2.文件存储Utils类

public class CacheDataUtils {

/*

* @param dir 要保存的目录

* @param filename 要保存的文件名

* @param data 要保存的数据

* */

public static boolean writeCacheData(String dir, String filename, Object data){

File f = new File(dir);

if (!f.exists()){

f.mkdirs();

}

File target = new File(dir + File.separator + filename);

return writeCacheData(target, data);

}

public static boolean clearCacheData(String dir, String filename){

File target = new File(dir + File.separator + filename);

if (target.exists()){

target.delete();

}

return true;

}

/*

* @param file 要保存的文件

* @param data 要保存的数据

* */

public static boolean writeCacheData(File file, Object data){

if (!file.exists()){

try {

file.createNewFile();

} catch (IOException e) {

e.printStackTrace();

return false;

}

}

ByteArrayOutputStream output = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream;

byte[] result = null;

try {

objectOutputStream = new ObjectOutputStream(output);

objectOutputStream.writeObject(data);

objectOutputStream.flush();

result = output.toByteArray();

objectOutputStream.close();

output.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

if (result == null){

return false;

}

try {

FileOutputStream outputStream = new FileOutputStream(file);

outputStream.write(result);

outputStream.close();

// AppCacheMgr.instance.appendCacheFileSize(file);

return true;

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return false;

}

/*

* 从指定文件读取数据，并反序列化对象

* @param dir 要读取的目录

* @param filename 要读取的文件名

* @return 反序列化后的对象

* */

public static Object readCacheData(String dir, String filename){

File target = new File(dir + File.separator + filename);

return readCacheData(target);

}

public static boolean isCacheDataExist(String dir, String filename){

File target = new File(dir + File.separator + filename);

return target.exists();

}

/*

* 从指定文件读取数据，并反序列化对象

* @param file 要读取的文件

* @return 反序列化后的对象

* */

public static Object readCacheData(File file){

if (!file.exists()){

return null;

}

Object obj = null;

try {

FileInputStream fileInput = new FileInputStream(file);

byte[] data = new byte[fileInput.available()];

fileInput.read(data);

fileInput.close();

ByteArrayInputStream input = new ByteArrayInputStream(data);

ObjectInputStream objectInputStream = new ObjectInputStream(input);

obj = objectInputStream.readObject();

objectInputStream.close();

input.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (Throwable e) {

e.printStackTrace();

}

return obj;

}

}

3.文件存储实现类

public class DataCache {

private String cacheDir;

private static final String CACHE_ROOT = "RESPONSE";

public static String APPCONFIG = "APPCONFIG";

public static final DataCache instance = new DataCache();

private DataCache() {

}

public void init(Context context) {

cacheDir = context.getCacheDir().getAbsolutePath()

+ File.separator + CACHE_ROOT;

}

private String getHashData(String key) {

return HashUtil.GetHashCode(key, HashUtil.HashType.MD5.toString());

}

/*

* 将对象序列化缓存到本地

*

* @param loginAccount 登录账号

* @param key 用于标识要保存的缓存数据

* @param data 要序列化保存的对象

* @return 成功返回true，否则false

*/

public boolean saveCacheData(String loginAccount, String key, Object data) {

key = getHashData(loginAccount + key);

return CacheDataUtils.writeCacheData(cacheDir, key, data);

}

/*

* 删除本地缓存数据

*

* @param loginAccount 登录账号

* @param key 用于标识要保存的缓存数据

* @return 成功返回true，否则false

*/

public boolean clearCacheData(String loginAccount, String key) {

key = getHashData(loginAccount + key);

return CacheDataUtils.clearCacheData(cacheDir, key);

}

/*

* 获取缓存数据并返反序列化

*

* @param loginAccount 登录账号

* @param key 用于标识要获取的缓存数据

* @return 成功返回对应对象实例，否则返回null

*/

public T getCacheData(String loginAccount, String key) {

key = getHashData(loginAccount + key);

Object obj = CacheDataUtils.readCacheData(cacheDir, key);

if (obj == null) {

return null;

}

return (T) obj;

}

public boolean isCacheExist(String loginAccount, String key) {

key = getHashData(loginAccount + key);

return CacheDataUtils.isCacheDataExist(cacheDir, key);

}

public String getImageFile(String loginAccount, String key) {

try {

key = getHashData(loginAccount + key);

File target = new File(cacheDir + File.separator + key);

return target.getCanonicalPath();

} catch (Throwable throwable) {

}

return null;

}

public Object getAppServiceConfigData() {

return getCacheData("", APPCONFIG);

}

}

4.具体使用

/**

* 保存数据

* @param loginAccount 登录账号

* @param key 保存文件的钥匙(开发人员自己拟定)

* @param obj 要保存的对象

*/

private void saveData(String loginAccount,String key,Object obj){

DataCache.instance.saveCacheData(loginAccount,key,obj);

}

/**

* 获取保存的数据

* @param loginAccount

* @param key

*/

private void getData(String loginAccount,String key){

DataCache.instance.getCacheData(loginAccount,key);

}

/**

* 清除保存的数据

* @param loginAccount

* @param key

*/

private void clearData(String loginAccount,String key){

DataCache.instance.clearCacheData(loginAccount,key);

}