Android数据库操作入门及实践示例

SQLite是一个轻量级的数据库系统，它不依赖于服务器或系统管理员，可以直接嵌入应用程序中。它是世界上使用最广泛的数据库引擎，特别适用于移动和嵌入式系统。

蔓红荔

1079人浏览 · 2025-08-14 15:36:52

蔓红荔 · 2025-08-14 15:36:52 发布

简介：在Android应用开发中，数据库扮演着存储和管理数据的关键角色。本文将逐步引导初学者理解如何在Android平台上使用SQLite数据库，包括其介绍、创建数据库与表、进行数据库操作，以及如何使用外部JDBC驱动连接MySQL数据库。重点涵盖了 SQLiteOpenHelper 类的使用、SQL语句的执行以及数据的增删改查等操作，并提供了实际的代码示例和步骤说明，帮助开发者掌握安卓应用中数据库操作的核心技能。
安卓数据库连接

1. SQLite数据库概述

SQLite简介

数据库特点

SQLite具有跨平台、无需配置、易于部署、支持标准SQL语法等特点，非常适合小型应用程序或者是在系统资源受限的环境下使用。

应用场景

由于SQLite的轻便性，它通常用于个人项目、小型应用程序、原型开发和测试环境中。它也被广泛应用于移动操作系统如Android和iOS中，作为数据存储的解决方案。

graph LR
    A[SQLite数据库] -->|嵌入式应用| B(小型项目)
    A -->|跨平台| C(移动应用)
    A -->|无需配置| D(原型开发)
    A -->|资源受限| E(测试环境)

SQLite的这些特性使得它在IT行业中拥有广泛的吸引力，无论是初学者还是经验丰富的开发者，都能快速上手并应用于实际项目中。

2. SQLite数据库创建与表结构设计

在现代数据驱动的应用开发中，数据库的设计与创建是不可或缺的基础。SQLite作为一种轻量级的数据库，由于其无需单独服务器进程和易于使用的特性，被广泛应用于移动应用和小型项目中。在本章中，我们将详细介绍SQLite数据库的创建和表结构设计的方法，以及一些优化技巧。

2.1 数据库的创建与配置

2.1.1 SQLite数据库的创建方法

SQLite数据库的创建通常通过编程语言中的数据库操作接口进行。对于Android开发而言，这是通过SQLiteOpenHelper类实现的。而对于其他环境，可以使用命令行工具 sqlite3 或相应编程语言提供的库函数。

以下是使用命令行工具 sqlite3 在Linux环境下创建SQLite数据库的示例：

sqlite3 mydatabase.db

这条命令会创建一个名为 mydatabase.db 的新数据库文件。如果文件已存在，命令会打开已存在的数据库文件供操作。

2.1.2 数据库的配置与优化

数据库创建后，通常需要进行配置和优化，以便满足应用的需求。这包括但不限于设置数据库缓存大小、启用或禁用某些特性等。对于SQLite，这些配置可以通过PRAGMA语句来实现。

PRAGMA cache_size = 2000; -- 设置数据库缓存大小为2000页
PRAGMA journal_mode = wal; -- 设置日志模式为wal模式，提升写入性能

数据库配置与优化是一个持续的过程，需要根据应用运行情况不断调整，以达到最佳性能。

2.2 表结构的设计原则

2.2.1 设计良好的表结构重要性

设计良好的表结构能够提升数据查询的效率，减少数据冗余，确保数据的完整性。表结构设计是数据库设计的核心内容，它直接影响到数据库的性能和可维护性。

在设计表结构时，应遵循第三范式，确保每个表都有一个主键，并且其他字段都依赖于主键。同时，尽量减少字段的数据类型大小，避免使用动态数据类型如 TEXT 和 BLOB 。

2.2.2 主键、外键、索引的应用

主键是用来唯一标识表中每一行记录的字段。在SQLite中，每张表都应该有一个主键。通常使用自增的整数字段作为主键。

外键用于在不同表的记录之间创建链接，它在一个表中是另一张表的主键的引用。通过外键，我们可以维护表之间的数据一致性。

