第七章：数据持久化

7.1 数据持久化简介

数据持久化：是指将那些内存中的瞬时数据保存到存储设备中，保证即使在手机或计算机关机的情况下，这些数据仍然不会丢失。
保存在内存中的数据是处于瞬时状态的，而保存在存储设备中的数据是处于持久状态的。持久化技术提供了一种机制，可以让数据在瞬时状态和持久状态之间进行转换。
Android系统中主要提供了3种方式用于简单地实现数据持久化功能：

• 文件存储
• SharedPreferences存储
• 数据库存储

7.2 文件存储

基本概念

文件存储是Android中最基本的数据存储方式，它不对存储的内容进行任何格式化处理，所有数据都是原封不动地保存到文件当中的，因而它比较适合存储一些简单的文本数据或二进制数据。

数据存储到文件中

创建项目

首先创建一个FilePersistenceTest项目。

设置布局

并修改activity_main.xml中的代码，如下所示：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent" >
  <EditText
            android:id="@+id/editText"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="Type something here"/>
</LinearLayout>

这里设立了一个输入框，在输入框中的输入的内容会短暂的进入内存当中进行存储，一旦按下”Back”键，输入的数据就会被回收，这就是瞬时数据。

主要逻辑

在数据被回收之前，将它存储到文件当中。修改MainActivity中的代码，如下所示：

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    override fun onDestroy() {
        super.onDestroy()
        // 获取输入框的实例
        val editText:EditText = findViewById(R.id.editText)
        // 将输入框中输入的内容转换为字符串
        val inputText = editText.text.toString()
        // 保存字符串
        save(inputText)
    }
    private fun save(inputText: String) {
        try {
            val output = openFileOutput("data", Context.MODE_PRIVATE)
            val writer = BufferedWriter(OutputStreamWriter(output))
            writer.use {
                it.write(inputText)
            }
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
}

在整个Activity销毁的时候，执行OnDestoryed方法，进行数据的存储，核心方法就是**save**，方法的参数就是需要保存的数据内容。
我们把核心方法单独拉出来看一下：

private fun save(inputText: String) {
    try {
        val output = openFileOutput("data", Context.MODE_PRIVATE)
        val writer = BufferedWriter(OutputStreamWriter(output))
        writer.use {
            // it指代的就是writer实例
            // write就是书写数据的函数
            it.write(inputText)
        }
    } catch (e: IOException) { // 抛出异常
        e.printStackTrace()
    }
}

openFileOutput

首先是一个openFileOutput方法：

• 第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。创建的文件保存在/data/data/<package name>/files目录，如： /data/data/cn.itcast.action/files/data.txt
• 第二参数用于指定操作模式，有四种模式，分别为：
  • Context.MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容。
  • Context.MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。
  • MODE_WORLD_READABLE：表示当前文件可以被其他应用读取；
  • MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。

接着是OutputStreamWriter，它是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出对象。
为什么要转换为字节流？

BufferedWriter

这里还有一个BufferedWriter方法，同样也是继承于Writer，Writer可以理解为一个书写器，可以执行数据的书写的操作。而这个BufferedWriter拥有8192字符的缓冲区，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。

use

最后这里使用了一个use函数，这是Kotlin提供的一个内置扩展函数。它保证在Lambda表达式中的代码全部执行完之后自动将外层的流关闭，这样就不需要再编写一个finally语句，手动去关闭流了，是一个非常好用的扩展函数。
也就是说在原始写入数据的时候，写入完毕需要关闭流（writer.close()），如果调用了use函数，就可以无需执行这个操作，它会自动关闭外层的流。

查看保存的数据

1. 运行项目
2. 打开Device File Explorer工具

1. 打开/data/data目录

1. 找到文件该项目文件（注意文件名称是com.example开头），打开file文件夹，就会发现data文件

文件中读取数据

和写入数据十分相似，所以这里就讲一下主要逻辑，首先是加载方法：

private fun load(): String {
    // 构建字符串构造器
    val content = StringBuilder()
    try {
        // 打开文件
        val input = openFileInput("data")
        // 使用字节流读取数据
        val reader = BufferedReader(InputStreamReader(input))
        reader.use {
            // 逐行读取内容，并把内容添加到content中
            reader.forEachLine {
                content.append(it)
            } 
        }
    } catch (e: IOException) {
        e.printStackTrace()
    }
    return content.toString()
}

这里最重要的就是读取数据，openFileInput、InputStreamReader、BufferedReader的概念和之前讲的都是类似的，把写入改成读取即可。
完整实例：

package com.example.filepersistencetest
import android.content.Context
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import com.example.database.MyDatabaseHelper
import java.io.*
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 调用加载方法，读取之前保存的数据
        val inputText = load()
        // 判断之前是否已经保存了数据
        if (inputText.isNotEmpty()) {
            val editText:EditText = findViewById(R.id.editText)
            // 设置输入框文本内容
            editText.setText(inputText)
            // 设置输入框光标的位置，在文本内容之后就只需要传入文本内容的长度即可
            editText.setSelection(inputText.length)
            // 保存的数据不为空就会弹出提示    
            Toast.makeText(this, "Restoring succeeded", Toast.LENGTH_SHORT).show()
        }
    }
    private fun load(): String {
        val content = StringBuilder()
        try {
            val input = openFileInput("data")
            val reader = BufferedReader(InputStreamReader(input))
            reader.use {
                reader.forEachLine {
                    content.append(it)
                } 
            }
        } catch (e: IOException) {
            e.printStackTrace()
        }
        return content.toString()
    }
    override fun onDestroy() {
        super.onDestroy()
        val editText:EditText = findViewById(R.id.editText)
        val inputText = editText.text.toString()
        save(inputText)
    }
    private fun save(inputText: String) {
        try {
            val output = openFileOutput("data", Context.MODE_PRIVATE)
            val writer = BufferedWriter(OutputStreamWriter(output))
            writer.use {
                it.write(inputText)
            }
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
}

本节参考

openFileOutput() - elleniou - 博客园
Java IO操作——字节-字符转换流(OutputStreamWriter、InputStreamReader)_LIUXUN1993728的博客-CSDN博客
吃透Java IO：字节流、字符流、缓冲流
Java中，BufferedReader类和BufferedWriter的介绍及作用_灵懈不同的施雅的博客-CSDN博客_bufferedwriter的作用

7.3 SharedPreferences存储

基本概念

不同于文件的存储方式，SharedPreferences是使用键值对的方式来存储数据的。
也就是说，当保存一条数据的时候，需要给这条数据提供一个对应的键，这样在读取数据的时候就可以通过这个键把相应的值取出来。
而且SharedPreferences还支持多种不同的数据类型存储：

• 如果存储的数据类型是整型，那么读取出来的数据也是整型的；
• 如果存储的数据是一个字符串，那么读取出来的数据仍然是字符串。

将数据存储到SharedPreferences中

类似于存储到文件当中一样，但是这里有两种方式：

• Context类中的getSharedPreferences()方法，这个方法接受两个参数：
  • 第一个参数用于指定SharedPreferences文件的名称，如果指定的文件不存在则会创建一个，SharedPreferences文件都是存放在/data/data/<packagename>/shared_prefs/目录下的；
  • 第二个参数用于指定操作模式，目前只有默认的MODE_PRIVATE这一种模式可选，表示只有当前的应用程序才可以对这个SharedPreferences文件进行读写。
• Activity类中的getPreferences()方法
  • 这个方法和Context中的getSharedPreferences()方法很相似，不过它只接收一个操作模式参数，因为使用这个方法时会自动将当前Activity的类名作为SharedPreferences的文件名。

接下来是实践部分：

创建项目

创建一个SharedPreferencesTest项目

设置布局

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical" >
  <Button
          android:id="@+id/saveButton"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:text="Save DaSharedPreferencesTestta"/>
</LinearLayout>

主要逻辑

package com.example.sharedpreferencestest
import android.content.Context
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val saveButton: Button = findViewById(R.id.saveButton)
        saveButton.setOnClickListener {
            // 获取SharedPreferences实例
            val editor = getSharedPreferences("data", Context.MODE_P
                                              RIVATE).edit()
            // 存储字符串数据
            editor.putString("name", "Tom")
            // 存储整形数据
            editor.putInt("age", 28)
            // 存储布尔类型数据
            editor.putBoolean("married", false)
            // 提交存储的数据
            editor.apply()
        }
    }
}

