Android 本地数据导入SQLite数据库，数据库复制到sd卡

1、本地数据导入SQLite数据库

如assets文件下的.db

 

package com.ms.mscode.db;

import android.app.Activity;
import android.content.Context;
import android.content.res.AssetManager;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.media.MediaScannerConnection;
import android.os.Environment;
import android.util.Log;

import com.ms.mscode.R;
import com.ms.mscode.util.FileUtils;

import org.xutils.common.util.FileUtil;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;

public class DatabaseUtil {
    public static final String TAG = "DatabaseUtil.java";
    private static final String DATABASE_PATH = "/data/data/com.ms.mscode/databases/";
    private static final String DATABASE_NAME = "caijima.db";
    private static final String DB_NAME = "caima.db";

    public static void writeFiletoSql(Activity mContext) {
        File fileDB = new File(DATABASE_PATH + DATABASE_NAME);
        if (fileDB.exists()) {
            fileDB.delete();
        }
        File file = new File(DATABASE_PATH);
        if (!file.exists())
            file.mkdirs();
        try {
            // 得到 assets 目录下我们实现准备好的 SQLite 数据库作为输入流
            InputStream is = mContext.getBaseContext().getAssets().open(DATABASE_NAME);
            OutputStream os = new FileOutputStream(DATABASE_PATH + DATABASE_NAME);
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) > 0) {
                os.write(buffer, 0, len);
            }
            os.flush();
            os.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * app的数据库复制到sd卡
     * @param mContext
     */
    public static void copySqltoFile(Activity mContext) {
        if (FileUtil.existsSdcard()) {
         String sqlPath= Environment.getExternalStorageDirectory()+"/sqlite.db";
            String dirPath = DATABASE_PATH + DATABASE_NAME;
            if(new File(dirPath).exists()){
                if(new File(sqlPath).exists()){
                    new File(sqlPath).delete();
                }
                boolean b = FileUtils.copyFile(DATABASE_PATH + DATABASE_NAME, sqlPath);
                if(b){
                    MediaScannerConnection.scanFile(mContext, new String[]{new File(sqlPath).getAbsolutePath()}, null, null);
                }
                Log.e("ReleaseDataBaseActivity", "dir made:" + b);
            }
        }
    }

    /**
     * 返回数据库
     * @param mContext
     * @return
     */
    public static SQLiteDatabase writeSqltoFile(Activity mContext) {
        try {
            String databaseFilename = DATABASE_PATH + DATABASE_NAME;
            File dir = new File(DATABASE_PATH);
            //判断SD卡下是否存在存放数据库的目录，如果不存在，新建目录
            if (!dir.exists()) {
                dir.mkdir();
                Log.i("ReleaseDataBaseActivity", "dir made:" + DATABASE_PATH);
            } else {
                Log.i("ReleaseDataBaseActivity", "dir exist:" + DATABASE_PATH);
            }
            try {
                //如果数据库已经在SD卡的目录下存在，那么不需要重新创建，否则创建文件，并拷贝/res/raw下面的数据库文件
                if (!new File(databaseFilename).exists()) {
                    new File(databaseFilename).delete();
                }
                Log.i("ReleaseDataBaseActivity", "file not exist:"
                        + databaseFilename);
                ///res/raw数据库作为输出流 DB_NAME
                InputStream is = mContext.getBaseContext().getAssets().open(DB_NAME);
//                    InputStream is = mContext.getResources().openRawResource(R.raw.db_exam);
                //测试用
                int size = is.available();
                Log.i("ReleaseDataBaseActivity", "DATABASE_SIZE:" + 1);
                Log.i("ReleaseDataBaseActivity", "count:" + 0);
                //用于存放数据库信息的数据流
                FileOutputStream fos = new FileOutputStream(
                        databaseFilename);
                byte[] buffer = new byte[8192];
                int count = 0;
                Log.i("ReleaseDataBaseActivity", "count:" + count);
                //把数据写入SD卡目录下
                while ((count = is.read(buffer)) > 0) {
                    fos.write(buffer, 0, count);
                }
                fos.flush();
                fos.close();
                is.close();
            } catch (FileNotFoundException e) {
                Log.e("Database", "File not found");
                e.printStackTrace();
            } catch (IOException e) {
                Log.e("Database", "IO exception");
                e.printStackTrace();
            }
            //实例化sd卡上得数据库，database作为返回值，是后面所有插入，删除，查询操作的借口。自己实现
            SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(databaseFilename, null);
            return database;

        } catch (Exception e) {
        }
        return null;
    }
}

 

package com.ms.mscode.util;

import android.util.Log;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * <pre>
 *     //                写入文件后，解决连接电脑文件不显示问题
 *                 File file = FileUtils.getFileByPath(file_path);
 *                 MediaScannerConnection.scanFile(mContext, new String[]{file.getAbsolutePath()}, null, null);
 *     author: Blankj
 *     blog  : http://blankj.com
 *     time  : 2016/8/11
 *     desc  : 文件相关工具类
 * </pre>
 */
public class FileUtils {

    private FileUtils() {
        throw new UnsupportedOperationException("u can't instantiate me...");
    }
    // 将字符串写入到文本文件中
    public static void writeTxtToFile(String strcontent, String filePath, String fileName) {
        //生成文件夹之后，再生成文件，不然会出错
        makeFilePath(filePath, fileName);
        String strFilePath = filePath+fileName;
        // 每次写入时，都换行写
        String strContent = strcontent + "\r\n";
        try {
            File file = new File(strFilePath);
            if (!file.exists()) {
                Log.d("TestFile", "Create the file:" + strFilePath);
                file.getParentFile().mkdirs();
                file.createNewFile();
            }
            RandomAccessFile raf = new RandomAccessFile(file, "rwd");
            raf.seek(file.length());
            raf.write(strContent.getBytes());
            raf.close();
        } catch (Exception e) {
            Log.e("TestFile", "Error on write File:" + e);
        }
    }

    // 生成文件

    /**
     * 文件目录
     * 文件名
     * @param filePath
     * @param fileName
     * @return
     */
    public static File makeFilePath(String filePath, String fileName) {
        File file = null;
        makeRootDirectory(filePath);
        try {
            file = new File(filePath + fileName);
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return file;
    }

 /*   // 生成文件夹*/

    /**
     *
     * @param filePath
     */
    public static void makeRootDirectory(String filePath) {
        File file = null;
        try {
            file = new File(filePath);
            if (!file.exists()) {
                file.mkdir();
            }
        } catch (Exception e) {
            Log.i("error:", e+"");
        }
    }


    /**
     * 根据文件路径获取文件
     *
     * @param filePath 文件路径
     * @return 文件
     */
    public static File getFileByPath(String filePath) {
        return StringUtils.isSpace(filePath) ? null : new File(filePath);
    }

    /**
     * 判断文件是否存在
     *
     * @param filePath 文件路径
     * @return {@code true}: 存在<br>{@code false}: 不存在
     */
    public static boolean isFileExists(String filePath) {
        return isFileExists(getFileByPath(filePath));
    }

    /**
     * 判断文件是否存在