《第一行源代码》第三版第七章（数据存储）

7.1 持久化技术简介

Android系统中主要提供3种方式用于简单地实现数据持久化功能：文件存储、SharePreferences存储以及数据库存储

7.2 文件存储

1.将数据存储到文件中

Context类中提供了一个openFileOutput()方法，可以用于将数据存储到指定的文件中。
这个方法接收两个参数:第一个参数是文件名，在文件创建的时候使用，注意这里指定的文件名不可以包含路径，因为所有的文件都默认存储到/data/datal/files/目录下;第二个参数是文件的操作模式，主要有MODE_PRIVATE 和MODE_APPEND两种模式可选，默认是MODE_PRIVATE，表示当指定相同文件名的时候，所写入的内容将会覆盖原文件中的内容，而MODE_APPEND则表示如果该文件已存在，就往文件里面追加内容，不存在就创建新文件。其实文件的操作模式本来还有两种:MODE_WORLD_READABLEMODE_WORLD_WRITEABLE。
这两种模式表示允许其他应用程序对我们程序中的文件进行读写操作，不过由于这两种模式过于危险，很容易引起应用的安全漏洞，已在Android 4.2版本中被废弃。

下面用例子学习一下Android项目中使用文件存储的技术：
activity_main 文件中
设置一个编辑框

<?xml version="1.0" encoding="utf-8"?>
<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>

MainActivity中：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onDestroy() {
        super.onDestroy()
        //数据被回收前保存
        val inputText = editText.text.toString()// 获取编辑框中的字符串
        save(inputText)	//save方法保存
    }

    private fun save(inputText:String){
        try {
            val output = openFileOutput("data", Context.MODE_PRIVATE)
            /*openFileOutput()方法能够得到一个FileOutputStream对象，然后借助它构建出OutputStreamWriter对象，
            接着使用OutputStreamWriter构建BufferedWriter对象，最后可以可以借助BufferedWriter将文本内容写入文本内容中*/
            val writer = BufferedWriter(OutputStreamWriter(output))
            writer.use {//use是kotlin的内置扩展函数（它会保证Lambda表达式中的代码全部执行完之后自动将外层的流关闭）
                it.write(inputText)
            }
        }catch (e:IOException){
            e.printStackTrace()
        }
    }
}

最后使用Device File Explorer 查看

如果未找到files文件可以使用synchronize同步一下

2. 从文件中读取数据

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val inputText = load() //调用load函数读取文件文本内容
        if (inputText.isNotEmpty()){//非空执行下面
            editText.setText(inputText)
            editText.setSelection(inputText.length) 
            //将国标移动到末尾以便继续输入
            Toast.makeText(this,"Restoring succeeded",Toast.LENGTH_SHORT).show()
        }
    }
    private fun load():String{
        val context = StringBuilder()
        try {
            val input = openFileInput("data") 
            //获取一个FileInputStream对象 然后构建一个InputStreamReader对象
            //接着构建BufferedReader对象这样我们就可以通过BufferedReader将文件的数据读取
            val reader = BufferedReader(InputStreamReader(input))
            reader.use {
                reader.forEachLine {//forEachLine扩展函数 每行内容都回调到Lambda表达式中
                    context.append(it)
                }
            }
        }catch (e:IOException){
            e.printStackTrace()
        }
        return context.toString()
    }

    override fun onDestroy() {
        super.onDestroy()
        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()
        }
    }
}

这样我们在编辑框里面写文本内容后按back后再次打开文本内容就不会消失了

7.3 SharedPreference存储

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

1. 将数据存储到SharedPreferences中

Android中主要提供两种方法用于得到SharePreferences对象：

1. Context.getSharedPreferences
   getSharedPreferences 为 Context 的成员方法，需要参数 name 和 mode
   mode 参数，SharedPreferences 推荐仅在自己应用内使用，所以一般默认使用 Context.MODE_PRIVATE
   name 参数，系统会在 data/data/your.package.name/shared_prefs/ 路径下创建对应 ${name}.xml 文件作为 SharedPreferences 的存储
2. Activity类中的getSharedPreferences
   这个方法和Context中的getPreferences（）方法很像，不过它只接受一个操作模式，因为使用这个方法时会自动将当前Activity的类名作为SharePreferences的文件名

下面新建一个SharedPreferencesTest项目，然后修改activity_main.xml中的代码：

<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="sava Date"/>
</LinearLayout>

修改MainActivity：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        saveButton.setOnClickListener{
            val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
            editor.putString("name","Tom")
            editor.putInt("age",28)
            editor.putBoolean("married",false)
            editor.apply()
        }
    }
}