非常的简单，getSharedPreferences的两个参数同上面的文件存储。edit()用于开启编辑模式。其余的都写在注释里面的了，很好理解。

查看保存的数据

和文件存储一样，在运行项目之后找到相应路径即可：

保存的文件是一个xml文件，内容很容易懂：

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
  <string name="name">Tom</string>
  <boolean name="married" value="false" />
  <int name="age" value="28" />
</map>

读取数据

SharedPreferences对象中提供了一系列的get方法，用于读取存储的 数 据，每 种get方法都对应了SharedPreferences.Editor中的一种put方法，比如读取一个布尔型数据就使用getBoolean()方法，读取一个字符串就使用getString()方法。这些get方法都接收两个参数：

• 第一个参数是键，传入存储数据时使用的键就可以得到相应的值了。
• 第二个参数是默认值，即表示当传入的键找不到对应的值时会以什么样的默认值进行返回。

修改布局

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    <Button
        android:id="@+id/saveButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Save Data"/>
    <Button
        android:id="@+id/restoreButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Restore Data"/>
</LinearLayout>

添加读取逻辑

        val restoreButton:Button = findViewById(R.id.restoreButton)
        restoreButton.setOnClickListener {
            // 得到getSharedPreferences实例
            val prefs = getSharedPreferences("data", Context.MODE_PRIVATE)
            // 获取key是"name"的值，读取不到默认是空
            val name = prefs.getString("name", "")
            // 获取key是"age"的值，读取不到默认是0
            val age = prefs.getInt("age", 0)
            // 获取key是"married" 的值，读取不到默认是false
            val married = prefs.getBoolean("married", false)
            Log.d("MainActivity", "name is $name")
            Log.d("MainActivity", "age is $age")
            Log.d("MainActivity", "married is $married")
        }

