Android SQLite

SP

/**
 * 保存到SP
 * @param view
 */
public void saveToSP(View view) {
    SharedPreferences sp = getSharedPreferences("SPName", Context.MODE_PRIVATE);
    sp.edit().putString("name", "Tony").apply(); // apply才会写入到 xml配置文件里面去
}

/**
 * 获取SP的数据
 * @param view
 */
public void getSpData(View view) {

    SharedPreferences sp = getSharedPreferences("SPName", Context.MODE_PRIVATE);

    String value = sp.getString("name", "deffault");// 假设 name 获取的值是空的，那么就会使用 默认值

    Toast.makeText(this, "" + value, Toast.LENGTH_SHORT).show();

}

SQLite

创建工具类

/**
 *  MySqliteOpenHelper 工具类   单例模式（1.构造函数私有化  2.对外提供函数）
 */
public class MySqliteOpenHelper extends SQLiteOpenHelper {

    // 2.对外提供函数  单例模式
    private static SQLiteOpenHelper mInstance;
    public static synchronized SQLiteOpenHelper getInstance(Context context) {
        if (mInstance == null) {
            mInstance = new MySqliteOpenHelper(context, "myDB.db", null, 1); // 以后想要数据库升级  修改成2   修改成3
        }
        return mInstance;
    }

    // 1.构造函数私有化
    private MySqliteOpenHelper(@Nullable Context context, @Nullable String name, @Nullable SQLiteDatabase.CursorFactory factory, int version) {
        super(context, name, factory, version);
    }

    // 创建表  表数据初始化  数据库第一次创建的时候调用    第二次发现有了 就不会重复创建了，也意味着：次函数只会执行一次
    // 数据库初始化时用的
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建表：persons表  _id  name

        // 主键： primary key  必须唯一的
        // 自动增长数字：例如：1 2 3 4 5 6  autoincrement
        //_id标准的写法（要求1）     只能使用   主键只能是Integer类型的（要求2）
        // id 不标准

        String sql = "create table persons(_id integer primary key autoincrement, name text)";

        db.execSQL(sql);
    }

    // 数据库升级用的
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }
}

生成db

SQLiteOpenHelper helper = MySqliteOpenHelper.getInstance(this);
// (helper.getWritableDatabase() / helper.getReadableDatabase()) databases 文件夹的创建，靠下面这句话
SQLiteDatabase readableDatabase = helper.getReadableDatabase();

查询

SQLiteOpenHelper helper = MySqliteOpenHelper.getInstance(this);
SQLiteDatabase db = helper.getReadableDatabase();

// 确保数据库打开成功，才能放心操作，规范
if (db.isOpen()) { // 数据库打开成功 返回true 进入if
    // 返回游标
    Cursor cursor = db.rawQuery("select * from persons", null);

    // 迭代游标  往下面移动来遍历数据
    while(cursor.moveToNext()) {
        // 偷懒的写法
        // int _id = cursor.getInt(0);
        // String name = cursor.getString(1);

        // 规范写法
        int _id = cursor.getInt(cursor.getColumnIndex("_id"));
        String name = cursor.getString(cursor.getColumnIndex("name"));

        Log.d("mytest", "query: _id:" + _id + " name:" + name);

    }

    // 一定记得关闭游标 否则耗费性能 规范写法
    cursor.close();
    // 数据库也要关闭 规范写法
    db.close();
}

插入

SQLiteOpenHelper helper = MySqliteOpenHelper.getInstance(this);
SQLiteDatabase db = helper.getWritableDatabase();

if (db.isOpen()) { // 确保数据库打开成功，才能放心操作，规范
    // 插入语句
    String sql = "insert into persons(name) values('meme')";

    db.execSQL(sql);

    // 规范：必须关闭 数据库
    db.close();
}

修改

SQLiteOpenHelper helper = MySqliteOpenHelper.getInstance(this);
SQLiteDatabase db = helper.getWritableDatabase();

if (db.isOpen()) { // 确保数据库打开成功，才能放心操作，规范
    // 修改语句
    String sql = "update persons set name =? where _id =?";

    db.execSQL(sql, new Object[]{"you", 5});

    // 规范：必须关闭 数据库
    db.close();
}

删除

SQLiteOpenHelper helper = MySqliteOpenHelper.getInstance(this);
SQLiteDatabase db = helper.getWritableDatabase();

if (db.isOpen()) { // 确保数据库打开成功，才能放心操作，规范

    // 删除语句
    String sql = "delete from persons where _id =?";

    db.execSQL(sql, new Object[]{4});

    // 规范：必须关闭 数据库
    db.close();
}

Room

导包

    // Room的支持
    def room_version = "2.2.0-alpha01"
    implementation "androidx.room:room-runtime:$room_version" // Room 的 APi支持
    annotationProcessor "androidx.room:room-compiler:$room_version" // Room 的注解处理器

创建

1. 必须先创建一个需要映射的实体类，用@Entity进行注解

@Entity
public class Student {

    // 主键唯一  主键自动增长
    @PrimaryKey(autoGenerate = true)
    private int id;

    private String name;

    private int age;

    /*public Student() {
    }*/

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2. 创建一个操作实体类的dao接口,用@Dao进行注解

@Dao // Database access object == 对表进行 增删改查
public interface StudentDao {

    // 增
    @Insert
    void insertStudents(Student ... students);

    // 改
    @Update
    void updateStudents(Student... students);

    // 删  条件
    @Delete
    void deleteStudents(Student... students);

