Android中的五种数据存储方式

最新推荐文章于 2024-07-25 21:18:27 发布

兰前小驻

最新推荐文章于 2024-07-25 21:18:27 发布

阅读量7.9k

点赞数 5

分类专栏：安卓

本文链接：https://blog.csdn.net/u013519020/article/details/52233421

版权

安卓专栏收录该内容

15 篇文章 0 订阅

订阅专栏

这五种方式分别是：

1、SharedPreferences（偏好设置），读取XML文件

2、文件存储

（1）assets（程序内部的资源，只能读）

（2）data/data/主包名/files目录下的，能读能写 || 手机内存

（3）读SD卡中的文件，需要申请权限

3、SQLite---->http://blog.csdn.net/u013519020/article/details/52229013

4、ContentProvider

5、网络流

一、SharedPreferences（偏好设置）本身不支持写，通过Editor获得写的能力

特点：轻量级存储，存放在XML文件中，采用Key--Value存取。

文件位置：data / data / 主包名 / shared_prefs / *.XML

编译器查找方式：Window-->Show View-->--other-->File Explorer(资源管理器)

存：（权限在后面还会有介绍）

Context ctx = MainActivity.this;
//第一个参数是文件名，第二个是读写模式
SharedPreferences sp=ctx.getSharedPreferences("t05", MODE_PRIVATE);
//获得编译
Editor editor = sp.edit();
//存数据
editor.putString("", "");
editor.commit();

取：

Context ctx = MainActivity.this;
//第一个参数是文件名，第二个是读写模式
SharedPreferences sp=ctx.getSharedPreferences("t05", MODE_PRIVATE);
String s=sp.getString("key", "取不到值时的默认值");

----------------------------文件存储------------------------

A.assets(只读、不能修改或删除)，这个是编译时存放的资源文件位置如图。

读取数据：

try {
//创建流
InputStream in = this.getAssets().open("文件名.扩展名");
//读出数据
Bitmap bm=BitmapFactory.decodeStream(in);
in.close();
in=null;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

B.读写数据（读写手机自身内存）

位置：data/data/主包名/files目录下的 || 也可以使用context.getFilesDir().getAbsolutePath()获得内存根路径

存：

try {
OutputStream os=this.openFileOutput("文件名", MODE_PRIVATE);
	os.write("wa".getBytes());
	os.close();
} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
}

取：

try {
	InputStream in=this.openFileInput("文件名");
	//缓冲区
	byte b[]=new byte[1024];
	//创建缓存
	ByteArrayBuffer ba=new ByteArrayBuffer(0);
	int l;
	//读
	while((l=in.read(b))>-1)
	{
	ba.append(b,0,l);
	}
	//转化
	String s=new String(ba.toByteArray());
} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
}

C.SDCard读写文件

（一）.首先要在AndroidManifest.XML中添加权限，两种方式添加：

1.傻瓜式添加

打开这个清单文件-->Permissions-->Add-->Permission(创建权限)、Uses Permission(申请/使用权限)

Name中选择： android.permission.READ_EXTERNAL_STORAGE//写权限

android.permission.WRITE_EXTERNAL_STORAGE//读权限

android.permission.MOUNT_UNMOUNT_FILESYSTEMS//创建、删除

2.牛人式添加（手敲）

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

在manifest节点中添加

（二）.判断SDCard是否存在

Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);

（三）.得到SDCard路径

File dir = Environment.getExternalStorageDirectory();

（四）.基本的文件流读写文件

....此处省略一万个字

（五）.关闭流，关闭文件，关闭一切，赋null，注意顺序。

---------------------------权限介绍-----------------------------------

权限共有四种，来自于context：

1.MODE_PRIVATE = 0

2.MODE_APPEND = 32768

3.MODE_WORLD_READABLE = 1

4.MODE_WORLD_WRITEABLE = 2

MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容。

MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。

MODE_WORLD_READABLE：表示当前文件可以被其他应用读取。

MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。

如果希望文件被其他应用读和写，可以传入： openFileOutput("itcast.txt",MODE_WORLD_READABLE + MODE_WORLD_WRITEABLE); android有一套自己的安全模型，当应用程序(.apk)在安装时系统就会分配给他一个userid，当该应用要去访问其他资源比如文件的时候，就需要userid匹配。默认情况下，任何应用创建的文件，sharedpreferences，数据库都应该是私有的（位于/data/data//files），其他程序无法访问。除非在创建时指定了MODE_WORLD_READABLE或者MODE_WORLD_WRITEABLE ，只有这样其他程序才能正确访问。

-------封装成组件---------

这是使用的方式，单例模式

if(FileManager.getInitialize().isSdCardAvailable()){
			path = FileManager.getInitialize().getSDOrCache(this, "/ambow/asso/apk/");
		}
		else
			path = FileManager.getInitialize().getSDOrCache(this, "");

文件管理的组件

public class FileManager {
	
	private static FileManager manager;
	
	/**
	 * 有效缓存时间是3天
	 */
	private static final long maxCacheTime = 1000*60*60*24*15;
	