逻辑也很简单，看注释即可。
完整实例：

package com.example.sharedpreferencestest
import android.content.Context
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val saveButton: Button = findViewById(R.id.saveButton)
        saveButton.setOnClickListener {
            val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
            editor.putString("name", "Tom")
            editor.putInt("age", 28)
            editor.putBoolean("married", false)
            editor.apply()
        }
        val restoreButton:Button = findViewById(R.id.restoreButton)
        restoreButton.setOnClickListener {
            val prefs = getSharedPreferences("data", Context.MODE_PRIVATE)
            val name = prefs.getString("name", "")
            val age = prefs.getInt("age", 0)
            val married = prefs.getBoolean("married", false)
            Log.d("MainActivity", "name is $name")
            Log.d("MainActivity", "age is $age")
            Log.d("MainActivity", "married is $married")
        }
    }
}

实现记住密码功能

这里我们需要使用到前面写过的BroadCastBestPractice项目中的登录部分。

布局文件修改

在activity_login文件中的Button组件前添加如下布局：

<LinearLayout
          android:orientation="horizontal"
          android:layout_width="match_parent"
          android:layout_height="wrap_content">
<CheckBox
          android:id="@+id/rememberPass"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content" />
<TextView
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:textSize="18sp"
          android:text="Remember password" />
</LinearLayout>

也就是一个复选框，一个文本View，内容是Remember password。

主要逻辑修改