索引是一种数据结构，它能够提高数据检索的速度。索引对于经常用于查询条件的字段特别有用，如搜索、排序操作。

以下是创建表并添加索引的示例SQL语句：

CREATE TABLE employees (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    department_id INTEGER,
    FOREIGN KEY(department_id) REFERENCES departments(id)
);

CREATE INDEX idx_employee_name ON employees(name);

在这个例子中，我们创建了一个 employees 表，并为 name 字段创建了一个索引。这样的设计能有效提升查询 employees 表中特定名字的记录的效率。

2.3 设计实践

在设计实践方面，需要考虑数据模型的完整性、性能以及易维护性。接下来，我们将通过具体的代码示例，深入探讨如何在SQLite中创建表、配置数据库以及如何通过主键、外键和索引优化表结构设计。

实践案例

创建表并添加索引

-- 创建一个名为`books`的表，并为其主要字段添加索引以提升查询效率。
CREATE TABLE IF NOT EXISTS books (
    book_id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    author TEXT NOT NULL,
    publisher TEXT NOT NULL,
    publish_date DATE NOT NULL,
    isbn TEXT NOT NULL UNIQUE
);

-- 为书籍标题创建索引，以便快速检索。
CREATE INDEX idx_books_title ON books(title);

通过创建 books 表和 idx_books_title 索引，我们保证了可以通过书籍标题快速地检索数据，同时，由于为 isbn 字段设置了 UNIQUE 约束，还保证了ISBN码的唯一性。

设计外键关系

-- 创建一个名为`authors`的表，用于存储作者信息，并通过外键与`books`表建立联系。
CREATE TABLE IF NOT EXISTS authors (
    author_id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    bio TEXT
);

-- 修改`books`表，添加一个外键指向`authors`表的主键。
ALTER TABLE books ADD COLUMN author_id INTEGER;
ALTER TABLE books ADD CONSTRAINT fk_books_authors FOREIGN KEY(author_id) REFERENCES authors(author_id);

在这个案例中，我们为 books 表添加了一个 author_id 字段，这个字段用作外键指向 authors 表的主键。这样的设计允许我们在查询书籍信息时，同时获取关联的作者信息。

小结

在本章中，我们详细讨论了SQLite数据库的创建方法和配置技巧，以及如何设计良好的表结构。我们学习了主键、外键和索引在表设计中的重要性和实际应用。这些都是高效运行SQLite数据库的基础。在接下来的章节中，我们将继续深入数据库操作的各个方面，从基础到进阶，向您展示如何在不同场景下应用SQLite。

3. SQLite数据库操作

3.1 打开和关闭数据库

3.1.1 使用SQLiteDatabase类操作数据库

SQLite数据库作为嵌入式数据库，其操作主要通过 SQLiteDatabase 类实现。 SQLiteDatabase 类提供了丰富的API来执行SQL语句，管理数据库的打开和关闭，以及事务处理等功能。在Android开发中，通过调用 openOrCreateDatabase 方法可以打开或创建数据库。

SQLiteDatabase db = null;
try {
    db = this.getWritableDatabase();
} catch (SQLiteException e) {
    Log.e("DB ERROR", e.getMessage());
}

在上述代码中， getWritableDatabase 尝试打开数据库，如果数据库不存在则创建一个新的数据库文件。如果操作成功， SQLiteDatabase 对象 db 将会非空。需要注意的是，所有数据库操作都应在异常处理中进行，以确保应用的稳定性。数据库操作完毕后，调用 close 方法来关闭数据库，释放资源。

3.1.2 确保数据库安全性地打开和关闭

数据库的打开和关闭需要考虑异常安全和资源管理。推荐使用 try-with-resources 语句来自动管理资源，或者确保在 finally 块中调用 close 方法，以防止内存泄漏。

SQLiteDatabase db = null;
try {
    db = this.getReadableDatabase();
    // 执行数据库操作
} catch (SQLiteException e) {
    Log.e("DB ERROR", e.getMessage());
} finally {
    if (db != null && db.isOpen()) {
        db.close();
    }
}

