安卓数据持久化工具类总结

安卓数据持久化工具类总结

程序猿是最懒的生物，开发中从不重复造轮子，实际开发中数据吃就化是必然要处理的一个问题，先总结了几个除处理sqlite外的几个工具类，因为sqlite可以直接用orm，持久化数据有I/O，SharedPreference等等方式。

外置储存卡

package cn.edu.zafu.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import android.os.Environment;

/**
 * 外部存儲卡工具类
 * 需要添加权限 
 * android.permission.WRITE_EXTERNAL_STORAGE
 * android.permission.MOUNT_UNMOUNT_FILESYSTEMS
 * 
 * @author lizhangqu
 * @version 1.0
 * 
 */
public class ExternalStorageUtil {

	/**
	 * 是否可写
	 * 
	 * @return 可写性
	 */
	public static boolean isExternalStorageWritable() {
		String state = Environment.getExternalStorageState();
		if (Environment.MEDIA_MOUNTED.equals(state)) {
			return true;
		}
		return false;
	}

	/**
	 * 是否可读
	 * 
	 * @return 可读性
	 */
	public static boolean isExternalStorageReadable() {
		String state = Environment.getExternalStorageState();
		if (Environment.MEDIA_MOUNTED.equals(state)
				|| Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
			return true;
		}
		return false;
	}

	/**
	 * 获得根路径
	 * 
	 * @return 外置内存卡根路径
	 */
	public static String getExternalStoragePath() {
		if (isExternalStorageWritable())
			return Environment.getExternalStorageDirectory().getAbsolutePath();
		else
			return null;
	}

	/**
	 * 获得下载目录路径
	 * 
	 * @return 外置内存卡下载路径
	 */
	public static String getExternalDownloadPath() {
		return Environment.getExternalStoragePublicDirectory(
				Environment.DIRECTORY_DOWNLOADS).getAbsolutePath();
	}

	/**
	 * 向根路径写文件
	 * 
	 * @param fileName 文件名
	 * @param content 上下文
	 * @return 是否写入成功
	 */
	public static boolean write(String fileName, String content) {
		return write("/", fileName, content);
	}

	/**
	 * 向根目录写字节
	 * 
	 * @param fileName 文件名
	 * @param bytes 文件字节数组
	 * @return 是否写入成功
	 */
	public static boolean writeBytes(String fileName, byte[] bytes) {
		return writeBytes("/", fileName, bytes);
	}

	/**
	 * 向指定目录的文件中写入字符串,路径以/开始/结尾
	 * 
	 * @param path 相对于根路径的路径，路径以/开始，以/结尾
	 * @param fileName 文件名
	 * @param content 文件内容
	 * @return 是否写入成功
	 */
	public static boolean write(String path, String fileName, String content) {
		return writeBytes(path, fileName, content.getBytes());
	}