package com.example.broadcastbestpractice
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.widget.Button
import android.widget.CheckBox
import android.widget.EditText
import android.widget.Toast
class LoginActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)
        // 分别获取按钮，账户输入框，密码输入框，记得密码选项框的实例
        val login: Button = findViewById(R.id.login)
        val accountEdit:EditText = findViewById(R.id.accountEdit)
        val passwordEdit:EditText = findViewById(R.id.passwordEdit)
        val rememberPass: CheckBox = findViewById(R.id.rememberPass)
        // 下面是读取数据
        val prefs = getPreferences(Context.MODE_PRIVATE)
        // 获取存储的isRemember值，如果没有这个值，就初始化赋值为false
        val isRemember = prefs.getBoolean("remember_password", false)
        // 如果选项框在之前存储的值是ture就执行下面的代码，也就是说选项框之前被选中了才会执行
        if (isRemember) {    // 将账号和密码都设置到文本框中
            // 获取存储的账户和密码的值，如果没有就是设置为""
            val account = prefs.getString("account", "")
            val password = prefs.getString("password", "")
            // 给两个输入框填入相应的值
            accountEdit.setText(account)
            passwordEdit.setText(password)
            rememberPass.isChecked = true
        }
        // 下面是登录事件，和之前一样
        login.setOnClickListener {
            val account = accountEdit.text.toString()
            val password = passwordEdit.text.toString()
            // 如果账号是admin且密码是123456，就认为登录成功
            if (account == "admin" && password == "123456") {
                // 从这里开始需要写入数据
                val editor = prefs.edit()
                // 检查复选框是否被选中
                if (rememberPass.isChecked) { 
                    editor.putBoolean("remember_password", true)
                    editor.putString("account", account)
                    editor.putString("password", password)
                } else {
                    // 若未被选中，调用clear()方法，将SharedPreferences中的数据全部清除掉。
                    editor.clear()
                }
                // 提交写入的数据
                editor.apply()
                val intent = Intent(this, MainActivity::class.java)
                startActivity(intent)
                finish()
            }
            else{
                Toast.makeText(this, "account or password is invalid",
                    Toast.LENGTH_SHORT).show()
            }
        }
    }
}

存储和读取数据部分逻辑如下：

本节参考

Android中SharedPreferences.Editor的apply()与commit()方法BugFree张瑞的博客-CSDN博客_editor.apply();

7.4 SQLite数据库存储

Android系统内置了SQLite数据库，SQLite是一款轻量级的关系型数据库，它的运算速度非常快，占用资源很少，通常只需要几百KB的内存就足够了，因而特别适合在移动设备上使用。
SQLite不仅支持标准的SQL语法，还遵循了数据库的ACID事务，而SQLite又比一般的数据库要简单得多，它甚至不用设置用户名和密码就可以使用。
Android为了更加方便地管理数据库，专门提供了SQLiteOpenHelper帮助类，借助这个类可以非常简单地对数据库进行创建和升级。

基本使用

1. SQLiteOpenHelper是一个抽象类，想要使用它，就需创建一个自己的帮助类去继承它。
2. SQLiteOpenHelper中有两个抽象方法：**onCreate()**和**onUpgrade()**。必须在自己的帮助类里重写这两个方法，然后分别在这两个方法中实现创建和升级数据库的逻辑。
3. SQLiteOpenHelper中还有两个非常重要的实例方法：**getReadableDatabase()**和**getWritableDatabase()**（一个是只读的方式打开，一个是可写入的方式打开）。这两个方法都可以创建或打开一个现有的数据库（如果数据库已存在则直接打开，否则要创建一个新的数据库），并返回一个可对数据库进行读写操作的对象。
4. SQLiteOpenHelper中有两个构造方法可供重写，一般使用参数少的那个构造方法即可。这个构造方法中接收4个参数：
   1. 第一个参数是Context，必须有它才能对数据库进行操作；
   2. 第二个参数是数据库名，创建数据库时使用的就是这里指定的名称；
   3. 第三个参数允许在查询数据时返回一个自定义的Cursor，一般传入null；
   4. 第四个参数表示当前数据库的版本号，可用于对数据库进行升级操作。

创建数据库

简单创建数据库

1. 下载插件

1. 添加数据库

1. 选择SQLite

1. 创建数据库

1. 创建Book表

1. 点击运行

1. 刷新查看

如果刷新了仍然未能看到Book表，就重新Android Studio

代码中创建表

首先创建一个DatabaseTest项目，接下来创建一个MyDatabaseHelper继承于SQLiteOpenHelper：

package com.example.databasehelper
import android.content.Context
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.widget.Toast
class MyDatabaseHelper(val context: Context, name: String, version: Int) :
    SQLiteOpenHelper(context, name, null, version) {
    private val createBook = "create table Book (" +
            " id integer primary key autoincrement," +
            "author text," +
            "price real," +
            "pages integer," +
            "name text)"
    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL(createBook)
        Toast.makeText(context, "Create succeeded", Toast.LENGTH_SHORT).show()
    }
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
    }
}

这里的几个方法和参数的作用基本都在基本使用中讲过了，这里讲一下之前没讲过的。

