安卓学习 Day25：使用SQLite数据库_sqlite 安卓使用案列

一、SQLite数据库管理工具

1、下载sqlite3

• 下载网址： http://www.sqlite.org/download.html
  
  

2、解压到指定目录

• 修改目录名为 - sqlite3
  

3、使用sqlite3操作数据库及表

• 打开命令提示符，进入 sqlite3目录
  
• 输入命令，创建数据库 - student.db（如果数据库存在，则会打开数据库）
  
• 查看全部数据库
  
• 创建学生表 - stu
  
• 查看表结构
  
• 插入表记录
  
• 查看表记录
  
• 更新表记录 - 将“戴沐白”改为“奥斯卡”’
  
• 删除记录 - 删除id为2的记录
  
• 删除学生表
  
• 帮助命令
  
• 重新创建学生表并插入记录
  

4、使用数据可视化管理工具 - Navicat

（1）打开Navicat工具

（2）新建连接 - 选择SQLite

（3）输入连接名

（4）添加数据库文件

（5）点击确定

（6）打开学生表

（7）新建查询，进行查询操作

二、案例演示 - 使用SQLiteDatabase类操作数据库

1、创建安卓应用

2、添加背景图片

3、字符串资源文件 - strings.xml

<resources>
    <string name="app_name">创建和删除数据库</string>
    <string name="create_db">创建数据库</string>
    <string name="delete_db">删除数据库</string>
</resources>
1
2
3
4
5

4、主布局资源文件 - activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/background"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btnCreateDB"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doCreateDB"
        android:text="@string/create_db"
        android:textSize="20dp" />

    <Button
        android:id="@+id/btnDeleteDB"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doDeleteDB"
        android:text="@string/delete_db"
        android:textSize="20dp" />
</LinearLayout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5、主界面类 - MainActivity

