Android SQLlite数据库简单总结

 SQLiteOpenHelper类 常用方法

/** 
  *  创建数据库
  */ 
 // 1. 创建 or 打开 可读/写的数据库（通过 返回的SQLiteDatabase对象 进行操作）
 getWritableDatabase（）

 // 2. 创建 or 打开 可读的数据库（通过 返回的SQLiteDatabase对象 进行操作）
 getReadableDatabase（）

 // 3. 数据库第1次创建时 则会调用，即 第1次调用 getWritableDatabase（） / getReadableDatabase（）时调用
 // 在继承SQLiteOpenHelper类的子类中复写
 onCreate(SQLiteDatabase db) 

 // 4. 数据库升级时自动调用
 // 在继承SQLiteOpenHelper类的子类中复写
 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)

 // 5. 关闭数据库
 close（）

 /** 
  *  数据库操作（增、删、减、查）
  */ 
 // 1. 查询数据
 (Cursor) query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit)  
 // 查询指定的数据表返回一个带游标的数据集。
 // 各参数说明： 
 // table：表名称 
 // colums：列名称数组 
 // selection：条件子句，相当于where 
 // selectionArgs：条件语句的参数数组 
 // groupBy：分组 
 // having：分组条件 
 // orderBy：排序类 
 // limit：分页查询的限制 
 // Cursor：返回值，相当于结果集ResultSet 

 (Cursor) rawQuery(String sql, String[] selectionArgs) 
 //运行一个预置的SQL语句，返回带游标的数据集（与上面的语句最大的区别 = 防止SQL注入）

 // 2. 删除数据行  
 (int) delete(String table,String whereClause,String[] whereArgs) 
 
 // 3. 添加数据行 
 (long) insert(String table,String nullColumnHack,ContentValues values) 
 
 // 4. 更新数据行 
(int) update(String table, ContentValues values, String whereClause, String[] whereArgs) 
 
 // 5. 执行一个SQL语句，可以是一个select or 其他sql语句 
 // 即 直接使用String类型传入sql语句 & 执行
 (void) execSQL(String sql) 

DataBaseHelper.java文件，继承SQLiteOpenHelper

package com.chy.sqlite.DataBase;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import androidx.annotation.Nullable;
public class DataBaseHelper extends SQLiteOpenHelper {
    private static final int DATABASE_VERSION = 1; //数据库版本号

    /**
     * 构造函数
     * 在SQLiteOpenHelper的子类中，必须有该构造函数
     */
    public DataBaseHelper(@Nullable Context context, @Nullable String name, @Nullable SQLiteDatabase.CursorFactory factory,
                          int version) {
        // 参数说明
        // context：上下文对象
        // name：数据库名称
        // factory：一个可选的游标工厂（通常是 Null）
        // version：当前数据库的版本，值必须是整数并且是递增的状态

        // 必须通过super调用父类的构造函数
        super(context, name, factory, version);
    }

    /**
     * 自定义构造函数
     * */
    public DataBaseHelper(@Nullable Context context, @Nullable String name) {
        super(context, name+".db", null, DATABASE_VERSION);
    }


    /**
     * 复写onCreate（）
     * 调用时刻：当数据库第1次创建时调用
     * 作用：创建数据库 表 & 初始化数据
     * SQLite数据库创建支持的数据类型： 整型数据、字符串类型、日期类型、二进制
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建数据库1张表
        // 通过execSQL（）执行SQL语句（此处创建了1个名为person的表）
        String sql = "create table person(id integer primary key autoincrement,name varchar(64),address varchar(64))";
        db.execSQL(sql);

        // 注：数据库实际上是没被创建 / 打开的（因该方法还没调用）
        // 直到getWritableDatabase() / getReadableDatabase() 第一次被调用时才会进行创建 / 打开
    }

    /**
     * 复写onUpgrade（）
     * 调用时刻：当数据库升级时则自动调用（即 数据库版本 发生变化时）
     * 作用：更新数据库表结构
     * 注：创建SQLiteOpenHelper子类对象时,必须传入一个version参数，
     * 该参数 = 当前数据库版本, 若该版本高于之前版本, 就调用onUpgrade()
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 参数说明：
        // db ： 数据库
        // oldVersion ： 旧版本数据库
        // newVersion ： 新版本数据库
        // 使用 SQL的ALTER语句

        // 向person表中新增 sex 属性
        String sql = "alter table person add sex varchar(8)";
        db.execSQL(sql);
    }
}

DataBaseManager.java

package com.chy.sqlite.DataBase;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

import java.util.ArrayList;
import java.util.HashMap;

public class DataBaseManager {

    DataBaseHelper dbHelper;
    SQLiteDatabase sqLiteDatabase;

    /**
     * Context 上下文
     * DBName 数据库名
     * */
    public DataBaseManager(Context context, String DBName){
        dbHelper = new DataBaseHelper(context, DBName);
        // 创建 or 打开 可读的数据库（通过 返回的SQLiteDatabase对象 进行操作）
        //sqLiteDatabase = dbHelper.getReadableDatabase();// 只有查找（读取）权限

        // 创建 or 打开 可读/写的数据库（通过 返回的SQLiteDatabase对象 进行操作）
        sqLiteDatabase = dbHelper.getWritableDatabase();// 增、删、改、查权限
    }