在实际应用中，还可以结合 SQLiteOpenHelper 类来更优雅地管理数据库的打开和关闭。 SQLiteOpenHelper 类封装了对数据库创建和版本管理的逻辑，能够确保在多线程环境下，数据库的打开和关闭操作是线程安全的。

3.2 执行SQL语句

3.2.1 INSERT、UPDATE、DELETE语句的执行

执行基本的数据库操作，如插入、更新、删除（CRUD操作），需要通过 SQLiteDatabase 类提供的 execSQL 或者 rawQuery 方法来实现。在执行这些操作时，需要确保传递的SQL语句是安全的，避免SQL注入攻击。

try {
    db.execSQL("INSERT INTO Users (name, age) VALUES ('Alice', 30)");
    db.execSQL("UPDATE Users SET age = age + 1 WHERE name = 'Alice'");
    db.execSQL("DELETE FROM Users WHERE name = 'Bob'");
} catch (SQLiteException e) {
    Log.e("SQL ERROR", e.getMessage());
}

上述代码中，使用 execSQL 方法直接执行了插入（INSERT）、更新（UPDATE）和删除（DELETE）操作。每次操作之后，都应当捕获异常，并记录错误信息。对于复杂的SQL操作，使用参数化的查询（ rawQuery ）会更加安全。

3.2.2 查询语句的执行与结果处理

查询操作可以使用 rawQuery 方法执行，并通过 Cursor 对象处理返回的结果集。 Cursor 提供了移动位置、获取数据等功能。

Cursor cursor = null;
try {
    cursor = db.rawQuery("SELECT * FROM Users WHERE age > ?", new String[]{"25"});
    if (cursor.moveToFirst()) {
        do {
            String name = cursor.getString(cursor.getColumnIndex("name"));
            int age = cursor.getInt(cursor.getColumnIndex("age"));
            // 处理查询到的数据
        } while (cursor.moveToNext());
    }
} catch (SQLiteException e) {
    Log.e("QUERY ERROR", e.getMessage());
} finally {
    if (cursor != null) {
        cursor.close();
    }
}

在查询时，使用 rawQuery 方法允许执行带参数的查询，避免SQL注入风险。查询结果通过遍历 Cursor 对象来获取。与数据库打开和关闭类似，查询结果处理完毕后，应当及时关闭 Cursor 。

3.3 数据的CRUD操作

3.3.1 数据的查询操作

数据的查询操作是数据库操作中最基本也是最重要的功能之一。对于复杂的查询需求，可以使用SQL的聚合函数、子查询、连接（JOIN）等特性。

Cursor cursor = null;
try {
    cursor = db.query("Users", new String[]{"name", "age"}, "age >= ?", new String[]{"25"}, null, null, "age DESC");
    if (cursor.moveToFirst()) {
        do {
            String name = cursor.getString(0);
            int age = cursor.getInt(1);
            // 处理查询到的数据
        } while (cursor.moveToNext());
    }
} catch (SQLiteException e) {
    Log.e("QUERY ERROR", e.getMessage());
} finally {
    if (cursor != null) {
        cursor.close();
    }
}

查询操作中，可以使用 query 方法替代 rawQuery 来简化操作。该方法允许直接指定表名、需要查询的列名、查询条件、排序等，更符合Android开发的习惯。

3.3.2 数据的插入操作

数据的插入操作通过构造INSERT语句来实现。插入操作适用于向数据库中添加新记录。

try {
    ContentValues values = new ContentValues();
    values.put("name", "Charlie");
    values.put("age", 28);
    db.insert("Users", null, values);
} catch (SQLiteException e) {
    Log.e("INSERT ERROR", e.getMessage());
}

ContentValues 类用于存储一组数据，避免直接拼接SQL语句，增加了代码的可读性和安全性。在插入数据时，应考虑主键冲突的情况， insert 方法在主键冲突时不会插入数据，但不会抛出异常。

3.3.3 数据的更新操作

数据的更新操作用于修改表中的已存在记录。更新操作需要先构造一个有效的UPDATE SQL语句。