• createBook变量使用字符串的形式来存储sql语句。
• execSQL用于执行sql语句，其中的参数就是一个字符串。

接下来简单使用以下这个类：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent">
  <Button
          android:id="@+id/createDatabase"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:text="Create Database"/>
</LinearLayout>

package com.example.databasetest
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import com.example.databasehelper.MyDatabaseHelper
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val dbHelper = MyDatabaseHelper(this, "BookStore.db", 1)
        val createDatabase: Button = findViewById(R.id.createDatabase)
        createDatabase.setOnClickListener {
            dbHelper.writableDatabase
        }
    }
}

调用逻辑十分的简单，就是构建一个帮助类，使用writableDatabase可读写的方式打开帮助类，这个时候帮助类调用启动方法OnCreated，执行了创建表的语句。
在老地方就可以找到创建的BookStore.db文件：

这个时候我们就可以把BookStore.db文件右击导出到自己新建的文件夹中进行使用。

接着就是在新建连接中，更改文件。

升级数据库

在上文中我们提到，**onUpgrade()**是升级数据库的方法。

为什么要升级数据库

为什么需要升级？举个例子，我们在刚才的代码中添加一个Category表的创建：

package com.example.databasehelper
import android.content.Context
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.widget.Toast
class MyDatabaseHelper(val context: Context, name: String, version: Int) :
    SQLiteOpenHelper(context, name, null, version) {
    private val createBook = "create table Book (" +
            " id integer primary key autoincrement," +
            "author text," +
            "price real," +
            "pages integer," +
            "name text)"
    private val createCategory = "create table Category (" +
            "id integer primary key autoincrement," +
            "category_name text," +
            "category_code integer)"
    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL(createBook)
        db.execSQL(createCategory)
        Toast.makeText(context, "Create succeeded", Toast.LENGTH_SHORT).show()
    }
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
    }
}

重新运行程序会发现，第二张Category表并没有被创建，其实是因为此时BookStore.db数据库已经存在，不管怎样点击“Create Database”按钮，MyDatabaseHelper中的onCreate()方法都不会再次执行，因此新添加的表也就无法创建。
最直白的解决方法就是将程序卸载重新安装。销毁数据库再重建，但是这样很麻烦。
所以有了升级方法，也可以理解为更新数据库：

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        db.execSQL("drop table if exists Book")
        db.execSQL("drop table if exists Category")
        onCreate(db)
    }

在onUpgrade()方法中执行了两条**DROP语句**，若数据库中已经存在Book表或Category表，就将这两张表删除，然后调用onCreate()方法重新创建。

如何升级数据库

方式很简单，SQLiteOpenHelper的构造方法里接收的第四个参数，表示当前数据库的**版本号**，之前传入的是1，现在只要传入一个比1大的数，就可以让onUpgrade()方法得到执行了。
把版本修改成为2之后，重新运行即可：

表的操作

这里PPT上面直接把四个方法写在onCreated方法里面，我觉得这样太拥挤了，所以单独拿出来写了四个初始化方法，最后在onCreated方法中调用即可。
最后我会把四个方法的完整实例代码放在一起展示。

注意我们这里每次操作之后都要重新导出db文件，才能查看操作之后的数据。

增

在布局中添加如下代码：

<Button
        android:id="@+id/addData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Add Data"
        />

增添数据的逻辑如下：

private fun initAddDataFunction(){
    val addData:Button = findViewById(R.id.addData)
    addData.setOnClickListener {
        // 可写入的方式读取数据
        val db = dbHelper.writableDatabase
        val values1 = ContentValues().apply {   // 开始组装第一条数据
            put("name", "The Da Vinci Code")
            put("author", "Dan Brown")
            put("pages", 454)
            put("price", 16.96)
        }
        db.insert("Book", null, values1) // 插入第一条数据
        val values2 = ContentValues().apply {  // 开始组装第二条数据
            put("name", "The Lost Symbol")
            put("author", "Dan Brown")
            put("pages", 510)
            put("price", 19.95)
        }
        db.insert("Book", null, values2) // 插入第二条数据
        Toast.makeText(this,"insert successful",Toast.LENGTH_LONG).show()
    }
}

