Android SQLlite数据库简单总结

一、

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;
 
     //单例模式 返回DBManager
    private static DataBaseManager INSTANCE = null;
    public static synchronized DataBaseManager getInstance(Context context,String DBName){
        if (INSTANCE == null){
            INSTANCE = new DataBaseManager(context,DBName);
        }
        return INSTANCE;
    }
    /**
     * Context 上下文
     * DBName 数据库名
     * */
    private 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）对查询的结果进行排序
            // 联合-模糊查询
        //String sql = "select ej.name,ej.jibie,ej.zw_name,ej.fuji from zy  left join ej on zy.fenlei = ej.name where  neirong like ? group by fenlei";
        //Cursor cursor = sqLiteDatabase.rawQuery(sql,new String[]{"%"+qwhere+"%"});            
 
            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 HashMap<String , String> querySingleDataFromDB(){
 
       
        String[] queryWhere = new String[]{"1"};
        String sql = "select * from person where infoId = ?";
 
        Cursor cursor = sqLiteDatabase.rawQuery(sql, queryWhere);
        int cur_len = cursor.getColumnCount();//获取数据所有列数
 
        HashMap<String , String> map = new HashMap<>();
 
        while (cursor.moveToNext()) {
            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);
            }
        }
 
        return map;
    }
 
 
        /**
         * 【查询数据条目数】
        * */
      public int getDBCount(){
        // String sql = "select count(*) from person";
        String sql = "select count(fid) from person";
        Cursor cursor = sqLiteDatabase.rawQuery(sql,null);
        cursor.moveToFirst();
        int count = cursor.getInt(0);
        cursor.close();
 
        return count;
     }
 
 
        /**
         * 【关闭数据库】
         * */
        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);
        // 获取数据库（没有则创建）
        dataBaseManager = DataBaseManager.getInstance(this,"test");
 
        // 新增数据
        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);
 
       
    }
 
 
    @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;
        }
    }
}