安卓數據持久化工具類總結

程序猿是最懶的生物，開發中從不重復造輪子，實際開發中數據吃就化是必然要處理的一個問題，先總結了幾個除處理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;
	}
}

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);
		

	}

}