同样使用Device File Explorer 进入
/data/data/com.example.sharedpreferencestest/shared_prefs去查看

2. 从SharedPreferences中读取数据

SharedPreferences对象中提供一系列的get方法，用于读取存储的数据，每个get方法对应了SharedPreferences.Editor中的一种putString（）方法，这些方法都接受两个参数，第一个键值，第二个是默认值
下面通过实例体验一下：
修改acitvity_main中的代码：

<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="sava Date"/>
    
    <Button
        android:id="@+id/restoreButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Restore Data"/>
</LinearLayout>

修改MainActivity

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        saveButton.setOnClickListener{
            val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
            editor.putString("name","Tom")
            editor.putInt("age",28)
            editor.putBoolean("married",false)
            editor.apply()
        }
        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("MainAcitivity","name is $name")
            Log.d("MainAcitivity","age is $age")
            Log.d("MainAcitivity","married is $married")
        }
    }
}

点击Restore Data按钮，结果如图：

3. 实现记住密码功能

这部分代码可以去一下链接右下角有随书资源：
https://www.ituring.com.cn/book/2744
里面接触了一个新的控件：CheckBox （复选框控件）
用户可以点击进行选中和取消

7.4SQLlite数据库存储

1. 创建数据库

SQLiteOpneHelper类：可以非常简单的对数据库进行创建和升级。它是一个抽象类。如果我们要使用它，就需要创建一个自己的帮助类去继承它。
必须重写类中的两个方法：onCreateView（） ：创建数据库 onUpgrade（） ：升级数据库

两个非常重要的实例方法：
两个方法都可以创建或打开一个现有的数据库，并返回一个可对数据库进行读写操作的对象。

getReadableDatabase（） ：返回的对象将以只读方式打开。
getWritableDatabase（） ：在数据库不可写入时，会出现异常。
SQLiteOpneHelper中有两个构造方法可供重写.。选择其中一个参数少的即可。接受四个参数：1. Context 2.数据库名 3.一个可以自定义的Cursor对象，一般传入null 4.版本号。
数据库文件放在/data/data/<.package name>/databases/目录下。

这边给出使用database navigator查看数据库的方法：
https://blog.csdn.net/yu75567218/article/details/78904909
书中也有 不过这个更直观

MyDatabaseHelper中：

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 Database succeeded",Toast.LENGTH_SHORT).show()//提示建表成功
    }

    override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
    }
}

MainActivity中：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //调用方式
        val dbHelper = MyDatabaseHelper(this,"BookStore.db",1)
        createDatabase.setOnClickListener {
            dbHelper.writableDatabase
        }
        //getwritableDatabase()方法  第一次点击，会检测到当前程序中没有BookStore.db这个数据库
            //于是会创建该数据库并调用MyDatabaseHelper中的onCreate()方法
        }
}

activity_main.xml 中只有一个按钮这边就不写出了

个人在下载该插件的时候出现了以下问题，据说是版本的问题，就没有使用这个插件了，如果可以下载这个插件也能使用就继续使用吧 ，不行的话就下载个SQLiteStudio

！！！到处的数据的时候要将全部的数据库文件都导出
！！！只导出.db会出现没有数据的问题
详细请看：https://blog.csdn.net/heming9174/article/details/85108035

2. 数据库的升级

修改MyDatabaseHelper

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 Database succeeded",Toast.LENGTH_SHORT).show()//提示建表成功
    }

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        db.execSQL("drop table if exists Book")
        db.execSQL("drop table if exists Category")
        //发现已经存在的表就删除，然后调用onCreate重建
        onCreate(db)
    }
}

然后再将MainActivity中的传入构造方法中的参数修改即可

val dbHelper = MyDatabaseHelper(this,"BookStore.db",2)

3. 添加数据

修改MyDatabaseHelper:

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 Database succeeded",Toast.LENGTH_SHORT).show()//提示建表成功
    }

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        db.execSQL("drop table if exists Book")
        db.execSQL("drop table if exists Category")
        //发现已经存在的表就删除，然后调用onCreate重建
        onCreate(db)
    }
}

修改MainActivity:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //调用方式
        val dbHelper = MyDatabaseHelper(this,"BookStore.db",2)
        createDatabase.setOnClickListener {
            dbHelper.writableDatabase
        }
        //getwritableDatabase()方法  第一次点击，会检测到当前程序中没有BookStore.db这个数据库
            //于是会创建该数据库并调用MyDatabaseHelper中的onCreate()方法

        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)
        }
        }

}