    // 删除 所有      @Delete 单个条件删除用的
    @Query("DELETE FROM Student")
    void deleteAllStudents();

    // 查询 所有  倒序 查询
    @Query("SELECT * FROM Student ORDER BY ID DESC")
    List<Student> getAllStudent();

	// 查询单个
	@Query("SELECT * FROM Student WHERE name = :name")
    Anime getStudentByName(String name);
}

3. 创建一个抽象类，添加@Database注解

// 数据库 关联  之前的 表  数据库信息
@Database(entities = {Student.class}, version = 1, exportSchema = false)
public abstract class StudentDatabase extends RoomDatabase {

    // 用户只需要操作dao，我们必须暴漏dao，dao被用户拿到后，就能对数据库 增删改查了
    public abstract StudentDao getStudentDao();

    // 单例模式  返回 DB
    private static StudentDatabase INSTANCE;
    public static synchronized StudentDatabase getInstance(Context context) {
        if (INSTANCE == null) {
            INSTANCE = Room.databaseBuilder
                    (context.getApplicationContext(), StudentDatabase.class, "student_database")

                    // 如果我们想玩数据库 默认是异步线程

                    // 慎用：强制开启 主线程 也可以操作 数据库  （测试可以用， 真实环境下 不要用）
                    //.allowMainThreadQueries()

                    .build();
        }
        return INSTANCE;
    }

}

4. 创建一个管理类

// DB的引擎
public class DBEngine {

    // 我只需要拿到dao，就能够对数据库 增删改查了
    private StudentDao studentDao;

    public DBEngine(Context context) {
        StudentDatabase studentDatabase = StudentDatabase.getInstance(context);
        studentDao = studentDatabase.getStudentDao();
    }

    // dao 增删改查

    // insert 插入
    public void insertStudents(Student... students) {
        new InsertAsyncTask(studentDao).execute(students);
    }

    // update 更新
    public void updateStudents(Student... students) {
        new UpdateAsyncTask(studentDao).execute(students);
    }

    // delete 删除 条件
    public void deleteStudents(Student... students) {
        new DeleteAsyncTask(studentDao).execute(students);
    }

    // delete 全部删除
    public void deleteAllStudents() {
        new DeleteAllAsyncTask(studentDao).execute();
    }

    // 查询全部
    public void queryAllStudents() {
        new QueryAllAsyncTask(studentDao).execute();
    }

    // 如果我们想玩数据库 默认是异步线程  ============  异步操作

    // insert 插入
    static class InsertAsyncTask extends AsyncTask<Student, Void, Void> {

        private StudentDao dao;

        public InsertAsyncTask(StudentDao studentDao) {
            dao = studentDao;
        }

        @Override
        protected Void doInBackground(Student... students) {
            dao.insertStudents(students);
            return null;
        }
    }

    // update 更新
    static class UpdateAsyncTask extends AsyncTask<Student, Void, Void> {

        private StudentDao dao;

        public UpdateAsyncTask(StudentDao studentDao) {
            dao = studentDao;
        }

        @Override
        protected Void doInBackground(Student... students) {
            dao.updateStudents(students);
            return null;
        }
    }

    // delete 删除 条件
    static class DeleteAsyncTask extends AsyncTask<Student, Void, Void> {

        private StudentDao dao;

        public DeleteAsyncTask(StudentDao studentDao) {
            dao = studentDao;
        }

        @Override
        protected Void doInBackground(Student... students) { // 既然传递了 student 进来，就是条件删除
            dao.deleteStudents(students);
            return null;
        }
    }

    // 删除 全部删除
    static class DeleteAllAsyncTask extends AsyncTask<Void, Void, Void> {

        private StudentDao dao;

        public DeleteAllAsyncTask(StudentDao studentDao) {
            dao = studentDao;
        }


        @Override
        protected Void doInBackground(Void... voids) {
            dao.deleteAllStudents();
            return null;
        }
    }

    // 全部 查询
    private static class QueryAllAsyncTask extends AsyncTask<Void, Void, Void> {

        private StudentDao dao;

        public QueryAllAsyncTask(StudentDao studentDao) {
            dao = studentDao;
        }

        @Override
        protected Void doInBackground(Void... voids) {
            List<Student> allStudent = dao.getAllStudent();

            // 遍历全部查询的结构
            for (Student student : allStudent) {
                Log.e("Derry", "doInBackground: 全部 查询 每一项：" + student.toString() );
            }

            return null;
        }
    }

}

增删改查

    private DBEngine dbEngine;
    dbEngine = new DBEngine(this);

    /**
     * 插入
     * @param view
     */
    public void insertAction(View view) {
        Student student1 = new Student("张三", 20);
        Student student2 = new Student("李四", 23);
        Student student3 = new Student("王五", 27);
        dbEngine.insertStudents(student1, student2, student3);
    }

    /**
     * 修改  下标为 3   修改成："李元霸", 40
     * @param view
     */
    public void updateAction(View view) {
        Student student = new Student("李元霸", 40);
        student.setId(3);
        dbEngine.updateStudents(student);
    }

    /**
     * 删除 条件 下标为 3
     * @param view
     */
    public void deleteAction(View view) {
        Student student = new Student(null, 0);
        student.setId(3);
        dbEngine.deleteStudents(student);
    }

    /**
     * 查询
     * @param view
     */
    public void queryAction(View view) {
        dbEngine.queryAllStudents();
    }

    /**
     * 全部 删除
     * @param view
     */
    public void deleteAllAction(View view) {
        dbEngine.deleteAllStudents();
    }