	/**
	 * 向指定目录的文件写入字节数组,路径以/开始/结尾
	 * 
	 * @param path 相对于根路径的路径，路径以/开始，以/结尾
	 * @param fileName 文件名
	 * @param bytes 字节数组
	 * @return
	 */
	public static boolean writeBytes(String path, String fileName, byte bytes[]) {
		boolean flag = false;
		if (!path.equals("/")) {
			File dir = new File(getExternalStoragePath() + path);
			if (!dir.exists()) {
				if (!(dir.mkdir() || dir.isDirectory())) {
					// 文件目录创建失败或者不是一个目录
					return false;
				}
			}
		}
		File file = new File(getExternalStoragePath() + path + fileName);
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file, false);
			fos.write(bytes);
			flag = true;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

		}
		return flag;
	}

	/**
	 * 从根路径读字节
	 * 
	 * @param fileName 文件名
	 * @return 字节数组
	 */
	public static byte[] readBytes(String fileName) {
		return readBytes("/", fileName);
	}

	/**
	 * 从指定目录读字节,路径以/开始/结尾
	 * 
	 * @param path 相对于根路径的路径，路径以/开始，以/结尾
	 * @param fileName 文件名
	 * @return 字节数组
	 */
	public static byte[] readBytes(String path, String fileName) {
		File file = new File(getExternalStoragePath() + path + fileName);
		if (!file.isFile()) {
			return null;
		} else {
			FileInputStream fis = null;
			try {
				fis = new FileInputStream(file);
				int length = fis.available();
				byte[] buffer = new byte[length];
				fis.read(buffer);
				return buffer;
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (fis != null) {
					try {
						fis.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
			return null;
		}

	}

	/**
	 * 从根目录读文本
	 * 
	 * @param fileName 文件名
	 * @return 字符串
	 */
	public static String read(String fileName) {
		return read("/", fileName);
	}

	/**
	 * 从指定目录读文本,路径以/开始/结尾
	 * 
	 * @param path 相对于根路径的路径，路径以/开始，以/结尾
	 * @param fileName 文件名
	 * @return 字符串
	 */
	public static String read(String path, String fileName) {
		try {
			byte[] readBytes = readBytes(path, fileName);
			if (readBytes == null) {
				return null;
			}
			return new String(readBytes, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 从根目录删除
	 * 
	 * @param fileName 文件名
	 * @return 是否删除成功
	 */
	public static boolean delete(String fileName) {
		return delete("/", fileName);
	}

	/**
	 * 从指定目录删除,路径以/开始/结尾
	 * 
	 * @param path 相对于根路径的路径，路径以/开始，以/结尾
	 * @param fileName 文件名
	 * @return 是否删除成功
	 */
	public static boolean delete(String path, String fileName) {
		File file = new File(getExternalStoragePath() + path + fileName);
		if (file.exists())
			return file.delete();
		else
			return true;
	}
}

内置储存卡

package cn.edu.zafu.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import android.content.Context;

/**
 * 內部存儲卡工具类
 * 
 * @author lizhangqu
 * @version 1.0
 */
public class InternalStorageUtil {

	/**
	 * 在原文件后追加内容
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param content 追加的文本
	 * @return 是否追加成功
	 */
	public static boolean append(Context context, String fileName,
			String content) {
		return writeBytes(context, fileName, content.getBytes(), true);
	}

	/**
	 * 写入文件，文件存在则覆盖
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param content 写入的文本
	 * @return 是否写入成功
	 */
	public static boolean write(Context context, String fileName, String content) {
		return writeBytes(context, fileName, content.getBytes(), false);
	}

	/**
	 * 写入字节
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param content 写入的字节
	 * @return 是否写入成功
	 */
	public static boolean writeBytes(Context context, String fileName,
			byte[] content) {
		return writeBytes(context, fileName, content, false);
	}

	/**
	 * 写入文件，文件存在时根据参数isAppend判断是否覆盖
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param content 写入的字节
	 * @param isAppend 是否追加
	 * @return 是否写入成功
	 */
	public static boolean writeBytes(Context context, String fileName,
			byte[] content, boolean isAppend) {
		FileOutputStream fout = null;
		boolean flag = false;
		try {
			if (isAppend) {
				fout = context.openFileOutput(fileName, Context.MODE_APPEND);
			} else {

				fout = context.openFileOutput(fileName, Context.MODE_PRIVATE);
			}
			fout.write(content);
			flag = true;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fout != null) {
					fout.close();
					fout = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return flag;
	}

	/**
	 * 读取文件
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @return 文件内容的字符串
	 */
	public static String read(Context context, String fileName) {
		byte[] buffer = readBytes(context, fileName);
		String result=null;
		try {
			result = new String(buffer, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return result;
	}
	/**
	 * @param context 上下文
	 * @param fileName 文件名
	 * @return 字节数组
	 */
	public static byte[] readBytes(Context context, String fileName) {
		FileInputStream fin = null;
		byte[] buffer = null;
		try {
			fin = context.openFileInput(fileName);
			int length = fin.available();
			buffer = new byte[length];
			fin.read(buffer);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (fin != null) {
					fin.close();
					fin = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return buffer;
	}

	/**
	 * 清除所有文件，当有一个文件未清除时返回false
	 * 
	 * @param context 上下文
	 * @return 是否清楚成功
	 */
	public static boolean clear(Context context) {
		boolean flag = true;
		String[] files = context.fileList();
		for (String fileName : files) {
			boolean result = context.deleteFile(fileName);
			if (result == false) {
				flag = false;
			}
		}
		return flag;
	}

	/**
	 * 根据文件名清除文件
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @return 是否删除成功
	 */
	public static boolean delete(Context context, String fileName) {
		return context.deleteFile(fileName);
	}

	/**
	 * 返回内部存储的绝对路径
	 * 
	 * @param context 上下文
	 * @return app内置文件夹路径
	 */
	public static String getFileDir(Context context) {
		File filesDir = context.getFilesDir();
		return filesDir.getAbsolutePath();
	}
}

资源文件的读取

package cn.edu.zafu.utils;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

import android.content.Context;

/**
 * assert资源的读取
 * 
 * @author lizhangqu
 * @version 1.0
 */
public class ResouceFileUtil {
	/**
	 * 从assert文件夹下读取文本资源
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @return 文件内容字符串
	 */
	public static String readStringFromAssert(Context context, String fileName) {
		String result = null;
		byte[] buffer = readBytesFromAssert(context, fileName);
		try {
			result = new String(buffer, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 从raw文件夹下读取文本资源
	 * 
	 * @param context 上下文
	 * @param rawId raw资源id
	 * @return 文件内容字符串
	 */
	public static String readStringFromRaw(Context context, int rawId) {
		String result = null;
		byte[] buffer = readBytesFromRaw(context, rawId);
		try {
			result = new String(buffer, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 从assert文件夹下读取文件到字节数组
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @return 文件字节数组
	 */
	public static byte[] readBytesFromAssert(Context context, String fileName) {
		InputStream is = null;
		byte[] buffer = null;
		try {
			is = context.getAssets().open(fileName);
			int size = is.available();
			buffer = new byte[size];
			is.read(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (is != null) {
				try {
					is.close();
					is = null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

		return buffer;
	}

	/**
	 * 从raw文件夹下读取文件到字节数组
	 * 
	 * @param context 上下文
	 * @param rawId raw资源id
	 * @return 文件字节数组
	 */
	public static byte[] readBytesFromRaw(Context context, int rawId) {
		InputStream is = null;
		byte[] buffer = null;
		try {
			is = context.getResources().openRawResource(rawId);
			int size = is.available();
			buffer = new byte[size];
			is.read(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (is != null) {
				try {
					is.close();
					is = null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return buffer;
	}
}

SharedPreference的操作

package cn.edu.zafu.utils;

import android.content.Context;
import android.content.SharedPreferences;

/**
 * SharedPreference方式持久化数据的工具类
 * 
 * @author lizhangqu
 * @version 1.0
 */
public class SharedPreferenceUtil {

	/**
	 * 保存键值对
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param key 键
	 * @param value 值
	 * @return 是否保存成功
	 */
	public static boolean set(Context context, String fileName, String key,
			String value) {
		SharedPreferences sharedPreferences = context.getSharedPreferences(
				fileName, Context.MODE_PRIVATE);
		SharedPreferences.Editor editor = sharedPreferences.edit();
		editor.putString(key, value);
		return editor.commit();
	}

	/**
	 * 获得键对应的值,如果没有则返回""
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param key 键
	 * @return 值，没有则返回""
	 */
	public static String get(Context context, String fileName, String key) {
		return get(context, fileName, key, "");
	}

	/**
	 * 获得键对应的值,如果没有则返回defaultValue
	 * 
	 * @param context 上下文
	 * @param fileName 文件名
 	 * @param key 键
	 * @param defaultValue 默认值
	 * @return 值，没有则返回defaultValue
	 */
	public static String get(Context context, String fileName, String key,
			String defaultValue) {
		SharedPreferences sharedPreferences = context.getSharedPreferences(
				fileName, Context.MODE_PRIVATE);
		String value = sharedPreferences.getString(key, defaultValue);// 第二个参数为默认值
		return value;
	}

	/**
	 * 移除一项
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param key 键
	 * @return 是否移除成功
	 */
	public static boolean remove(Context context, String fileName, String key) {
		SharedPreferences sharedPreferences = context.getSharedPreferences(
				fileName, Context.MODE_PRIVATE);
		SharedPreferences.Editor editor = sharedPreferences.edit();
		editor.remove(key);
		return editor.commit();

	}
	
	/**
	 * 清除文件内容
	 * @param context 上下文
	 * @param fileName 文件名
	 * @return 是否清除成功
	 */
	public static boolean clear(Context context, String fileName) {
		SharedPreferences sharedPreferences = context.getSharedPreferences(
				fileName, Context.MODE_PRIVATE);
		SharedPreferences.Editor editor = sharedPreferences.edit();
		editor.clear();
		return editor.commit();

	}
	
	/**
	 * 某一项是否存在
	 * @param context 上下文
	 * @param fileName 文件名
	 * @param key 键
	 * @return 该键对应的值是否存在
	 */
	public static boolean contatins(Context context, String fileName,String key) {
		SharedPreferences sharedPreferences = context.getSharedPreferences(
				fileName, Context.MODE_PRIVATE);
		return sharedPreferences.contains(key);
		

	}

}