try {
    ContentValues values = new ContentValues();
    values.put("age", 30);
    db.update("Users", values, "name = ?", new String[]{"Alice"});
} catch (SQLiteException e) {
    Log.e("UPDATE ERROR", e.getMessage());
}

update 方法执行更新操作，需要指定表名、待更新的内容（ ContentValues 对象）以及更新条件。更新条件作为参数传入，保证操作的安全性和准确性。

3.3.4 数据的删除操作

数据的删除操作是通过构造DELETE SQL语句来实现的，用于从表中移除一条或多条记录。

try {
    db.delete("Users", "name = ?", new String[]{"Bob"});
} catch (SQLiteException e) {
    Log.e("DELETE ERROR", e.getMessage());
}

delete 方法接受表名、删除条件和删除条件的参数。需要注意的是，在执行删除操作时，应特别小心，避免误删除重要数据。

至此，我们已经详细学习了SQLite数据库的基本操作，包括数据库的打开和关闭、SQL语句的执行、以及数据的CRUD操作。在下一章节，我们将探索如何通过JDBC驱动来连接MySQL数据库，扩展我们的数据库操作能力。

4. JDBC驱动连接MySQL数据库

4.1 JDBC驱动的安装与配置

4.1.1 下载并配置MySQL JDBC驱动

首先，需要了解JDBC（Java Database Connectivity）是一个Java API，允许Java程序执行SQL语句。使用JDBC，我们能够以一致的方式连接和访问数据库，无论底层数据库是什么。

为了连接MySQL数据库，第一步是要下载适合当前Java版本的MySQL JDBC驱动（即mysql-connector-java）。此驱动可通过MySQL官方网站或Maven仓库获得。以下是通过Maven安装JDBC驱动的示例：

<!-- 在项目的pom.xml中添加依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.23</version>
</dependency>

安装完成后，需要配置连接字符串以建立连接。一个典型的JDBC连接字符串看起来像这样：

String url = "jdbc:mysql://localhost:3306/your_database_name?useSSL=false&serverTimezone=UTC";
String username = "your_username";
String password = "your_password";

这里， your_database_name 应替换为你的数据库名称， your_username 和 your_password 应替换成数据库访问凭证。

4.1.2 JDBC连接字符串的编写与调试

编写连接字符串时，要注意以下几点：

URL格式： jdbc:mysql://主机地址[:端口号]/数据库名 。
参数：可以添加参数如 useSSL=false 禁用SSL连接（安全考虑）， serverTimezone=UTC 设置时区以避免时区错误。
异常处理：应该对驱动加载、数据库连接等关键步骤进行异常处理。

try {
    Class.forName("com.mysql.cj.jdbc.Driver");
    Connection conn = DriverManager.getConnection(url, username, password);
    // 数据库操作代码
} catch (ClassNotFoundException e) {
    System.out.println("找不到JDBC驱动类");
} catch (SQLException e) {
    System.out.println("数据库连接失败");
}

在上述代码中，我们首先通过 Class.forName() 加载MySQL JDBC驱动类。之后，使用 DriverManager.getConnection() 尝试建立连接。异常处理部分捕捉了可能的 ClassNotFoundException 和 SQLException ，并输出错误信息。

4.2 JDBC数据库连接实践

4.2.1 JDBC连接MySQL数据库实例

现在，我们将提供一个完整的例子来演示如何通过JDBC连接MySQL数据库。这个例子将包括建立连接、执行查询、处理结果以及关闭连接。

import java.sql.*;

public class MySQLJDBCExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/your_database_name?useSSL=false&serverTimezone=UTC";
        String user = "your_username";
        String password = "your_password";
        String query = "SELECT * FROM your_table_name";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(query)) {
            // 输出查询结果
            while (rs.next()) {
                System.out.println(rs.getString("column_name"));
            }
        } catch (SQLException e) {
            System.out.println("发生错误: " + e.getMessage());
        }
    }
}

在上述代码中， Connection 、 Statement 和 ResultSet 类是进行数据库操作的核心。 Connection 代表与特定数据库的会话。 Statement 用于执行静态SQL语句并返回它们生成的 ResultSet 。 ResultSet 则代表了数据库结果集，可以用来滚动和检索数据。