    /**
     * 【插入数据】
     * */
        public void insertDataToDB(){
            // 创建ContentValues对象
            ContentValues values = new ContentValues();

            /** 向该对象中插入键值对
            * 其中，key = 列名，value = 插入的值
            * 注：CContentValues 和HashTable类似都是一种存储的机制
             * 但是两者最大的区别就在于，
             * contenvalues只能存储基本类型的数据，
             * 像string，int之类的，不能存储对象这种东西，而HashTable却可以存储对象*/
            values.put("name", "测试");
            values.put("address", "长春");

            // 参数1：要操作的表名称
            // 参数2：SQl不允许一个空列，若ContentValues是空，那么这一列被明确的指明为NULL值
            // 参数3：ContentValues对象
           // sqLiteDatabase.insert("person", null, values);

            // 注：也可采用SQL语句插入
            String sql = "insert into person (name,address) values ('test','cc')";
            sqLiteDatabase.execSQL(sql);
        }


        /**
         * 【删除数据】
         *
         * */
        public void deleateToDB(){
            // 参数1：表名(String)
            // 参数2：WHERE表达式（String），需删除数据的行； 若该参数为 null, 就会删除所有行；？号是占位符
            // 参数3：WHERE选择语句的参数(String[]), 逐个替换 WHERE表达式中 的“？”占位符;
            // 删除 id = 1的数据
           // sqLiteDatabase.delete("person", "id=?", new String[]{"1"});


            // 注：也可采用SQL语句修改
            String sql = "delete from person where id='4'";
            sqLiteDatabase.execSQL(sql);
        }

        /**
         * 【更新数据】
         * */
        public void updataToDB(){
            // 创建一个ContentValues对象
            ContentValues values = new ContentValues();
            values.put("name", "lisi");

            // 参数1：表名(String)
            // 参数2：需修改的ContentValues对象
            // 参数3：WHERE表达式（String），需数据更新的行； 若该参数为 null, 就会修改所有行；？号是占位符
            // 参数4：WHERE选择语句的参数(String[]), 逐个替换 WHERE表达式中 的“？”占位符;
            //调用update方法修改数据库：将id=1 修改成 name = zhangsan
           // sqLiteDatabase.update("person", values, "id=?", new String[] { "2" });

            // 注：也可采用SQL语句修改
            String sql = "update person set name = 'lisi' where id='5'";
            sqLiteDatabase.execSQL(sql);
        }


    /**
     * 【查询数据】
     * */
        public void queryDataFromDB(){
            ArrayList<HashMap<String ,String>> list = new ArrayList<>();
            // 参数1：（String）表名
            // 参数2：（String[]）要查询的列名
            // 参数3：（String）查询条件
            // 参数4：（String[]）查询条件的参数
            // 参数5：（String）对查询的结果进行分组
            // 参数6：（String）对分组的结果进行限制
            // 参数7：（String）对查询的结果进行排序
            Cursor cursor = sqLiteDatabase.query("person", new String[] {"id", "name", "address"} , "id = ?", new String[]{"2"}, null, null, null);
            int cur_len = cursor.getColumnCount();//获取数据所有列数

            while (cursor.moveToNext()){
                HashMap<String , String> map = new HashMap<>();
                for (int i=0; i<cur_len; i++){
                    String clos_name = cursor.getColumnName(i);//从给定的索引i返回列名
                    String clos_value = cursor.getString(cursor.getColumnIndex(clos_name));//返回指定的名称，没有就返回-1
                    if(clos_value==null){
                        clos_value = "";
                    }
                    Log.i("TAG:","while循环下面的for循环拿到的数据clos_value为："
                            + cursor.getString(cursor.getColumnIndex(clos_name)));
                    map.put(clos_name , clos_value);
                }
                list.add(map);
            }
        }

        /**
         * 【关闭数据库】
         * */
        public void closeDB(){
            /**注：完成数据库操作后，记得调用close（）关闭数据库，从而释放数据库的连接*/
            sqLiteDatabase.close();
        }

        /**
         * 【自增列清零】
         * */
        private void clearSqlite_sequenceFromDB(){
            // 将自增id列清零，重新计算
            String sql = "update sqlite_sequence set seq=0 where name = 'person'";
            sqLiteDatabase.execSQL(sql);
        }
}

使用方法：

package com.chy.sqlite;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.chy.sqlite.DataBase.DataBaseManager;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button addBtn;
    private Button delBtn;
    private Button updataBtn;
    private Button queryBtn;

    private DataBaseManager dataBaseManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 新增数据
        addBtn = findViewById(R.id.addBtn);
        addBtn.setOnClickListener(this);
        // 删除数据
        delBtn = findViewById(R.id.delBtn);
        delBtn.setOnClickListener(this);
        // 更新数据
        updataBtn = findViewById(R.id.updataBtn);
        updataBtn.setOnClickListener(this);
        // 查找数据
        queryBtn = findViewById(R.id.queryBtn);
        queryBtn.setOnClickListener(this);

        dataBaseManager = new DataBaseManager(this, "test");
    }


    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.addBtn:
                    dataBaseManager.insertDataToDB();
                break;
            case R.id.delBtn:
                    dataBaseManager.deleateToDB();
                break;
            case R.id.updataBtn:
                    dataBaseManager.updataToDB();
                break;
            case R.id.queryBtn:
                    dataBaseManager.queryDataFromDB();
                break;
        }
    }
}