4. 更新数据

update()方法：接受四个参数
第一个参数：表名
第二个参数： ContentValues
第三，四参数：用于约束更新的某一行或某几行中的数据，不指定就会默认更新所有行。

注册一个updateData按钮
在MainActivity中的onCreate中添加：

updateData.setOnClickListener{
            val db = dbHelper.writableDatabase
            val values = ContentValues()
            values.put("price",10.99)
            db.update("Book",values,"name = ?", arrayOf("The Da Vinci Code"))
        }

将The

5. 删除数据

delete（）方法 ：接受三个参数 ：
第一个：表名
第二第三个参数，用于约束删除某一行或某几行的数据，不指定默认删除所有行。

注册一个deteleData按钮
在MainActivity中的onCreate中添加：

deleteData.setOnClickListener{
            val db = dbHelper.writableDatabase
            db.delete("Book","pages > ?", arrayOf("500"))
        }

这样页数超过500页的书就会被删除了

6. 查询数据

query（）方法 ：（最少）七个参数：
参数1：表名；
参数2：用于指定去查询哪几列，不指定默认所有列；
参数3.4：用于约束查询某行或某几行的数据，不指定默认查询所有列；
参数5：用于指定需要去group by 的列，不指定则表示不对查询结果进行group by 操作；
参数6：用于对于group by 之后的数据进行进一步过滤，不指定则不过滤；参数7：用于指定查询结果的排序方式，不指定使用默认的排序方式。

注册一个queryData按钮
在MainActivity中的onCreate中添加：

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.getColumnIndex("name"))
                    val author = cursor.getString(cursor.getColumnIndex("author"))
                    val pages = cursor.getString(cursor.getColumnIndex("pages"))
                    val price = cursor.getString(cursor.getColumnIndex("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()
        }

7. 使用SQL操作数据库

当然我们也可以使用SQL语句来完成前面的所有功能。
db.execSQL(
“insert into Book (name, author, pages, price) values(?, ?, ?, ?)”, arrayOf(“The Da Vinci Code”, “Dan Brown”, “454”, “16.96”)
)
更新数据的方法如下：
db.execSQL(“update Book set price = ? where name = ?”, arrayOf(“10.99”, “The Da Vinci Code”))
删除数据的方法如下：
db.execSQL(“delete from Book where pages > ?”, arrayOf(“500”))
查询数据的方法如下：
val cursor = db.rawQuery(“select * from Book”, null)

7.5 SQLite最佳实践

1.使用事务

在原先的代码布局文件中添加
replaceData按钮
在MainActivity中的onCreate中添加：

replaceData.setOnClickListener{
            val db = dbHelper.writableDatabase
            db.beginTransaction()//开启事务
            try {
                db.delete("Book",null,null)

                val values = ContentValues().apply {
                    put("name","Game of Thrones")
                    put("author","George Martin")
                    put("pages",720)
                    put("price",20.85)
                }
                db.insert("Book",null,values)
                db.setTransactionSuccessful()//事务已经执行成功
            }catch (e: Exception){
                e.printStackTrace()
            }finally {
                db.endTransaction()//结束事务
            }
        }

现在运行程序并点击"Replce Data”"按钮，然后点击“Query Data"按钮。你会发现，Book表中存在的还是之前的旧数据，说明我们的事务确实生效了。然后将手动抛出异常的那行代码删除并重新运行程序，此时点击一下"Replace Datd"按钮，就会将Book表中的数据替换成新数据了，你可以再使用“Query Data”按钮来验证一下。

2. 升级数据库的最佳写法

下面让我们来模拟数据库升级的案例：
第一版本：要求简单需要一个book表

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)//执行建表语句
    }
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
    }
}

过了几星期之后有了新的需求，（添加一个Category表）于是修改：

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)
    }
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        if(oldVersion <=1){
            db.execSQL(createCategory)
        }
    }
}

如果用户数据库的旧版本号小于等于1,就只会创建一张Category表。这样当用户直接安装第2版的程序时，就会进人onCreate()方法，将两张表一起创建。而当用户使用第2版的程序覆盖安装第1版的程序时，就会进人升级数据库的操作中，此时由于Book表已经存在了，因此只需要创建一张Category表即可。

又没过多久，新的需求又来了，这次需要给book和category之间建立关联，需要在book表中添加category_id字段。
修改MyDatabaseHelper中的代码：

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,"+
            "category_id integer)"
    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)
    }
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        if(oldVersion <=1){
            db.execSQL(createCategory)
        }
        if (oldVersion <= 2){
            db.execSQL("alter table Book add column category_id integer")
        }
    }
}

