很多时候在应用安装初始化时，需要创建本地数据库，同时为数据库添加数据，之后再从数据库中读取数据。

这里有2个思路

    1.先在本地创建一个能支持android使用的sqlite数据库文件,启动时,用现成的sqlite的二进制文件进行直接copy到Android系统的数据库路径

    2.可以考虑在第一次启动时,执行数据库初始化的sql文件.

1.在本地准备android能使用的sqlite数据库文件

使用sqlite数据库管理工具,看个人爱好(SQLite Database Browser ,Navicat Premium,)

打开数据库,创建"android_metadata"数据表

Sql代码

1. CREATE TABLE "android_metadata" ("_id"  INTEGER PRIMARY KEY AUTOINCREMENT,"locale" TEXT DEFAULT ‘en_US‘);//创建表  

2. INSERT INTO "android_metadata" VALUES (1,‘en_US‘);//插入值  

 创建其他应用需要的表..此处省略.

2.复制文件到应用中.

把第一步创建的数据库文件复制到应用中的assets文件夹, asserts文件夹的路径如下：

然后创建DateBaseHelper extends SQLiteOpenHelper的类文件.

代码如下:

Java代码

1. public class DataBaseHelper extends SQLiteOpenHelper {  
2.     //The Android‘s default system path of your application database.  
3.     private static String DB_PATH = "/data/data/YOUR_PACKAGE/databases/";  
4.     private static String DB_NAME = "myDBName";  
5.     private SQLiteDatabase myDataBase;  
6.     private final Context myContext;  
7.     /** 
8.      * Constructor 
9.      * Takes and keeps a reference of the passed context in order to access to the application assets and resources. 
10.      * @param context 
11.      */  
12.     public DataBaseHelper(Context context) {  
13.         super(context, DB_NAME, null, 1);  
14.         this.myContext = context;  
15.     }  
16.   
17.     /** 
18.      * Creates a empty database on the system and rewrites it with your own database. 
19.      * */  
20.     public void createDataBase()throws IOException {  
21.         boolean dbExist = checkDataBase();  
22.         if (dbExist) {  
23.             //do nothing - database already exist  
24.         } else {  
25.             //By calling this method and empty database will be created into the default system path  
26.             //of your application so we are gonna be able to overwrite that database with our database.  
27.             this.getReadableDatabase();  
28.             try {  
29.                 copyDataBase();  
30.             } catch (IOException e) {  
31.                 throw new Error("Error copying database");  
32.             }  
33.         }  
34.     }  
35.   
36.     /** 
37.      * Check if the database already exist to avoid re-copying the file each time you open the application. 
38.      * @return true if it exists, false if it doesn‘t 
39.      */  
40.     private boolean checkDataBase() {  
41.         SQLiteDatabase checkDB = null;  
42.         try {  
43.             String myPath = DB_PATH + DB_NAME;  
44.             checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);  
45.         } catch (SQLiteException e) {  
46.             //database does‘t exist yet.  
47.         }  
48.   
49.         if (checkDB != null) {  
50.             checkDB.close();  
51.         }  
52.         return checkDB != null ? true : false;  
53.     }  
54.   
55.     /** 
56.      * Copies your database from your local assets-folder to the just created empty database in the 
57.      * system folder, from where it can be accessed and handled. 
58.      * This is done by transfering bytestream. 
59.      * */  
60.     private void copyDataBase()throws IOException {  
61.         //Open your local db as the input stream  
62.         InputStream myInput = myContext.getAssets().open(DB_NAME);  
63.         // Path to the just created empty db  
64.         String outFileName = DB_PATH + DB_NAME;  
65.         //Open the empty db as the output stream  
66.         OutputStream myOutput = new FileOutputStream(outFileName);  
67.         //transfer bytes from the inputfile to the outputfile  
68.         byte[]buffer = new byte[1024];  
69.         int length;  
70.         while ((length = myInput.read(buffer)) > 0) {  
71.             myOutput.write(buffer, 0, length);  
72.         }  
73.   
74.         //Close the streams  
75.         myOutput.flush();  
76.         myOutput.close();  
77.         myInput.close();  
78.     }  
79.   
80.     public void openDataBase()throws SQLException {  
81.         //Open the database  
82.         String myPath = DB_PATH + DB_NAME;  
83.         myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);  
84.     }  
85.   
86.     @Override  
87.     public synchronized void close() {  
88.         if (myDataBase != null)  
89.             myDataBase.close();  
90.         super.close();  
91.     }  
92.   
93.     @Override  
94.     public void onCreate(SQLiteDatabase db) {}  
95.   
96.     @Override  
97.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {}  
98.     // Add your public helper methods to access and get content from the database.  
99.     // You could return cursors by doing "return myDataBase.query(....)" so it‘d be easy  
100.     // to you to create adapters for your views.  
101. }  
 
3.现在我们可以创建DateBaseHelper的实现操作了.
createDataBase() //创建
openDataBase()//打开只读数据库
记得要更改"YOUR_PACKAGE"为你的应用的包名
如:com.examplename.myapp
大概代码如下:
Java代码
1. ...  
2. DataBaseHelper myDbHelper = new DataBaseHelper();  
3. myDbHelper = new DataBaseHelper(this);  
4. try {  
5.     myDbHelper.createDataBase();  
6. } catch (IOException ioe) {  
7.     throw new Error("Unable to create database");  
8. }  
9. try {  
10.     myDbHelper.openDataBase();  
11. } catch (SQLException sqle) {  
12.     throw sqle;  
13. }  
14. ...

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标移动开发之Android频道！