这里我们通过ContentValues().apply{}来把不同的数据组装起来，形成一个元组进行插入，Book表一共有五个字段，所以一般要使用五个put对每个字段分别设置，这里的values2值插入了四个字段，是因为id作为主键，如果不插入就会自动增加。

元组组装完成之后，就使用insert语句进行插入即可，这里的insert有三个参数：

• 第一个参数是表名，希望向哪张表里添加数据，就传入该表的名字；
• 第二个参数用于在未指定添加数据的情况下给某些可为空的列自动赋值NULL，一般用不到这个功能，直接传入null即可；
• 第三个参数是一个ContentValues对象，提供了一系列的put()方法重载，用于向ContentValues中添加数据，只需要将表中的每个列名以及相应的待添加数据传入即可。

这一段使用sql就是：

db.execSQL("insert into Book (name, author, pages, price) values(?, ?, ?, ?)",
arrayOf("The Da Vinci Code", "Dan Brown", "454", "16.96")
)
db.execSQL("insert into Book (name, author, pages, price) values(?, ?, ?, ?)",
arrayOf("The Lost Symbol", "Dan Brown", "510", "19.95")
)

插入之后重新查询可得：

删

增加一个删除用的按钮：

<Button
        android:id="@+id/deleteData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Delete Data"
        />

接下来是删除逻辑：

private fun initDeleteFunction(){
    val deleteData: Button = findViewById(R.id.deleteData)
    deleteData.setOnClickListener {
        val db = dbHelper.writableDatabase
        db.delete("Book", "pages > ?", arrayOf("500"))
    }
    Toast.makeText(this,"delete successful",Toast.LENGTH_LONG).show()
}

非常的简单，只需要一个delete函数即可，其中包含了三个参数：

• 第一个参数仍然是表名；
• 第二、第三个参数用于约束删除某一行或某几行的数据，不指定的话默认会删除所有行。

第二个和第三个语句就类似于sql语句里面的where子句，只不过这里做了一个拆分，将约束的条件参数作为一个列表放在第三个参数的位置。
这一段使用sql就是：

db.execSQL("delete from Book where pages > ?", arrayOf("500"))

改

添加修改用的按钮：

<Button
        android:id="@+id/updateData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Update Data"
        />

修改的核心逻辑：

private fun initUpdateDate(){
    val updateData: Button = findViewById(R.id.updateData)
    updateData.setOnClickListener {
        val db = dbHelper.writableDatabase
        val values = ContentValues()
        values.put("price", 10.99)
        db.update("Book", values, "name = ?", arrayOf("The Da Vinci Code"))
    }
    Toast.makeText(this,"update successful",Toast.LENGTH_LONG).show()
}

由于修改的只是一个字段，而不是元组，所以这里不需要进行组装。
根据sql里面的update语句，我们需要的就是一个字段+一个约束条件即可，所以update里面四个参数的就一目了然了。

• 第一个：表名称
• 第二个：修改的字段
• 第三个、第四个：约束条件

上面这段代码就相当于：

db.execSQL("update Book set price = ? where name = ?", arrayOf("10.99", "The Da Vinci Code"))

修改之后就是：

查

查询所需要用的方法是query()，参数如下：

添加一个查询按钮：

<Button
        android:id="@+id/queryData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Query Data"
        />

查询的核心逻辑：

private fun initQueryData(){
    val queryData: Button = findViewById(R.id.queryData)
    queryData.setOnClickListener {
        val db = dbHelper.writableDatabase  // 查询Book表中所有的数据
        val cursor = db.query("Book", null, null, null, null, null, null)
        if (cursor.moveToFirst()) {
            do {   // 遍历Cursor对象，取出数据并打印
                val name = cursor.getString(cursor.getColumnIndexOrThrow("name"))
                val author = cursor.getString(cursor.getColumnIndexOrThrow("author"))
                val pages = cursor.getInt(cursor. getColumnIndexOrThrow("pages"))
                val price = cursor.getDouble(cursor. getColumnIndexOrThrow("price"))
                Log.d("MainActivity", "book name is $name")
                Log.d("MainActivity", "book author is $author")
                Log.d("MainActivity", "book pages is $pages")
                Log.d("MainActivity", "book price is $price")
            } while (cursor.moveToNext())
        }
        cursor.close()
    }
    Toast.makeText(this,"query successful",Toast.LENGTH_LONG).show()
}

