码迷，mamicode.com
首页 > 移动开发 > 详细

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

时间：2015-03-05 09:18:12      阅读：185      评论：0      收藏：0      [点我收藏+]

标签：io   orm   数据   数据持久化   android   

程序猿是最懒的生物，开发中从不重复造轮子，实际开发中数据吃就化是必然要处理的一个问题，先总结了几个除处理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);
		

	}

}


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

标签：io   orm   数据   数据持久化   android   

原文地址：http://blog.csdn.net/sbsujjbcy/article/details/44077561
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！