4.2.2 JDBC连接池的使用与优势

JDBC连接池是一种管理数据库连接的机制，它允许重用现有连接，而不是为每个数据库操作都创建一个新的连接。连接池的优点包括性能提升和资源利用优化。

要使用连接池，可以使用像HikariCP这样的库。添加依赖到 pom.xml ：

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>4.0.3</version>
</dependency>

接下来，通过配置属性创建连接池实例：

HikariDataSource ds = new HikariDataSource();
ds.setJdbcUrl(url);
ds.setUsername(user);
ds.setPassword(password);
ds.setConnectionTimeout(5000); // 设置连接超时时间（毫秒）
ds.setMinimumIdle(1); // 最小空闲连接数
ds.setMaximumPoolSize(5); // 最大连接数
ds.setIdleTimeout(300000); // 连接空闲最大时间（毫秒）

通过使用HikariCP，应用程序能够快速建立稳定的数据库连接，提高数据库操作性能，减少延迟。连接池还有助于减少因数据库连接过多导致的资源问题，确保系统整体的稳定性和效率。

5. SQLiteOpenHelper类的使用

SQLiteOpenHelper类是Android平台上用来管理数据库版本和创建/更新数据库表的一个非常重要的辅助类。本章节将详细解读SQLiteOpenHelper类的作用与机制，并且提供实际应用中的具体示例。

5.1 SQLiteOpenHelper类的作用与机制

SQLiteOpenHelper类为数据库的创建和版本管理提供了一个更加方便和高级的接口。通过实现SQLiteOpenHelper类中的回调方法，开发者能够更加简单地控制数据库的创建和升级过程。

5.1.1 检测数据库版本与创建表

SQLiteOpenHelper类通过 getReadableDatabase() 和 getWritableDatabase() 方法来检测数据库的版本，并在需要时进行创建和更新。这两个方法会触发 onCreate(SQLiteDatabase db) 和 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) 方法的调用。

public class DatabaseHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "example.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建表的SQL语句
        String createTableSQL = "CREATE TABLE IF NOT EXISTS user (" +
                "id INTEGER PRIMARY KEY AUTOINCREMENT," +
                "name TEXT," +
                "email TEXT);";
        // 执行创建表的SQL语句
        db.execSQL(createTableSQL);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 检测到版本更新时执行的代码，例如更新表结构
        if (oldVersion < newVersion) {
            // 更新逻辑，比如添加新列
            db.execSQL("ALTER TABLE user ADD COLUMN age INTEGER");
        }
    }
}

5.1.2 管理数据库升级的策略

onUpgrade方法为数据库升级提供了策略管理。当检测到数据库版本变化时，开发者可以通过比较当前版本号与期望版本号来决定执行哪些升级操作。这包括添加新表、修改表结构等操作。

5.2 SQLiteOpenHelper类的实际应用

在实际应用中，SQLiteOpenHelper类的使用通常伴随着onCreate和onUpgrade方法的具体实现。以下将通过实例展示如何创建SQLiteOpenHelper实例以及如何实现onCreate()和onUpgrade()方法。

5.2.1 创建SQLiteOpenHelper实例

创建SQLiteOpenHelper的实例通常是在应用程序的某个组件首次启动时进行，例如在Activity的onCreate方法中。这样可以确保数据库在第一次访问时就已经创建好。

public class MainActivity extends AppCompatActivity {
    private DatabaseHelper dbHelper;

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

        dbHelper = new DatabaseHelper(this);
    }
}

5.2.2 实现onCreate()和onUpgrade()方法

onCreate方法负责在数据库首次创建时执行的初始化操作，比如创建表。而onUpgrade方法则根据数据库版本的比较结果，执行相应的升级操作。

