android 超轻量级数据存储类

    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileNotFoundException;  
    import java.io.FileOutputStream;  
    import java.io.IOException;  
    import java.io.OutputStream;  
    import java.io.UnsupportedEncodingException;  
    import java.net.URLDecoder;  
    import java.net.URLEncoder;  
    import java.util.HashMap;  
    import java.util.Map;  
    import java.util.Properties;  
    import java.util.Set;  
      
    import android.content.Context;  
      
    /** 
     * android本地存储 ，主要用于存储简单key value键值对。提供增、删、改、查方法。 可自定义路径 
     *  
     * @author Administrator 
     * 
     */  
    public class LocalStorage {  
        private static Properties properties = new Properties();  
        private static String filepath;  
      
        private LocalStorage() {  
        }  
      
        /** 
         *  
         * @param ctx 
         * @param fileName 
         *            文件名 
         * @return 
         */  
        public static LocalStorage get(Context ctx,String fileName) {  
            return get(ctx.getCacheDir() + "/" + fileName);  
        }  
      
        /** 
         *  
         * @param filePath 
         *            文件绝对路径 
         * @return 
         */  
        public static LocalStorage get(String filePath) {  
            createFile(filePath);  
            filepath = filePath;  
            try {  
                properties.load(new FileInputStream(filepath));  
                return new LocalStorage();  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
      
        private static void createFile(String fileName) {  
            File file = new File(fileName);  
            if (!file.exists()) {  
                String path = file.getAbsolutePath();  
                String[] sourceStrArray = path.split("/");  
                String dirPath = "";  
                for (int i = 0; i < sourceStrArray.length - 1; i++) {  
                    if (!sourceStrArray[i].equals("")) {  
                        dirPath += "/" + sourceStrArray[i];  
                    }  
                }  
                new File(dirPath).mkdirs();  
                try {  
                    file.createNewFile();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
      
        }  
      
        public String getAsString(String key) {  
            if (key == null) {  
                return null;  
            }  
            Properties props = new Properties();  
            try {  
                props.load(new FileInputStream(filepath));  
                String value = props.getProperty(key);  
                value = URLDecoder.decode(value,"utf-8");  
                return value;  
            } catch (Exception e) {  
                e.printStackTrace();  
                return null;  
            }  
        }  
      
        public int getAsInt(String key) {  
            String str = getAsString(key);  
            if (str == null)  
                return -9999;  
            return Integer.valueOf(str).intValue();  
        }  
      
        public boolean getAsBoolean(String key) {  
            String str = getAsString(key);  
            if (str == null)  
                return false;  
            if (str.equals("true"))  
                return true;  
            return false;  
        }  
      
        public long getAsLong(String key) {  
            String str = getAsString(key);  
            if (str == null)  
                return -9999;  
            return Long.valueOf(str).longValue();  
        }  
      
        public float getAsFloat(String key) {  
            String str = getAsString(key);  
            if (str == null)  
                return -9999;  
            return Float.valueOf(str).floatValue();  
        }  
      
        public double getAsDouble(String key) {  
            String str = getAsString(key);  
            if (str == null)  
                return -9999;  
            return Double.valueOf(str).doubleValue();  
        }  
      
        /** 
         * 添加 
         *  
         * @param keyname 
         * @param keyvalue 
         */  
        public void put(String keyname,Object keyvalue) {  
            // 处理中文乱码  
            String value = keyvalue.toString();  
            try {  
                value = URLEncoder.encode(value,"utf-8");  
            } catch (UnsupportedEncodingException e1) {  
                e1.printStackTrace();  
            }  
            try {  
                OutputStream fos = new FileOutputStream(filepath);  
                properties.setProperty(keyname,value);  
                properties.store(fos,null);  
            } catch (IOException e) {  
            }  
        }  
      
        /** 
         * 更新 
         *  
         * @param keyname 
         * @param keyvalue 
         */  
        public void update(String keyname,String keyvalue) {  
            try {  
                properties.load(new FileInputStream(filepath));  
                OutputStream fos = new FileOutputStream(filepath);  
                properties.setProperty(keyname,keyvalue);  
                properties.store(fos,null);  
            } catch (IOException e) {  
            }  
        }  
      
        /** 
         * 根据key删除 
         *  
         * @param key 
         */  
        public void delete(String key) {  
            try {  
                FileInputStream fis = new FileInputStream(filepath);  
                properties.load(fis);  
                Map<String,String> map = new HashMap<String,String>();  
                Set<Object> keySet = properties.keySet();  
                for (Object object : keySet) {  
                    String objectkey = (String) object;  
                    String value = (String) properties.get(objectkey);  
                    map.put(objectkey,value);  
                }  
                map.remove(key);  
                properties.remove(key);  
                for (java.util.Map.Entry<String,String> entry : map.entrySet()) {  
                    properties.setProperty(entry.getKey(),entry.getValue());  
                }  
                FileOutputStream fos = new FileOutputStream(filepath);  
                properties.store(fos,"delete key:" + key);  
                fos.close();  
                fis.close();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  

    // 这里获取LocalStorage对象。参数也可以为文件绝对路径，当然也可以直接传入Context和文件名。  
        LocalStorage localStorage = LocalStorage.get("test.txt");  
        // 增加  
        localStorage.put("key","哈哈");  
        // 更新  
        localStorage.update("key","value");  
        // 查找，这里提供多个getAs 方法。取数据找到相应的数据类型  
        localStorage.getAsString("key");  
      
        // 删除  
        localStorage.delete("key");