Android开发系列之数据存储（二）

上一篇记载了Android开发数据库与Sharepreferences的基本使用，该篇主要讲述下文件的存储方式。

  .文件

   文件存储方式在Android开发中几乎是必不可少的，常用的文件磁盘缓存，字符串文件缓存以及xml文件缓存等。

.文件读写 文件的读写主要有几种：多媒体文件以流的形式，文本文件以字符串的形式等。

.将流写入文件

/**
     * 将InputStream保存到文件
     *
     * @param context
     * @param in
     * @param fileLength
     * @param savDir
     * @param savName
     */
    public static void writeStream2File(Context context, InputStream in,
            long fileLength, String savDir, String savName) {

        if (in == null) {
            return;
        }
        if (StringUtils.isEmpty(savDir) || StringUtils.isEmpty(savName)) {
            return;
        }
        if (!canWrite(context, fileLength)) {
            return;
        }
        File dirFile = new File(savDir);
        if (!dirFile.exists()) {
            dirFile.mkdirs();
        }
        File savFile = new File(savDir, savName);
        try {
            if (savFile.exists()) {
                savFile.deleteOnExit();
            }
            savFile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(savFile);
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
            fos.flush();
            fos.close();
            fos = null;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                    fos = null;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

.将文件转化为流

public InputStream getInputStream(String path) {

   if(StringUtils.isEmpty(path)){

          return null;
    }

    File file = new File(path);
    if(!file.exists) ｛
        return null;
     ｝

     return new FileInputStream(file);
}

.将字符串写入文件

/**
     * 将String保存到文件
     *
     * @param context
     * @param content
     * @param dirPath
     * @param fileName
     * @param append
     *            写入形式：true-追加写入 、false-重新写入
     * @return
     */
    public static boolean writeString2File(Context context, String content,
            String dirPath, String fileName, boolean append) {

        if (StringUtils.isEmpty(content)) {
            return false;
        }
        if (StringUtils.isEmpty(dirPath) || StringUtils.isEmpty(fileName)) {
            return false;
        }
        File file = new File(dirPath, fileName);
        if (!file.exists()) {
            try {
                createNewDir(context, dirPath);
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(file, append);
            fileWriter.write(content);
            fileWriter.close();
            fileWriter = null;
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null) {
                    fileWriter.close();
                    fileWriter = null;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

.从文件读取字符串

/**
     * 读取文件
     *
     * @param context
     * @param filePath
     * @param charsetName
     * @return
     */
    public static StringBuilder readFile(Context context, File file,
            String charsetName) {
        if (file != null && file.exists() && SDCardUtils.sdcardExists()) {
            if (StringUtils.isEmpty(charsetName)) {
                charsetName = "UTF-8";
            }
            StringBuilder fileContent = new StringBuilder();
            BufferedReader reader = null;
            InputStreamReader is = null;
            try {
                is = new InputStreamReader(new FileInputStream(file),
                        charsetName);
                reader = new BufferedReader(is);
                String line = null;
                while ((line = reader.readLine()) != null) {
                    if (!fileContent.toString().equals("")) {
                        fileContent.append("\r\n");
                    }
                    fileContent.append(line);
                }
                is.close();
                reader.close();
                is = null;
                reader = null;
                return fileContent;
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (is != null) {
                        is.close();
                        is = null;
                    }
                    if (reader != null) {
                        reader.close();
                        reader = null;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

.将文件转化为Base64字符串

/**
     * 文件转化Base64 String
     *
     * @param path
     *            文件完整路径
     * @return
     */
    public static String encodeFileByBase64(Context context, String dirPath,
            String fileName) {

        if (StringUtils.isEmpty(dirPath) || StringUtils.isEmpty(fileName)) {
            return null;
        }
        File file = new File(dirPath, fileName);
        if (!file.exists()) {
            return null;
        }
        FileInputStream fis = null;
        ByteArrayOutputStream bos = null;
        try {
            fis = new FileInputStream(file);
            bos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = fis.read(buffer)) >= 0) {
                bos.write(buffer, 0, len);
            }
            String base64String = new String(Base64.encodeToString(
                    bos.toByteArray(), Base64.DEFAULT));
            fis.close();
            bos.close();
            fis = null;
            bos = null;
            return base64String;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                    fis = null;
                }
                if (bos != null) {
                    bos.close();
                    bos = null;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

.将Base64字符串解析到文件

/**
     * Base64编码String解析到文件
     *
     * @param context
     * @param content
     * @param dirPath
     * @param fileName
     * @return
     */
    public static boolean decode2FileByBase64(Context context, String content,
            String dirPath, String fileName) {

        if (StringUtils.isEmpty(content) || StringUtils.isEmpty(dirPath)
                || StringUtils.isEmpty(fileName)) {
            return false;
        }
        File file = new File(dirPath, fileName);
        try {
            if (file.exists()) {
                file.deleteOnExit();
                file.createNewFile();
            } else {
                createNewDir(context, dirPath);
                file.createNewFile();
            }
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        byte[] buffer = Base64.decode(content, Base64.DEFAULT);
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            fos.write(buffer);
            fos.close();
            fos = null;
            return true;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                    fos = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

.XML解析

      xml文件存储是常用的数据存储方式，xml解析常用的有SAX解析、DOM解析、PULL解析等。在讲述xml解析之前先讲述一下xml的格式以及如何将实体类保存为xml文件。

  . xml的存储格式

<persons>
    <person id="23">
        <name>eboy</name>
        <age>22</age>
    </person>
    <person id="24">
        <name>Frr</name>
        <age>20</age>
    </person>
</persons>

.将实体类集合保存到xml文件

/**
     * 将数据保存到xml文件
     *
     * @param persons
     * @param savePath
     * @throws Exception
     */
    public static boolean writeToXML(List<Person> persons, String savePath) {

        if (savePath == null || savePath.equals("")) {
            Log.e(TAG, "请输入正确的保存路径！");
            return false;
        }

        FileOutputStream out = null;

        try {
            //创建保存文件.如果存在，则删除并新建文件
            File file = new File(savePath);
            file.deleteOnExit();
            file.createNewFile();
            out = new FileOutputStream(file);

        } catch (Exception e) {
            Log.e(TAG, "无效的文件路径！ " + e.getMessage());
            return false;
        }

        //创建XML序列化对象
        XmlSerializer serializer = Xml.newSerializer();
        //设置输出目标
        serializer.setOutput(out, "UTF-8");
        //开始解析
        serializer.startDocument("UTF-8", true);
        //设置开始根节点
        serializer.startTag(null, "persons");

        //将对象集合解析为节点
        for (Person person : persons) {

            // 开始解析父节点
            serializer.startTag(null, "person");
            serializer.attribute(null, "id", person.getId().toString()); //添加父节点属性

            // 子节点startTag/endTag要对称
            serializer.startTag(null, "name");
            serializer.text(person.getName().toString());//子节点值
            serializer.endTag(null, "name");

            serializer.startTag(null, "age");
            serializer.text(person.getAge().toString());
            serializer.endTag(null, "age");

            //结束解析父节点
            serializer.endTag(null, "person");
        }

        //设置结束根节点
        serializer.endTag(null, "persons");
        //解析结束
        serializer.endDocument();

        out.flush();
        out.close();
    }