每当升级一个 数据库版本的时候，onUpgrade()方法里一定要写一个相应的if判断语句,确保不管应本怎样更新，都可以保证数据库的表结构是最新的，而且表中的数据完全不会天失

7.6 Kotlin课堂：高阶函数的应用

1.简化SharedPreferences的用法

新建一个SharedPreferences.kt文件在文件中填写代码：

fun SharedPreferences.open(block:SharedPreferences.Editor.() -> Unit){
    val editor = edit()
    editor.block()
    editor.apply()
}

MainActivity的存储数据写法变化：

/*val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
            editor.putString("name","Tom")
            editor.putInt("age",28)
            editor.putBoolean("married",false)
            editor.apply()*/
            getSharedPreferences("data", Context.MODE_PRIVATE).open {
                //open写成edit就是Google的拓展库函数
                putString("name","Tom")
                putInt("age",28)
                putBoolean("married",false)
            }

我们定义的open函数在Google提供的KTX拓展库中已经拥有，我们这边只是把它的edit函数换成了open

2. 简化ContentValues的用法

在Kotlin中允许我们使用A to B 的键值对。
我们创建一个ContentValues.kt文件 然后定义一个cvOf()方法
遍历出来。
这个方法的作用是构建一个ContentValues对象。首先，cvof()方法接收了一个Pair参数，也就是使用AtoB语2其内的&山不对应的就是Java中的可变参数前面加上了一个vararg关键字，这是什么意思呢?其实varargA M类H叫放参i这此参啊都数列表，我们允许向这个方法传入0个、1个、2个甚至任意多个Pair类型的参数，这些参数都会被赋值到使用vararg声明的这一个变量上面，然后使用for-in循环可以将传入的所有参数。
入空值。
再来看声明的Pair类型。由于Pair是一种键值对的数据结构，因此需要通过泛型来指定它的键和值分别对应什么类型的数据。值得庆幸的是ContentValues 的所有键都是字符串类型的，这里可以直接将Pair键的泛型指定成String。但ContentValues的值却可以有多种类型（字符串型、整型、浮点型，甚至是null)，所以我们需要将Pair值的泛型指定成Any?。而 Any?则表示允许传这是因为Any是 Kotlin中所有类的共同基类，相当于Java中的Object，而Any？则表示允许传入空值
接下来我们开始为cvOf()方法实现功能逻辑，核心思路就是先创建一个ContentValues对象，然后遍历pairs 参数列表，取出其中的数据并填人 ContentValues中，最终将ContentValues对象返回即可。思路并不复杂，但是存在一个问题:Pair参数的值是Any?类型的，我们怎样让它ContentValues所支持的数据类型对应起来呢?这个确实没有什么好的办法，只能使用when语句一一进行条件判断，并覆盖ContentValues所支持的所有数据类型。
代码如下：

fun cvOf(vararg pairs: Pair<String, Any?>): ContentValues {
    val cv = ContentValues()
    for (pair in pairs) {
        val key = pair.first
        val value = pair.second
        when (value) {
            is Int -> cv.put(key, value)
            is Long -> cv.put(key, value)
            is Short -> cv.put(key, value)
            is Float -> cv.put(key, value)
            is Double -> cv.put(key, value)
            is Boolean -> cv.put(key, value)
            is String -> cv.put(key, value)
            is Byte -> cv.put(key, value)
            is ByteArray -> cv.put(key, value)
            null -> cv.putNull(key)
        }
    }
    return cv

然后我们可以使用类似mapOf()函数的语法结构构建ContentValues对象
比如借助apply()函数：

fun cvOf(vararg pairs: Pair<String, Any?>)= ContentValues().apply {
    for (pair in pairs) {
        val key = pair.first
        val value = pair.second
        when (value) {
            is Int -> put(key, value)
            is Long -> put(key, value)
            is Short -> put(key, value)
            is Float -> put(key, value)
            is Double -> put(key, value)
            is Boolean -> put(key, value)
            is String -> put(key, value)
            is Byte -> put(key, value)
            is ByteArray -> put(key, value)
            null -> putNull(key)
        }
    }
}

插入数据代码如下：

val values1 = cvOf("name" to "The Da Vinci Code","author" to "Dan Brown","pages" to 454,"price" to 16.96)
            db.insert("Book", null, values1)

当然KTX库中也有一个同样功能的ContentValuesOf()方法