@Override
public void onCreate(SQLiteDatabase db) {
    String createTableSQL = "CREATE TABLE IF NOT EXISTS user (" +
            "id INTEGER PRIMARY KEY AUTOINCREMENT," +
            "name TEXT," +
            "email TEXT);";
    db.execSQL(createTableSQL);
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    // 假设从版本1升级到版本2
    if (oldVersion < 2) {
        db.execSQL("ALTER TABLE user ADD COLUMN age INTEGER");
    }
}

通过这两个方法的实现，SQLiteOpenHelper类就能智能地处理数据库的创建和升级逻辑，确保应用程序中使用的数据库结构与业务需求保持同步。

6. 示例项目结构和代码说明

在本章节中，我们将深入探讨安卓项目的数据库模块结构，并提供完整的示例代码解读。为了更好地理解，我们将分解项目文件结构，并详细解释各个数据库操作类的实现方式。

6.1 安卓项目的数据库模块结构

安卓项目的数据库模块是应用中管理数据持久化的核心部分。它涉及到多个组件和文件，理解它们的结构和关系对开发高效的数据操作至关重要。

6.1.1 项目的文件结构分析

一个典型的安卓数据库模块通常包含以下文件和文件夹结构：

SQLiteOpenHelper 类文件
数据库操作类 ( DatabaseHelper.java )
数据库模型类 ( Model.java )
SQL 语句文件 ( sqlScripts.sql )

示例文件结构可能如下：

|── src
    ├── main
        ├── java
            ├── com.example.myapp
                ├── database
                    ├── DatabaseHelper.java
                    ├── Model.java
                ├── sqlScripts.sql

6.1.2 数据库操作类的划分与实现

在安卓项目中，数据库操作类负责实际的数据库交互。我们通常将创建、打开、关闭、升级和管理数据库的代码封装在 SQLiteOpenHelper 子类中。

示例代码解析

下面是一个简单的 SQLiteOpenHelper 实现的示例：

public class DatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "mydatabase.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE IF NOT EXISTS people (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // Handle database version upgrades
        db.execSQL("DROP TABLE IF EXISTS people");
        onCreate(db);
    }
}

6.2 完整示例代码解读

我们将通过示例代码来深入了解如何实现数据库的创建与表结构，以及CRUD操作的具体代码实现。

6.2.1 数据库创建与表结构代码解析

在 onCreate 方法中，我们定义了数据库的创建逻辑和表结构。

@Override
public void onCreate(SQLiteDatabase db) {
    db.execSQL("CREATE TABLE IF NOT EXISTS people (" +
               "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
               "name TEXT, " +
               "age INTEGER)");
}

这段代码创建了一个名为 people 的表，它包含 id （主键且自增）、 name （文本类型）和 age （整型）三个字段。

6.2.2 CRUD操作的实现代码解析

CRUD操作指的是对数据库进行的创建(Create)、读取(Read)、更新(Update)和删除(Delete)操作。接下来，我们将展示如何实现这些操作。

数据的插入操作

public long insertPerson(String name, int age) {
    SQLiteDatabase db = this.getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put("name", name);
    values.put("age", age);
    long id = db.insert("people", null, values);
    return id;
}

数据的查询操作

public List<Person> getAllPeople() {
    List<Person> peopleList = new ArrayList<>();
    SQLiteDatabase db = this.getReadableDatabase();
    Cursor cursor = db.query("people", new String[] {"id", "name", "age"}, null, null, null, null, null);
    if (cursor.moveToFirst()) {
        do {
            Person person = new Person();
            person.setId(cursor.getInt(cursor.getColumnIndex("id")));
            person.setName(cursor.getString(cursor.getColumnIndex("name")));
            person.setAge(cursor.getInt(cursor.getColumnIndex("age")));
            peopleList.add(person);
        } while (cursor.moveToNext());
    }
    cursor.close();
    db.close();
    return peopleList;
}

以上代码演示了如何通过查询数据库来获取所有人的信息，并将其封装到 Person 对象列表中。类似的逻辑也适用于更新和删除操作。

在完成本章节的探讨后，我们已详细介绍了安卓项目中数据库模块的结构与代码实现。这些示例将帮助您更好地理解数据库操作在实际项目中的应用。

本文还有配套的精品资源，点击获取