package net.zs.create_dalete_db;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    private static final String DB_NAME_PREFIX = "student"; // 数据库名前缀
    private static final int MODE = Context.MODE_PRIVATE; // 文件访问模式
    private int count; // 数据库计数器
    private SQLiteDatabase db; // SQLite数据库

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 利用布局资源文件设置用户界面
        setContentView(R.layout.activity_main);

        // 获取应用当前数据库个数
        count = databaseList().length;
    }

    /**
     * 创建数据库
     */
    public void doCreateDB(View view) {
        // 数据库计数器累加
        count++;
        // 定义数据库名
        String dbname = DB_NAME_PREFIX + count + ".db";
        try {
            // 打开或创建数据库
            db = openOrCreateDatabase(dbname, MODE, null);
            // 提示用户创建成功
            Toast.makeText(this, "恭喜，数据库【" + dbname + "】创建成功！", Toast.LENGTH_SHORT).show();
        } catch (Exception e) {
            // 提示用户创建失败
            Toast.makeText(this, "遗憾，数据库【" + dbname + "】创建失败！", Toast.LENGTH_SHORT).show();
        }

    }

    /**
     * 删除数据库（删除全部数据库）
     */
    public void doDeleteDB(View view) {
        // 获取数据库名数组
        String[] dbnames = databaseList();
        // 判断是否有数据库可删除
        if (dbnames.length > 0) {
            // 遍历数组，删除对应的数据库
            for (int i = 0; i < dbnames.length; i++) {
                // 按照名称删除数据库
                deleteDatabase(dbnames[i]);
            }
            // 数据库计数器清零
            count = 0;
            // 提示用户删除成功
            Toast.makeText(this, "恭喜，数据库全部被删除！", Toast.LENGTH_SHORT).show();
        } else {
            // 提示用户没有数据库可删除
            Toast.makeText(this, "遗憾，没有数据库可删除！", Toast.LENGTH_SHORT).show();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

6、运行程序，查看效果

三、案例演示 - 使用SQLiteDatabase类操作数据表

1、创建安卓应用

2、添加背景图片

3、字符串资源文件 - strings.xml

<resources>
    <string name="app_name">利用SQLiteDatabase操作数据表</string>
    <string name="create_or_open_db">创建或打开数据库</string>
    <string name="create_table">创建表</string>
    <string name="add_record">添加表记录</string>
    <string name="update_record">更新表记录</string>
    <string name="display_all_records">显示全部表记录</string>
    <string name="delete_all_records">删除全部表记录</string>
    <string name="delete_table">删除表</string>
    <string name="delete_db">删除数据库</string>
</resources>
1
2
3
4
5
6
7
8
9
10
11

4、主布局资源文件 - activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/background"
    android:gravity="center"
    android:orientation="vertical"
    android:padding="10dp" >

    <Button
        android:id="@+id/btnCreateOrOpenDB"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doCreateOrOpenDB"
        android:text="@string/create_or_open_db" />

    <Button
        android:id="@+id/btnCreateTable"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doCreateTable"
        android:text="@string/create_table" />

    <Button
        android:id="@+id/btnAddRecord"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doAddRecord"
        android:text="@string/add_record" />

    <Button
        android:id="@+id/btnUpdateRecord"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doUpdateRecord"
        android:text="@string/update_record" />

    <Button
        android:id="@+id/btnDisplayAllRecords"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doDisplayAllRecords"
        android:text="@string/display_all_records" />

    <Button
        android:id="@+id/btnDeleteAllRecords"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doDeleteAllRecords"
        android:text="@string/delete_all_records" />

    <Button
        android:id="@+id/btnDeleteTable"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doDeleteTable"
        android:text="@string/delete_table" />

    <Button
        android:id="@+id/btnDeleteDB"
        android:layout_width="200dp"
        android:layout_height="wrap_content"
        android:onClick="doDeleteDB"
        android:text="@string/delete_db" />
</LinearLayout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

5、主界面类 - MainActivity

package net.zs.operate_table;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    private final String DB_NAME = "student.db"; // 数据库名
    private final String TABLE_NAME = "student"; // 表名
    private final int MODE = Context.MODE_PRIVATE; // 访问模式
    private SQLiteDatabase db; // SQLite数据库
    private int id; // 学号

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /**
     * 创建或打开数据库
     */
    public void doCreateOrOpenDB(View view) {
        // 判断数据库是否存在
        if (databaseList().length == 0) {
            // 创建数据库
            db = openOrCreateDatabase(DB_NAME, MODE, null);
            // 提示用户数据库创建成功
            Toast.makeText(this, "恭喜，数据库【" + DB_NAME + "】创建成功！", Toast.LENGTH_SHORT).show();
        } else {
            // 打开数据库
            db = openOrCreateDatabase(DB_NAME, MODE, null);
            // 提示用户数据库打开成功
            Toast.makeText(this, "恭喜，数据库【" + DB_NAME + "】打开成功！", Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * 创建表
     */
    public void doCreateTable(View view) {
        // 判断数据库对象是否为空
        if (db == null) {
            // 判断数据库是否存在
            if (databaseList().length == 0) {
                Toast.makeText(this, "请创建数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "请打开数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            }
        } else {
            // 判断表是否存在
            if (isTableExisted(TABLE_NAME)) {
                // 弹出吐司提示用户表已经存在
                Toast.makeText(this, "表【" + TABLE_NAME + "】已经存在！", Toast.LENGTH_SHORT).show();
            } else {
                try {
                    // 定义SQL字符串
                    String strSQL = "CREATE TABLE " + TABLE_NAME + "(id integer, name text, gender text)";
                    // 执行SQL语句
                    db.execSQL(strSQL);
                    // 提示用户创建表成功
                    Toast.makeText(this, "创建表成功！", Toast.LENGTH_SHORT).show();
                } catch (SQLException e) {
                    // 提示用户创建表失败
                    Toast.makeText(this, "创建表失败！", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }

    /**
     * 判断表是否存在
     *
     * @param tableName
     * @return true 表存在; false 表不存在
     */
    private boolean isTableExisted(String tableName) {
        // 定义SQL字符串
        String strSQL = "SELECT * FROM sqlite_master WHERE type = ? AND name = ?";
        // 执行SQL查询，返回游标
        Cursor cursor = db.rawQuery(strSQL, new String[]{"table", tableName});
        // 判断游标里是否有记录
        if (cursor.getCount() > 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 添加表记录
     */
    public void doAddRecord(View view) {
        // 判断数据库对象是否存在
        if (db == null) {
            // 判断数据库是否存在
            if (databaseList().length == 0) {
                Toast.makeText(this, "请创建数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "请打开数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            }
        } else {
            // 判断表是否存在
            if (isTableExisted(TABLE_NAME)) {
                // 获取新记录的学号
                id = getNewId(TABLE_NAME);
                // 创建内容值对象
                ContentValues values = new ContentValues();
                // 以键值对方式添加字段数据
                values.put("id", id);
                values.put("name", "学生" + id);
                values.put("gender", id % 2 == 1 ? "男" : "女");
                // 将数据插入表中
                long count = db.insert(TABLE_NAME, null, values);
                if (count != -1) {
                    // 弹出吐司提示用户添加成功
                    Toast.makeText(this, "恭喜，表记录添加成功！", Toast.LENGTH_SHORT).show();
                } else {
                    // 弹出吐司提示用户添加失败
                    Toast.makeText(this, "遗憾， 表记录添加失败！", Toast.LENGTH_SHORT).show();
                }
            } else {
                // 提示用户先创建表
                Toast.makeText(this, "表【" + TABLE_NAME + "】不存在，请先创建!", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 获取新记录的学号
     *
     * @param tableName
     * @return
     */
    private int getNewId(String tableName) {
        // 判断表是否存在
        if (isTableExisted(tableName)) {
            // 查询全部表记录，返回游标
            Cursor cursor = db.query(tableName, null, null, null, null, null, null);
            // 移到最后一条记录
            if (cursor.moveToLast()) {
                // 获取最后一条记录的id
                int id = cursor.getInt(0);
                // 返回新记录的id
                return id + 1;
            }
        }
        return 1;
    }

    /**
     * 更新表记录
     */
    public void doUpdateRecord(View view) {
        // 判断数据库对象是否为空
        if (db == null) {
            // 判断数据库是否存在
            if (databaseList().length == 0) {
                Toast.makeText(this, "请创建数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "请打开数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            }
        } else {
            // 判断表是否存在
            if (isTableExisted(TABLE_NAME)) {
                // 判断是否有表记录
                if (getRecordCount(TABLE_NAME) > 0) {
                    // 定义SQL字符串
                    String strSQL = "UPDATE " + TABLE_NAME + " SET name = ?, gender = ? WHERE id = ?";
                    try {
                        // 执行SQL， 返回更新表记录
                        db.execSQL(strSQL, new Object[]{"张晓芸", "女", 1});
                        // 提示用户更新表记录成功
                        Toast.makeText(this, "恭喜，表记录更新成功！", Toast.LENGTH_SHORT).show();
                    } catch (SQLException e) {
                        // 提示用户更新记录失败
                        Toast.makeText(this, "遗憾，表记录更新失败！", Toast.LENGTH_SHORT).show();
                    }
                } else {
                    // 弹出吐司提示用户没有表记录
                    Toast.makeText(this, "没有表记录可更新，请先添加表记录!", Toast.LENGTH_SHORT).show();
                }
            } else {
                // 提示用户先创建表
                Toast.makeText(this, "表【" + TABLE_NAME + "】不存在，请先创建！", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 返回表记录
     *
     * @param table_name
     * @return 表记录数
     */
    private int getRecordCount(String table_name) {
        // 定义SQL字符串
        String strSQL = "SELECT * FROM " + table_name;
        // 执行SQL，返回游标
        Cursor cursor = db.rawQuery(strSQL, null);
        // 返回记录数
        return cursor.getCount();
    }

    /**
     * 显示全部表记录
     */
    public void doDisplayAllRecords(View view) {
        // 判断数据库对象是否为空
        if (db == null) {
            // 判断数据库是否存在
            if (databaseList().length == 0) {
                Toast.makeText(this, "请创建数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "请打开数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            }
        } else {
            // 判断表是否存在
            if (isTableExisted(TABLE_NAME)) {
                // 判断表里是否有记录
                if (getRecordCount(TABLE_NAME) > 0) {
                    // 定义SQL字符串
                    String strSQL = "SELECT * FROM " + TABLE_NAME;
                    // 执行SQL，返回游标
                    Cursor cursor = db.query(TABLE_NAME, null, null, null, null, null, null);
                    // 定义字符串生成器
                    StringBuilder builder = new StringBuilder();
                    // 遍历游标对象（记录集）
                    while (cursor.moveToNext()) {
                        // 将每条记录信息组合之后添加到字符串生成器
                        builder.append(cursor.getInt(0) + " " + cursor.getString(1) + " " + cursor.getString(2) + "\n");
                    }
                    // 弹出吐司显示全部学生记录
                    Toast.makeText(this, "全部表记录\n\n" + builder.toString(), Toast.LENGTH_SHORT).show();
                } else {
                    // 弹出吐司提示用户没有表记录
                    Toast.makeText(this, "没有表记录可显示，请先添加表记录！", Toast.LENGTH_SHORT).show();
                }
            } else {
                // 提示用户先创建表
                Toast.makeText(this, "表【" + TABLE_NAME + "】不存在，请先创建！", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 删除全部表记录（三个层面的判断）
     */
    public void doDeleteAllRecords(View view) {
        // 判断数据库对象是否存在
        if (db == null) {
            // 判断数据库是否存在
            if (databaseList().length == 0) {
                Toast.makeText(this, "请创建数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "请打开数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            }
        } else {
            // 判断表是否存在
            if (isTableExisted(TABLE_NAME)) {
                // 判断是否有记录
                if (getRecordCount(TABLE_NAME) > 0) {
                    // 定义SQL字符串
                    String strSQL = "DELETE FROM " + TABLE_NAME;
                    try {
                        // 执行SQL，删除表记录
                        db.execSQL(strSQL);
                        // 提示用户删除表记录成功
                        Toast.makeText(this, "全部表记录已删除！", Toast.LENGTH_SHORT).show();
                    } catch (SQLException e) {
                        // 提示用户删除表记录失败
                        Toast.makeText(this, "删除表记录失败！", Toast.LENGTH_SHORT).show();
                    }
                } else {
                    // 弹出吐司提示用户没有表记录
                    Toast.makeText(this, "没有表记录可删除，请先添加记录！", Toast.LENGTH_SHORT).show();
                }
            } else {
                // 提示用户先创建表
                Toast.makeText(this, "表【" + TABLE_NAME + "】不存在，请先创建！", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 删除表
     */
    public void doDeleteTable(View view) {
        // 判断数据库对象是否存在
        if (db == null) {
            // 判断数据库是否存在
            if (databaseList().length == 0) {
                Toast.makeText(this, "请创建数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "请打开数据库【" + DB_NAME + "】。", Toast.LENGTH_SHORT).show();
            }
        } else {
            // 判断表是否存在
            if (isTableExisted(TABLE_NAME)) {
                // 定义SQL字符串
                String strSQL = "DROP TABLE " + TABLE_NAME;
                try {
                    // 执行SQL，删除表
                    db.execSQL(strSQL);
                    // 提示用户表删除成功
                    Toast.makeText(this, "表删除成功！", Toast.LENGTH_SHORT).show();
                } catch (SQLException e) {
                    // 提示用户表删除失败
                    Toast.makeText(this, "表删除失败！", Toast.LENGTH_SHORT).show();
                }
            } else {
                // 提示用户先创建表
                Toast.makeText(this, "表【" + TABLE_NAME + "】不存在，请先创建！", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 删除数据库
     */
    public void doDeleteDB(View view) {
        // 判断数据库是否存在
        if (databaseList().length == 0) {
            // 提示用户没有数据库
            Toast.makeText(this, "没有数据库可删除！", Toast.LENGTH_SHORT).show();
        } else {
            // 判断数据库删除是否成功
            if (deleteDatabase(DB_NAME)) {
                // 提示用户删除成功
                Toast.makeText(this, "数据库【" + DB_NAME + "】删除成功！", Toast.LENGTH_SHORT).show();
            } else {
                // 提示用户删除失败
                Toast.makeText(this, "数据库【" + DB_NAME + "】删除失败！", Toast.LENGTH_SHORT).show();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345

6、运行程序，查看效果

四、案例演示 - 手机联系人（采用SQLite数据库）

1、创建安卓应用

2、添加背景图片

3、主布局资源文件 - activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/background"
    android:orientation="vertical"
    android:padding="15dp"
    tools:context=".MainActivity">

    <ListView
        android:id="@+id/lvContact"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">        
    </ListView>
</LinearLayout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、自定义数据库助手类

• 创建 - DBHelper类
  
• 源代码

package net.zs.sqlite_contacts;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.widget.Toast;

import androidx.annotation.Nullable;

public class DBHelper extends SQLiteOpenHelper {

    private Context context; // 上下文环境
    private static final String DB_NAME = "contact.db"; // 数据库名
    private static final int DB_VERSION = 1; // 数据库版本号
    private static final String TABLE_NAME = "contact"; // 表名

    public DBHelper(@Nullable Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    /**
     * 创建回调方法，只有当数据库不存在时才会被调用
     * @param db
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建数据表
        createTable(db, TABLE_NAME);
        // 添加表记录
        addRecords(db, TABLE_NAME);
    }

    /**
     * 创建数据表
     * @param db
     * @param tableName
     */
    private void createTable(SQLiteDatabase db, String tableName) {
        // 定义SQL字符串
        String strSQL = "create table " + tableName + "(_id text, name text, gender text, age integer, telephone text)";
        try {
            // 执行SQL，创建数据表
            db.execSQL(strSQL);
        } catch (SQLException e) {
            Toast.makeText(context, "遗憾，建表失败！", Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * 添加表记录
     * @param db
     * @param tableName
     */
    private void addRecords(SQLiteDatabase db, String tableName) {
        // 创建内容值对象
        ContentValues values = new ContentValues();

        // 将第1条记录信息放入内容值对象
        values.put("_id", "2020001");
        values.put("name", "李小文");
        values.put("gender", "男");
        values.put("age", 19);
        values.put("telephone", "15878786780");
        // 利用数据库对象的插入方法，插入第1条记录
        db.insert(tableName, null, values);

        // 将第2条记录信息放入内容值对象
        values.put("_id", "2020002");
        values.put("name", "韩玉玲");
        values.put("gender", "女");
        values.put("age", 20);
        values.put("telephone", "15845678907");
        // 利用数据库对象的插入方法，插入第2条记录
        db.insert(tableName, null, values);

        // 将第3条记录信息放入内容值对象
        values.put("_id", "2020003");
        values.put("name", "唐语涵");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "13978789089");
        // 利用数据库对象的插入方法，插入第3条记录
        db.insert(tableName, null, values);

        // 将第4条记录信息放入内容值对象
        values.put("_id", "2020004");
        values.put("name", "董翔宇");
        values.put("gender", "男");
        values.put("age", 20);
        values.put("telephone", "15823234567");
        // 利用数据库对象的插入方法，插入第4条记录
        db.insert(tableName, null, values);

        // 将第5条记录信息放入内容值对象
        values.put("_id", "2020005");
        values.put("name", "郑文佳");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "13978781234");
        // 利用数据库对象的插入方法，插入第5条记录
        db.insert(tableName, null, values);

        // 将第6条记录信息放入内容值对象
        values.put("_id", "2020006");
        values.put("name", "伍子胥");
        values.put("gender", "男");
        values.put("age", 20);
        values.put("telephone", "15878786780");
        // 利用数据库对象的插入方法，插入第6条记录
        db.insert(tableName, null, values);

        // 将第7条记录信息放入内容值对象
        values.put("_id", "2020007");
        values.put("name", "南怀瑾");
        values.put("gender", "男");
        values.put("age", 18);
        values.put("telephone", "13956567862");
        // 利用数据库对象的插入方法，插入第7条记录
        db.insert(tableName, null, values);

        // 将第8条记录信息放入内容值对象
        values.put("_id", "2020008");
        values.put("name", "李文华");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "15956567845");
        // 利用数据库对象的插入方法，插入第8条记录
        db.insert(tableName, null, values);

        // 将第9条记录信息放入内容值对象
        values.put("_id", "2020009");
        values.put("name", "吴文渊");
        values.put("gender", "男");
        values.put("age", 20);
        values.put("telephone", "13978784560");
        // 利用数据库对象的插入方法，插入第8条记录
        db.insert(tableName, null, values);

        // 将第10条记录信息放入内容值对象
        values.put("_id", "2020010");
        values.put("name", "陈燕文");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "15890903456");
        // 利用数据库对象的插入方法，插入第10条记录
        db.insert(tableName, null, values);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    /**
     * 查询方法
     */
    public Cursor query(String tableName, String[] columns, String selection, String[] selectionArgs) {
        // 获取只读数据库
        SQLiteDatabase db = getReadableDatabase();
        // 执行数据库查询方法，返回游标对象
        return db.query(tableName, columns, selection, selectionArgs, null, null, null, null);
    }

    /**
     * 删除方法
     */
    public int delete(String tableName, String whereClause, String[] whereArgs) {
        // 获取可写数据库
        SQLiteDatabase db = getWritableDatabase();
        // 执行数据库删除方法，返回删除记录数
        return db.delete(tableName, whereClause, whereArgs);
    }

    /**
     * 更新方法
     */
    public int update(String tableName, ContentValues values, String whereClause, String[] whereArgs) {
        // 获取可写数据库
        SQLiteDatabase db = getWritableDatabase();
        // 执行数据库更新方法，返回更新记录数
        return db.update(tableName, values, whereClause, whereArgs);
    }

    /**
     * 插入方法
     */
    public long insert(String tableName, ContentValues values) {
        // 获取可写数据库
        SQLiteDatabase db = getWritableDatabase();
        // 执行数据库插入方法，返回插入记录数
        return db.insert(tableName, null, values);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

5、主界面类 - MainActivity

package net.zs.sqlite_contacts;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.widget.Toast;

import androidx.annotation.Nullable;

public class DBHelper extends SQLiteOpenHelper {

    private Context context; // 上下文环境
    private static final String DB_NAME = "contact.db"; // 数据库名
    private static final int DB_VERSION = 1; // 数据库版本号
    private static final String TABLE_NAME = "contact"; // 表名

    public DBHelper(@Nullable Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    /**
     * 创建回调方法，只有当数据库不存在时才会被调用
     * @param db
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建数据表
        createTable(db, TABLE_NAME);
        // 添加表记录
        addRecords(db, TABLE_NAME);
    }

    /**
     * 创建数据表
     * @param db
     * @param tableName
     */
    private void createTable(SQLiteDatabase db, String tableName) {
        // 定义SQL字符串
        String strSQL = "create table " + tableName + "(_id text, name text, gender text, age integer, telephone text)";
        try {
            // 执行SQL，创建数据表
            db.execSQL(strSQL);
        } catch (SQLException e) {
            Toast.makeText(context, "遗憾，建表失败！", Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * 添加表记录
     * @param db
     * @param tableName
     */
    private void addRecords(SQLiteDatabase db, String tableName) {
        // 创建内容值对象
        ContentValues values = new ContentValues();

        // 将第1条记录信息放入内容值对象
        values.put("_id", "2020001");
        values.put("name", "李小文");
        values.put("gender", "男");
        values.put("age", 19);
        values.put("telephone", "15878786780");
        // 利用数据库对象的插入方法，插入第1条记录
        db.insert(tableName, null, values);

        // 将第2条记录信息放入内容值对象
        values.put("_id", "2020002");
        values.put("name", "韩玉玲");
        values.put("gender", "女");
        values.put("age", 20);
        values.put("telephone", "15845678907");
        // 利用数据库对象的插入方法，插入第2条记录
        db.insert(tableName, null, values);

        // 将第3条记录信息放入内容值对象
        values.put("_id", "2020003");
        values.put("name", "唐语涵");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "13978789089");
        // 利用数据库对象的插入方法，插入第3条记录
        db.insert(tableName, null, values);

        // 将第4条记录信息放入内容值对象
        values.put("_id", "2020004");
        values.put("name", "董翔宇");
        values.put("gender", "男");
        values.put("age", 20);
        values.put("telephone", "15823234567");
        // 利用数据库对象的插入方法，插入第4条记录
        db.insert(tableName, null, values);

        // 将第5条记录信息放入内容值对象
        values.put("_id", "2020005");
        values.put("name", "郑文佳");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "13978781234");
        // 利用数据库对象的插入方法，插入第5条记录
        db.insert(tableName, null, values);

        // 将第6条记录信息放入内容值对象
        values.put("_id", "2020006");
        values.put("name", "伍子胥");
        values.put("gender", "男");
        values.put("age", 20);
        values.put("telephone", "15878786780");
        // 利用数据库对象的插入方法，插入第6条记录
        db.insert(tableName, null, values);

        // 将第7条记录信息放入内容值对象
        values.put("_id", "2020007");
        values.put("name", "南怀瑾");
        values.put("gender", "男");
        values.put("age", 18);
        values.put("telephone", "13956567862");
        // 利用数据库对象的插入方法，插入第7条记录
        db.insert(tableName, null, values);

        // 将第8条记录信息放入内容值对象
        values.put("_id", "2020008");
        values.put("name", "李文华");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "15956567845");
        // 利用数据库对象的插入方法，插入第8条记录
        db.insert(tableName, null, values);

        // 将第9条记录信息放入内容值对象
        values.put("_id", "2020009");
        values.put("name", "吴文渊");
        values.put("gender", "男");
        values.put("age", 20);
        values.put("telephone", "13978784560");
        // 利用数据库对象的插入方法，插入第8条记录
        db.insert(tableName, null, values);

        // 将第10条记录信息放入内容值对象
        values.put("_id", "2020010");
        values.put("name", "陈燕文");
        values.put("gender", "女");
        values.put("age", 18);
        values.put("telephone", "15890903456");
        // 利用数据库对象的插入方法，插入第10条记录
        db.insert(tableName, null, values);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    /**
     * 查询方法
     */
    public Cursor query(String tableName, String[] columns, String selection, String[] selectionArgs) {
        // 获取只读数据库
        SQLiteDatabase db = getReadableDatabase();
        // 执行数据库查询方法，返回游标对象
        return db.query(tableName, columns, selection, selectionArgs, null, null, null, null);
    }

    /**
     * 删除方法
     */
    public int delete(String tableName, String whereClause, String[] whereArgs) {
        // 获取可写数据库
        SQLiteDatabase db = getWritableDatabase();
        // 执行数据库删除方法，返回删除记录数
        return db.delete(tableName, whereClause, whereArgs);
    }

    /**
     * 更新方法
     */
    public int update(String tableName, ContentValues values, String whereClause, String[] whereArgs) {
        // 获取可写数据库
        SQLiteDatabase db = getWritableDatabase();
        // 执行数据库更新方法，返回更新记录数
        return db.update(tableName, values, whereClause, whereArgs);
    }

    /**
     * 插入方法
     */
    public long insert(String tableName, ContentValues values) {
        // 获取可写数据库
        SQLiteDatabase db = getWritableDatabase();
        // 执行数据库插入方法，返回插入记录数
        return db.insert(tableName, null, values);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

6、运行程序，查看效果