	/**
	 * 构造函数
	 * @param context
	 */
	public FileManager(){
	}
	/**
	 * 单例，获取FileManager实例
	 * @param context
	 * @return
	 */
	public static FileManager getInitialize(){
		if(manager == null)
			manager = new FileManager();
		return manager;
	}
	/**
	 * 获取缓存cache目录路径
	 * @param context	上下文
	 * @return
	 */
	public String getCacheDir(Context context, String path){
		StringBuffer dir = new StringBuffer();
		dir.append(context.getFilesDir().getAbsolutePath());
		if(!path.startsWith("/"))
			dir.append("/");
		dir.append(path);
		File file = new File(dir.toString());
		if(!file.exists())
			file.mkdirs();
		return dir.toString();
	}
	
	/**
	 * 获取sd卡缓存路径
	 *
	 * @param path		路径
	 * @return
	 * 			有sd卡的返回sd上的路径
	 * 			没有sd卡返回null
	 */
	public String getSDDir(String path){
		if(!isSdCardAvailable())return null;
		StringBuffer dir = new StringBuffer();
		dir.append(Environment.getExternalStorageDirectory());
		if(!path.startsWith("/"))
			dir.append("/");
		dir.append(path);
		File file = new File(dir.toString());
		if(!file.exists())
			file.mkdirs();
		return dir.toString();
	}
	
	/**
	 * 获取缓存文件的路径
	 * @param path	缓存文件的路径
	 * @param url	保存的文件的url
	 * @return		
	 */
	public String getCacheFileUrl(Context context,String path, String url){
		return getSDOrCache(context,path)+formatPath(url);
	}
	
	/**
	 * 获取缓存路径
	 * @param context	上下文
	 * @param path		路径
	 * @return
	 * 			有sd卡返回sd上的路径
	 * 			没有sd卡返回cach中的路径
	 */
	public String getSDOrCache(Context context, String path){
		String url = null;
		if(isSdCardAvailable())
			url = getSDDir(path);
		else
			url = getCacheDir(context, path);
		return url;
	}
	/**
	 * 检测内存卡是否可用
	 * @return  可用则返回 true
	 */
	public boolean isSdCardAvailable(){
		if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
			return true;
		}
		return false;
	}
	/**
	 * 格式化url地址
	 * 	以便根据url来命名文件
	 * @param name	图片url
	 * @return
	 */
	public String formatPath(String name){
		String path = name;
		path = path.replace(":", "_");
		path = path.replace("/", "_");
		return path;
	}
	/**
	 * 判断该路径的文件是否存在
	 * @param path	文件路径（完全路径）
	 * @return
	 */
	public boolean isExists(String path){
		File file = new File(path);
		if(file.exists())
			return true;
		return false;
	}
	
	/**
	 * 判断当前目录是否存在文件
	 * @param path
	 * @return
	 */
	public boolean hasMoreFile(String path){
		File file = new File(path);
		if(!file.exists())
			return false;
		String[] files = file.list();
		if(files == null || files.length == 0)
			return false;
		return true;
	}
	/**
	 * 清除sd卡中过期的缓存
	 * 
	 * @param basePath	路径(要清楚文件的路径)
	 */
	public void cleanInvalidCache(String basePath){
		File file = new File(basePath);
		if(!file.exists()) return;
		File[] caches = file.listFiles();
		if(caches == null || caches.length == 0) return;
		long now = System.currentTimeMillis();
		try {
			for(int i=0;i<caches.length;i++){
				if((now - caches[i].lastModified()) < maxCacheTime){
					continue;
				}
				caches[i].delete();
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
					//每删除一张图片后停留10毫秒，防止cpu占用率过高，造成程序无响应
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 保存保存输入流
	 * @param path	要保存的完全路径
	 * @param is	网络获取的inputstream流
	 */
	public void saveInputStream(String path,InputStream is){
		if(!isExists(path)){
			File file = new File(path);
			FileOutputStream fos = null;
			try {
				fos = new FileOutputStream(file);
				int size = 0;
				byte[] buffer = new byte[1024];
				while((size = is.read(buffer)) != -1)
					fos.write(buffer, 0, size);
				fos.flush();
				fos.close();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			finally{
				try {
					if(fos != null){
						fos.close();
						fos = null;
					}
					if(file != null)
						file = null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	/**
	 * 从文件中读取流
	 * @param path	文件路径
	 * @return
	 */
	public InputStream loadInputStream(String path){
		InputStream is = null;
		if(isExists(path)){
			File file = new File(path);
			try {
				is = new FileInputStream(file);
			} catch (FileNotFoundException e) {
				e.printStackTrace();
				return null;
			}
		}
		return is;
	}
	
	
	/**
	 * 把对象写入文件
	 * 
	 * @throws Exception
	 */
	public void WriteObject(Object obj,Context context,String path) throws Exception {
		FileOutputStream fis = context.openFileOutput(path, Context.MODE_PRIVATE);
		ObjectOutputStream oos = new ObjectOutputStream(fis);
		oos.writeObject(obj);
		oos.close();
		fis.close();
	}

	/**
	 * 从文件读取对象
	 * 
	 * @return
	 * @throws Exception
	 */
	public Object readObject(Context context,String path) throws Exception {
		Object obj = new Object();
		FileInputStream fis = context.openFileInput(path);
		ObjectInputStream oos = new ObjectInputStream(fis);
		obj = oos.readObject();
		oos.close();
		fis.close();
		return obj;
	}
	
	/**
	 * 删除保存文件
	 * @param path  文件的完整路径
	 */
	public void delete(String path){
		File file = new File(path);
		if(file.exists())
			file.delete();
	}
}

转载请声明：http://blog.csdn.net/u013519020/article/details/52233421