这里的查询语句非常简单：db.query("Book", null, null, null, null, null, null)，说明查询全表，主要是遍历cursor对象输出查询的结果有点多，实际也不难。

• moveToFirst()：用于获取查询结果的第一个元组，如果这个数据存在，说明查询不为空，使用do while循环进行遍历即可。
• moveToNext()：获取下一个元组，如果下一个元组不存在，说明已经遍历完成了。
• getColumnIndexOrThrow：用于通过索引获取相应的值，其实也可以使用getColumnIndex，但是有可能这个所以不存在，所以使用getColumnIndexOrThrow。
• getDataType：把获取到的数据转换为DataType类型，比如String，Int。
• cursor.close()：最后注意关闭cursor。

查询语句相当于：

val cursor = db.rawQuery("select * from Book", null)

完整实例代码

点击三角符号可以查看。

package com.example.databasetest
import android.content.ContentValues
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.Toast
import com.example.databasehelper.MyDatabaseHelper
class MainActivity : AppCompatActivity() {
    private val dbHelper = MyDatabaseHelper(this, "BookStore.db", 3)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val createDatabase: Button = findViewById(R.id.createDatabase)
        createDatabase.setOnClickListener {
            dbHelper.writableDatabase
        }
        // 增添数据
        initAddDataFunction()
        // 删除数据
        initDeleteFunction()
        // 修改数据
        initUpdateDate()
        // 查询数据
        initQueryData()
    }
    private fun initAddDataFunction(){
        val addData:Button = findViewById(R.id.addData)
        addData.setOnClickListener {
            val db = dbHelper.writableDatabase
            val values1 = ContentValues().apply {   // 开始组装第一条数据
                put("name", "The Da Vinci Code")
                put("author", "Dan Brown")
                put("pages", 454)
                put("price", 16.96)
            }
            db.insert("Book", null, values1) // 插入第一条数据
            val values2 = ContentValues().apply {  // 开始组装第二条数据
                put("name", "The Lost Symbol")
                put("author", "Dan Brown")
                put("pages", 510)
                put("price", 19.95)
            }
            db.insert("Book", null, values2) // 插入第二条数据
            Toast.makeText(this,"insert successful",Toast.LENGTH_LONG).show()
        }
    }
    private fun initDeleteFunction(){
        val deleteData: Button = findViewById(R.id.deleteData)
        deleteData.setOnClickListener {
            val db = dbHelper.writableDatabase
            db.delete("Book", "pages > ?", arrayOf("500"))
        }
        Toast.makeText(this,"delete successful",Toast.LENGTH_LONG).show()
    }
    private fun initUpdateDate(){
        val updateData: Button = findViewById(R.id.updateData)
        updateData.setOnClickListener {
            val db = dbHelper.writableDatabase
            val values = ContentValues()
            values.put("price", 10.99)
            db.update("Book", values, "name = ?", arrayOf("The Da Vinci Code"))
        }
        Toast.makeText(this,"update successful",Toast.LENGTH_LONG).show()
    }
    private fun initQueryData(){
        val queryData: Button = findViewById(R.id.queryData)
        queryData.setOnClickListener {
            val db = dbHelper.writableDatabase  // 查询Book表中所有的数据
            val cursor = db.query("Book", null, null, null, null, null, null)
            if (cursor.moveToFirst()) {
                do {   // 遍历Cursor对象，取出数据并打印
                    val name = cursor.getString(cursor.getColumnIndexOrThrow("name"))
                    val author = cursor.getString(cursor.getColumnIndexOrThrow("author"))
                    val pages = cursor.getInt(cursor. getColumnIndexOrThrow("pages"))
                    val price = cursor.getDouble(cursor. getColumnIndexOrThrow("price"))
                    Log.d("MainActivity", "book name is $name")
                    Log.d("MainActivity", "book author is $author")
                    Log.d("MainActivity", "book pages is $pages")
                    Log.d("MainActivity", "book price is $price")
                } while (cursor.moveToNext())
            }
            cursor.close()
        }
        Toast.makeText(this,"query successful",Toast.LENGTH_LONG).show()
    }
}