精华内容
下载资源
问答
  • 2022-02-07 15:34:08

    Android SQLite数据库相关API的介绍可以看这篇文章

    Android SQLite数据库中基础的增删改查操作以及API的详解

    效果如图所示:

    在这里插入图片描述
    一、向数据库中写入数据

    1.首先创建数据库user和表user_info,详细的注释已经在代码中给出

    public class UserDBHelper extends SQLiteOpenHelper {
        private static final String TAG = "UserDBHelper";
        //声明数据库帮助器的实例
        public static UserDBHelper userDBHelper = null;
        //声明数据库的实例
        private SQLiteDatabase db = null;
        //声明数据库的名称
        public static final String DB_NAME = "user.db";
        //声明表的名称
        public static final String TABLE_NAME = "user_info";
        //声明数据库的版本号
        public static int DB_VERSION = 1;
    
        public UserDBHelper(@Nullable Context context) {
            super(context, DB_NAME, null, DB_VERSION);
        }
    
        public UserDBHelper(@Nullable Context context, int version) {
            super(context, DB_NAME, null, version);
        }
    
        //利用单例模式获取数据库帮助器的实例
        public static UserDBHelper getInstance(Context context, int version) {
            if (userDBHelper == null && version > 0) {
                userDBHelper = new UserDBHelper(context, version);
            } else if (userDBHelper == null) {
                userDBHelper = new UserDBHelper(context);
            }
            return userDBHelper;
        }
    
        //打开数据库的写连接
        public SQLiteDatabase openWriteLink() {
            if (db == null || !db.isOpen()) {
                db = userDBHelper.getWritableDatabase();
            }
            return db;
        }
    
    	//getWritableDatabase()与getReadableDatabase() 这两个方法都可以获取到数据库的连接
    	//正常情况下没有区别,当手机存储空间不够了
    	//getReadableDatabase()就不能进行插入操作了,执行插入没有效果
    	//getWritableDatabase():也不能进行插入操作,如果执行插入数据的操作,则会抛异常。对于现在来说不会出现这种情况,用哪种方式都可以
    
        //打开数据库的读连接
        public SQLiteDatabase openReadLink() {
            if (db == null || !db.isOpen()) {
                db = userDBHelper.getReadableDatabase();
            }
            return db;
        }
    
        //关闭数据库的读连接
        public void closeLink() {
            if (db != null && db.isOpen()) {
                db.close();
                db = null;
            }
        }
    
    
        @Override
        public void onCreate(SQLiteDatabase db) {
            //如果存在user_info表,则删除该表
            String drop_sql = "DROP TABLE IF EXISTS " + TABLE_NAME + ";";
            db.execSQL(drop_sql);
            //创建user_info表
            String create_sql = "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + "("
                    + "_id INTEGER PRIMARY KEY AUTOINCREMENT,"
                    + "name VARCHAR NOT NULL,"
                    + "age INTEGER NOT NULL,"
                    + "height INTEGER NOT NULL,"
                    + "weight DECIMAL(10,2) NOT NULL,"
                    + "married INTEGER NOT NULL,"
                    + "update_time VARCHAR NOT NULL"
                    + ");";
            db.execSQL(create_sql);
        }
    
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    
        }
    
        //根据指定条件删除表记录
        public int delete(String condition) {
            // 执行删除记录动作,该语句返回删除记录的数目
            //参数一:表名
            //参数二:whereClause where子句
            //参数三:whereArgs 您可以在 where 子句中包含 ?s,
            // 它将被 whereArgs 中的值替换。这些值将绑定为字符串。
            return db.delete(TABLE_NAME, condition, null);
        }
    
        //删除该表所有记录
        public int deleteAll() {
            // 执行删除记录动作,该语句返回删除记录的数目
            return db.delete(TABLE_NAME, "1=1", null);
        }
    
        // 往该表添加一条记录
        public long insert(UserInfo userInfo) {
            List<UserInfo> infoList = new ArrayList<>();
            infoList.add(userInfo);
            return insert(infoList);
        }
    
        // 往该表添加多条记录
        public long insert(List<UserInfo> infoList) {
            long result = -1;
            for (int i = 0; i < infoList.size(); i++) {
                UserInfo userInfo = infoList.get(i);
                List<UserInfo> tempList = new ArrayList<>();
                // 如果存在同名记录,则更新记录
                // 注意条件语句的等号后面要用单引号括起来
                if (userInfo.name != null && userInfo.name.length() > 0) {
                    String condition = String.format("name='%s'", userInfo.name);
                    tempList = query(condition);
                    if (tempList.size() > 0) {
                        update(userInfo, condition);
                        result = tempList.get(0).rowid;
                        continue;
                    }
                }
                // 不存在唯一性重复的记录,则插入新记录
                ContentValues cv = new ContentValues();
                cv.put("name", userInfo.name);
                cv.put("age", userInfo.age);
                cv.put("height", userInfo.height);
                cv.put("weight", userInfo.weight);
                cv.put("married", userInfo.married);
                cv.put("update_time", userInfo.update_time);
                // 执行插入记录动作,该语句返回插入记录的行号
                //参数二:参数未设置为NULL,参数提供可空列名称的名称,以便在 cv 为空的情况下显式插入 NULL。
                //参数三:values 此映射包含行的初始列值。键应该是列名,值应该是列值
                result = db.insert(TABLE_NAME, "", cv);
                // 添加成功则返回行号,添加失败则返回-1
                if (result == -1) {
                    return result;
                }
            }
            return result;
        }
    
        //根据条件更新指定的表记录
        public int update(UserInfo userInfo, String condition) {
            ContentValues cv = new ContentValues();
            cv.put("name", userInfo.name);
            cv.put("age", userInfo.age);
            cv.put("height", userInfo.height);
            cv.put("weight", userInfo.weight);
            cv.put("married", userInfo.married);
            cv.put("update_time", userInfo.update_time);
            //执行更新记录动作,该语句返回更新的记录数量
            //参数二:values 从列名到新列值的映射
            //参数三:whereClause 更新时要应用的可选 WHERE 子句
            //参数四:whereArgs 您可以在 where 子句中包含 ?s,
            //它将被 whereArgs 中的值替换。这些值将绑定为字符串。
            return db.update(TABLE_NAME, cv, condition, null);
        }
    
        public int update(UserInfo userInfo) {
            // 执行更新记录动作,该语句返回更新的记录数量
            return update(userInfo, "rowid=" + userInfo.rowid);
        }
    
        public List<UserInfo> query(String condition) {
            String sql = String.format("select rowid,_id,name,age,height,weight,married,update_time" +
                    " from %s where %s;", TABLE_NAME, condition);
            List<UserInfo> infoList = new ArrayList<>();
            // 执行记录查询动作,该语句返回结果集的游标
            //参数一:SQL查询
            //参数二:selectionArgs
            //您可以在查询的 where 子句中包含 ?s,它将被 selectionArgs 中的值替换。这些值将绑定为字符串。
            Cursor cursor = db.rawQuery(sql, null);
            // 循环取出游标指向的每条记录
            while (cursor.moveToNext()) {
                UserInfo userInfo = new UserInfo();
                //Xxx getXxx(columnIndex):根据字段下标得到对应的值
                //int getColumnIndex():根据字段名得到对应的下标
                //cursor.getLong():以 long 形式返回所请求列的值。
                //getColumnIndex() 获取给定列名的从零开始的列索引,如果列名不存在返回-1
                userInfo.name = cursor.getString(cursor.getColumnIndex("name"));
                userInfo.age = cursor.getInt(cursor.getColumnIndex("age"));
                userInfo.height = cursor.getLong(cursor.getColumnIndex("height"));
                userInfo.weight = cursor.getFloat(cursor.getColumnIndex("weight"));
                //SQLite没有布尔型,用0表示false,用1表示true
                userInfo.married = (cursor.getInt(cursor.getColumnIndex("married")) == 0) ? false : true;
                userInfo.update_time = cursor.getString(cursor.getColumnIndex("update_time"));
                infoList.add(userInfo);
            }
            //查询完毕,关闭数据库游标
            cursor.close();
            return infoList;
        }
    }
    

    2.创建UserInfo实体类

    //用户信息
    public class UserInfo {
        public long rowid; // 行号
        public int xuhao; // 序号
        public String name; // 姓名
        public int age; // 年龄
        public long height; // 身高
        public float weight; // 体重
        public boolean married; // 婚否
        public String update_time; // 更新时间
    
        public UserInfo() {
            rowid = 0L;
            xuhao = 0;
            name = "";
            age = 0;
            height = 0L;
            weight = 0.0f;
            married = false;
            update_time = "";
        }
    }
    

    3.创建布局页面activity_sqilte_write.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="5dp"
        tools:context=".SqilteWriteActivity">
    
        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="40dp">
    
            <TextView
                android:id="@+id/tv_name"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="姓名:"
                android:textColor="@color/black"
                android:textSize="17sp" />
    
            <EditText
                android:id="@+id/edit_name"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_marginTop="3dp"
                android:layout_marginBottom="3dp"
                android:layout_toRightOf="@+id/tv_name"
                android:background="@drawable/edit_style"
                android:gravity="center|left"
                android:hint="请输入姓名"
                android:inputType="text"
                android:maxLength="12"
                android:textSize="17sp" />
        </RelativeLayout>
    
        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="40dp">
    
            <TextView
                android:id="@+id/tv_age"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="年龄:"
                android:textColor="@color/black"
                android:textSize="17sp" />
    
            <EditText
                android:id="@+id/edit_age"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_marginTop="3dp"
                android:layout_marginBottom="3dp"
                android:layout_toRightOf="@+id/tv_age"
                android:background="@drawable/edit_style"
                android:gravity="center|left"
                android:hint="请输入年龄"
                android:inputType="number"
                android:maxLength="2"
                android:textSize="17sp" />
        </RelativeLayout>
    
        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="40dp">
    
            <TextView
                android:id="@+id/tv_height"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="身高:"
                android:textColor="@color/black"
                android:textSize="17sp" />
    
            <EditText
                android:id="@+id/edit_height"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_marginTop="3dp"
                android:layout_marginBottom="3dp"
                android:layout_toRightOf="@+id/tv_height"
                android:background="@drawable/edit_style"
                android:gravity="center|left"
                android:hint="请输入身高"
                android:inputType="number"
                android:maxLength="3"
                android:textSize="17sp" />
        </RelativeLayout>
    
        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="40dp">
    
            <TextView
                android:id="@+id/tv_weight"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="体重:"
                android:textColor="@color/black"
                android:textSize="17sp" />
    
            <EditText
                android:id="@+id/edit_weight"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_marginTop="3dp"
                android:layout_marginBottom="3dp"
                android:layout_toRightOf="@+id/tv_weight"
                android:background="@drawable/edit_style"
                android:gravity="center|left"
                android:hint="请输入体重"
                android:inputType="numberDecimal"
                android:maxLength="5"
                android:textSize="17sp" />
        </RelativeLayout>
    
        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="40dp">
    
            <CheckBox
                android:id="@+id/checkbox"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center" />
    
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:layout_toRightOf="@+id/checkbox"
                android:gravity="center"
                android:text="已婚"
                android:textColor="@color/black"
                android:textSize="17sp" />
        </RelativeLayout>
    
        <Button
            android:id="@+id/btn_save"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="保存到数据库"
            android:textColor="@color/black"
            android:textSize="17sp" />
    </LinearLayout>
    

    4.创建SqilteWriteActivity类添加数据

    public class SqilteWriteActivity extends AppCompatActivity implements View.OnClickListener, CompoundButton.OnCheckedChangeListener {
        private EditText edit_name;
        private EditText edit_age;
        private EditText edit_height;
        private EditText edit_weight;
        private CheckBox checkbox;
        private Button btn_save;
        private boolean isMarried = false;
    
        //声明数据库帮助器的对象
        private UserDBHelper userDBHelper;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_sqilte_write);
            edit_name = findViewById(R.id.edit_name);
            edit_age = findViewById(R.id.edit_age);
            edit_height = findViewById(R.id.edit_height);
            edit_weight = findViewById(R.id.edit_weight);
            checkbox = findViewById(R.id.checkbox);
            checkbox.setOnCheckedChangeListener(this);
            btn_save = findViewById(R.id.btn_save);
            btn_save.setOnClickListener(this);
        }
    
        @Override
        public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
            isMarried = isChecked;
        }
    
        @Override
        protected void onStart() {
            super.onStart();
            userDBHelper = UserDBHelper.getInstance(this, 1);
            //打开数据库帮助器的写连接
            userDBHelper.openWriteLink();
        }
    
        @Override
        public void onClick(View v) {
            if (v.getId() == R.id.btn_save) {
                String name = edit_name.getText().toString();
                String age = edit_age.getText().toString();
                String height = edit_height.getText().toString();
                String weight = edit_weight.getText().toString();
                if (TextUtils.isEmpty(name)) {
                    ToastUtil.show(this, "请先填写姓名");
                    return;
                } else if (TextUtils.isEmpty(age)) {
                    ToastUtil.show(this, "请先填写年龄");
                    return;
                } else if (TextUtils.isEmpty(height)) {
                    ToastUtil.show(this, "请先填写身高");
                    return;
                } else if (TextUtils.isEmpty(weight)) {
                    ToastUtil.show(this, "请先填写体重");
                    return;
                }
                UserInfo userInfo = new UserInfo();
                userInfo.name = name;
                userInfo.age = Integer.parseInt(age);
                userInfo.height = Long.parseLong(height);
                userInfo.weight = Float.parseFloat(weight);
                userInfo.married = isMarried;
                @SuppressLint("SimpleDateFormat")
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String nowTime = sdf.format(new Date());
                userInfo.update_time = nowTime;
                userDBHelper.insert(userInfo);
                ToastUtil.show(this, "数据已写入SQLite数据库");
            }
        }
    
        @Override
        protected void onStop() {
            super.onStop();
            userDBHelper.closeLink();
        }
    }
    

    以上就是添加数据的代码详解

    二、读取数据库中的数据

    1.布局页面activity_sqlite_read.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".SqliteReadActivity">
        
        <Button
            android:id="@+id/btn_delete_all"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="删除所有记录"
            android:textColor="@color/black"
            android:textSize="17sp" />
    
        <TextView
            android:id="@+id/tv_sqlite"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:paddingLeft="5dp"
            android:textColor="@color/black"
            android:textSize="17sp" />
    
    </LinearLayout>
    

    2.创建SqliteReadActivity类显示数据库中的数据,并且实现删除功能

    public class SqliteReadActivity extends AppCompatActivity implements View.OnClickListener {
        private Button btn_delete_all;
        private TextView tv_sqlite;
        //声明数据库帮助器的实例
        private UserDBHelper userDBHelper;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_sqlite_read);
            btn_delete_all = findViewById(R.id.btn_delete_all);
            btn_delete_all.setOnClickListener(this);
            tv_sqlite = findViewById(R.id.tv_sqlite);
        }
    
        @Override
        protected void onStart() {
            super.onStart();
            //获得数据库帮助器的实例
            userDBHelper = UserDBHelper.getInstance(this, 1);
            //打开数据库帮助器的读连接
            userDBHelper.openReadLink();
            // 读取数据库中保存的所有用户记录
            readSQLite();
        }
    
        @SuppressLint("DefaultLocale")
        private void readSQLite() {
            if (userDBHelper == null) {
                ToastUtil.show(this, "数据库连接为空!");
                return;
            }
            // 执行数据库帮助器的查询操作
            List<UserInfo> userInfoList = userDBHelper.query("1=1");
            String desc = String.format("数据库查询到%d条记录,详情如下:", userInfoList.size());
            for (int i = 0; i < userInfoList.size(); i++) {
                UserInfo userInfo = userInfoList.get(i);
                desc = String.format("%s\n第%d条记录信息如下:", desc, i + 1);
                desc = String.format("%s\n 姓名为%s", desc, userInfo.name);
                desc = String.format("%s\n 年龄为%d", desc, userInfo.age);
                desc = String.format("%s\n 身高为%d", desc, userInfo.height);
                desc = String.format("%s\n 体重为%f", desc, userInfo.weight);
                desc = String.format("%s\n 婚否为%b", desc, userInfo.married);
                desc = String.format("%s\n 更新时间为%s", desc, userInfo.update_time);
            }
            if (userInfoList.size() <= 0) {
                desc = "数据库查询到的记录为空";
            }
            tv_sqlite.setText(desc);
        }
    
    
        @Override
        public void onClick(View v) {
            if (v.getId() == R.id.btn_delete_all) {
                //关闭数据库连接
                userDBHelper.closeLink();
                //打开数据库帮助器的写连接
                userDBHelper.openWriteLink();
                //删除所有记录
                userDBHelper.deleteAll();
                //关闭数据库连接
                userDBHelper.closeLink();
                //打开数据库帮助器的读连接
                userDBHelper.openReadLink();
                //读取数据库中保存的所有用户记录
                readSQLite();
                ToastUtil.show(this, "已删除所有记录");
            }
        }
    }
    

    以上就是显示数据库中的数据的详细步骤,和删除数据的步骤~

    更多相关内容
  • Android为了操作SQlite数据库,提供了SQLiteDatabase类,其内封装了insert 、delete、update 、query 、执行SQL命令等操作。同时又为SQLiteDatabase提供了一个辅助类,SQLiteOpenHelper。它提供了两个重要的方法,...
  • 成功包含着黄连与蜂蜜,黄连在成功前吞咽,蜂蜜在成功后...③SQLite数据库存储数据; ④使用ContentProvider存储数据; ⑤网络存储数据。 使用SQLite保存数据: SQLite是一种小巧的嵌入式数据库,使用方便、开发简单。

            Android提供了5种方式来让用户保存持久化应用程序数据。根据自己的需求来做选择,比如数据是否是应用程序私有的,是否能被其他程序访问,需要多少数据存储空间等,分别是: 

            ①使用SharedPreferences存储数据 

            ②文件存储数据

            ③SQLite数据库存储数据

            ④使用ContentProvider存储数据

            ⑤网络存储数据 

    使用SQLite保存数据

            对于重复数据或结构化数据(例如联系信息),将数据保存到数据库是理想选择。下面咱咱就开始在Android上使用SQLite数据库。android.database.sqlite软件包中提供了在Android上使用数据库所需的API。

            咱先玩玩SQLite数据库,后面咱从SQLite迁移到Room。

            注意:虽然这些API功能强大,但它们的级别较低,使用起来需要花费大量时间和精力:

    • 没有针对原始SQL查询的编译时验证。随着数据图表不断发生变化,你需要手动更新受影响的SQL查询。此过程既耗时又容易出错。
    • 你需要使用大量样板代码,在SQL查询和数据对象之间进行转换。

            出于这些原因,咱强烈建议将Room持久性库用作抽象层以访问应用的SQLite数据库中的信息。

    SQL的基本语法

            SQL本质上是一种编程语言,它的学名叫作“结构化查询语言”(全称为StructuredQuery Language,简称SQL)。不过SQL语言并非通用的编程语言,它专用于数据库的访问和处理,更像是一种操作命令,所以常说SQL语句而不说SQL代码。标准的SQL语句分为3类:数据定义、数据操纵和数据控制,但不同的数据库往往有自己的实现。

            SQLite是一种小巧的嵌入式数据库,使用方便、开发简单。如同MySQL、Oracle那样,SQLite也采用SQL语句管理数据,由于它属于轻型数据库,不涉及复杂的数据控制操作,因此App开发只用到数据定义和数据操纵两类SQL。此外,SQLite的SQL语法与通用的SQL语法略有不同。

    数据库帮助器SQLiteOpenHelper

            由于SQLiteDatabase存在局限性,一不小心就会重复打开数据库,处理数据库的升级也不方便;因此Android提供了数据库帮助器SQLiteOpenHelper,帮助开发者合理使用SQLite。

    SQLiteOpenHelper的具体使用步骤如下:

            步骤1:新建一个继承自SQLiteOpenHelper的数据库操作类,按提示重写onCreate和onUpgrade两个方法。其中,onCreate方法只在第一次打开数据库时执行,在此可以创建表结构;而onUpgrade方法在数据库版本升高时执行,在此可以根据新旧版本号变更表结构。

            步骤2:为保证数据库安全使用,需要封装几个必要方法,包括获取单例对象.打开数据库连接、关闭数据库连接,说明如下:

    • 获取单例对象:确保在App运行过程中数据库只会打开一次,避免重复打开引起错误。
    • 打开数据库连接:SQLite有锁机制,即读锁和写锁的处理;故而数据库连接也分两种,读连接可调用getReadableDatabase方法获得,写连接可调用getWritableDatabase获得。
    • 关闭数据库连接:数据库操作完毕,调用数据库实例的close方法关闭连接。

            步骤3:提供对表记录增加、删除、修改、查询的操作方法。

    继承SQLiteOpenHelper类,重写onCreate、onUpgrade、onOpen方法

    public class UserDBHelper extends SQLiteOpenHelper {
        private static final String DB_NAME = "user.db";//数据库的名称
        private static UserDBHelper mHelper = null;//数据库帮助器的实例
        private SQLiteDatabase mDB = null;//数据库的实例
        public static final String TABLE_NAME = "user_info";
        public static final String _ID = "_id";
        public static final String COLUMN_NAME = "name";
        public static final String COLUMN_AGE = "age";
        public static final String COLUMN_UPDATE_TIME = "update_time";
        /**
         * @param context 上下文环境(例如,一个 Activity)
         *                DB_NAME  数据库名字
         *                factory  null  一个可选的游标工厂(通常是 Null)
         * @param version 数据库模型版本的整数
         *                会调用父类 SQLiteOpenHelper的构造函数
         */
        public UserDBHelper(Context context, int version) {
            super(context, DB_NAME, null, version);
        }
    
        //利用单例模式获取SQLiteOpenHelper的唯一实例
        public static UserDBHelper getInstance(Context context, int version) {
            if (version > 0 && mHelper == null) {
                mHelper = new UserDBHelper(context, version);
            }
            return mHelper;
        }
        //创建数据库表,执行建表语句
        @Override
        public void onCreate(SQLiteDatabase db) {
        }
        /**
         * 当数据库需要修改的时候(两个数据库版本不同),Android系统会主动的调用这个方法。
         * 一般我们在这个方法里边删除数据库表,并建立新的数据库表.
         */
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        }
        @Override
        public void onOpen(SQLiteDatabase db) {
            //每次成功打开数据库后首先被执行
            super.onOpen(db);
        }
    }
    

    创建表

            表格的创建动作由create命令完成,格式为“CREATE TABLE IFNOT EXISTS表格名称(以逗号分隔的各字段定义);”。以用户信息表为例,它的建表语句如下所示:

    //创建数据库表,执行建表语句
    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.e(getClass().getName(), "onCreate");
        //创建表语句
        String SQL_CREATE_ENTRIES = "CREATE TABLE IF NOT EXISTS "
                + TABLE_NAME + "("
                + _ID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
                + COLUMN_NAME+" VARCHAR NOT NULL,"
                + COLUMN_AGE+" INTEGER NOT NULL,"
                + COLUMN_UPDATE_TIME+" VARCHAR NOT NULL" + "); ";
        //执行完整的sQL语句
        db.execSQL(SQL_CREATE_ENTRIES);
    }

            上面的SQL语法与其他数据库的SQL语法有所出入,相关的注意点说明见下:

            ①SQL语句不区分大小写,无论是create与table这类关键词,还是表格名称、字段名称,都不区分大小写。唯一区分大小写的是被单引号括起来的字符串值。

            ②为避免重复建表,应加上IF NOT EXISTS关键词,例如CREATE TABLE IFNOT EXISTS表格名称......

            ③SQLite支持整型INTEGER、长整型LONG、字符串VARCHAR、浮点数FLOAT,但不支持布尔类型。布尔类型的数据要使用整型保存,如果直接保存布尔数据,在入库时sQLite会自动将它转为0或1,其中0表示false,1表示true。

            ④建表时需要唯一标识字段,它的字段名为_id。创建新表都要加上该字段定义,例如_id lNTEGER PRIMARY KEY AUTOINCREMENT NOT NULL。

    删除表

            表格的删除动作由drop命令完成,格式为“DROP TABLE IFEXISTS表格名称;”。下面是删除用户信息表的SQL语句例子:

    //删除表
    public void deleteTable(SQLiteDatabase db) {
        String SQL_DELETE_ENTRIES = "DROP TABLE IF EXISTS " + TABLE_NAME;
        db.execSQL(SQL_DELETE_ENTRIES);
    }

    打开数据库表

            下面这段代码会返回一个 SQLiteDatabase 类的实例,使用这个对象,你就可以查询或者修改数据库。 

    //打开数据库的读连接(查询数据库)
    public SQLiteDatabase openReadLink() {
        if (mDB == null || !mDB.isOpen()) {
            mDB = mHelper.getReadableDatabase();
        }
        return mDB;
    }
    
    //打开数据库的写连接(可写数据库)
    public SQLiteDatabase openwriteLink() {
        if (mDB == null || !mDB.isOpen()) {
            mDB = mHelper.getWritableDatabase();
        }
        return mDB;
    }
    

    关闭数据库

    //由于在数据库关闭时,调用getWritableDatabase()和getReadableDatabase()的成本比较高,
    // 因此只要您有可能需要访问数据库,就应保持数据库连接处于打开状态。通常情况下,
    // 最好在发出调用的Activity的onDestroy()中关闭数据库。
    @Override
    protected void onDestroy() {
        userDBHelper.closeLink();
        super.onDestroy();
    }
    

    添加数据

            使用 SQLiteDatabase 对象的insert()。

    //往该表添加多条记录
    public long insert(List<UserInfoBean> infoList) {
        long result = -1;
        for (int i = 0; i < infoList.size(); i++) {
            UserInfoBean info = infoList.get(i);
            //不存在唯一性重复的记录,则插入新记录
            ContentValues cv = new ContentValues();
            cv.put(_ID, info.get_id());
            cv.put(COLUMN_NAME, info.getName());
            cv.put(COLUMN_AGE, info.getAge());
            cv.put(COLUMN_UPDATE_TIME, info.getUpdate_time());
            //执行插入记录动作,该语句返回插入记录的行号
            result = mDB.insert(TABLE_NAME, "", cv);
            if (result == -1) {//添加成功则返回行号,添加失败则返回-1
                return result;
            }
        }
        return result;
    }

            方法使用:

    List<UserInfoBean> list = new ArrayList<>();
    list.add(new UserInfoBean("10", "帅次次", 20, "09:00"));
    list.add(new UserInfoBean("12", "朱元璋", 30, "11:00"));
    list.add(new UserInfoBean("15", "赵匡胤", 40, "13:00"));
    list.add(new UserInfoBean("18", "李世民", 50, "15:00"));
    long l = userDBHelper.insert(list);
    tv_sql.setText("插入成功:" + l);

    修改数据

            使用SQLiteDatabase 对象的update()方法。

    //根据条件更新指定的表记录
    public int update(UserInfoBean info, String condition) {
        ContentValues cv = new ContentValues();
        cv.put(COLUMN_NAME, info.getName());
        cv.put(COLUMN_AGE, info.getAge());
        cv.put(COLUMN_UPDATE_TIME, info.getUpdate_time());
        //执行更新记录动作,该语句返回更新的记录数量
        return mDB.update(TABLE_NAME, cv, condition, null);
    }

            方法使用:

    UserInfoBean bean = new UserInfoBean("武媚娘", 32,"12:00");
    userDBHelper.update(bean, "_id=18");
    

    查找数据

            使用SQLiteDatabase 对象的query()方法。

    //根据指定条件查询记录,并返回结果数据列表
    public List<UserInfoBean> query() {
        List<UserInfoBean> infoList = new ArrayList<UserInfoBean>();
        //执行记录查询动作,该语句返回结果集的游标
        //SELECT语句内容作为 query()方法的参数,比如:要查询的表名,要获取的字段名,WHERE条件,
        //包含可选的位置参数,去替代WHERE条件中位置参数的值,GROUP BY条件,HAVING条件。
        //除了表名,其他参数可以是null
        Cursor cursor = mDB.query(TABLE_NAME, null, null, null, null, null, null);
        //循环取出游标指向的每条记录
        while (cursor.moveToNext()) {
            UserInfoBean info = new UserInfoBean();
            info._id = cursor.getString(0);//取出字符串
            info.name = cursor.getString(1);//取出字符串
            info.age = cursor.getInt(2);//取出整型数
            info.update_time = cursor.getString(3);//取出字符串
            infoList.add(info);
        }
        cursor.close();
        // 查询完毕,关闭数据库游标
        return infoList;
    }

            方法使用:

    userDBHelper.query();
    

    删除数据

            使用SQLiteDatabase 对象的delete()方法。

    //根据指定条件删除表记录
    public int delete(String condition) {
        //执行删除记录动作,该语句返回删除记录的数目
        return mDB.delete(TABLE_NAME, condition, null);
    }

            方法使用:

    userDBHelper.delete("_id=12");

    未创建表或者删除表后不要对表进行操作报错

            1、添加数据失败(Error)程序报错
    android.database.sqlite.SQLiteException: no such table: user_info (code 1)

            2、删改查数据(AndroidRuntime)程序崩溃
    android.database.sqlite.SQLiteException: no such table: user_info (code 1)

    各参数说明

            table:表名称

            colums:列名称数组

            selection:条件子句,相当于where

            selectionArgs:条件语句的参数数组

            groupBy:分组

            having:分组条件

            orderBy:排序类

            limit:分页查询的限制

            Cursor:返回值,相当于结果集ResultSet

    使用游标

            不管你如何执行查询,都会返回一个 Cursor,这是 Android 的 SQLite 数据库游标,使用游标,你可以:  

            通过使用 getCount() 方法得到结果集中有多少记录; 

            通过 moveToFirst(), moveToNext(), 和 isAfterLast() 方法遍历所有记录;

            通过 getColumnNames() 得到字段名;

            通过 getColumnIndex() 转换成字段号;

            通过 getString(),getInt() 等方法得到给定字段当前记录的值;

            通过 requery() 方法重新执行查询得到游标;

            通过 close() 方法释放游标资源;

    项目实例:SQLiteDemo.zip

    展开全文
  • 先画个图,了解下Android数据库操作的简单流程: 1.首先,写一个自己的数据库操作帮助类,这个类继承自Android自带的SQLiteOpenHelper. 2.在自己的DAO层借助自己的Helper写数据库操作的一些方法 3.Activity调用...
  • Android SQLite 增、删、查、改操作源码
  • 主要介绍了Android+SQLite数据库实现的生词记事本功能,结合具体实例形式分析了Android操作SQLite数据库实现生词记录功能的操作步骤与相关注意事项,需要的朋友可以参考下
  • 本文实例分析了Android编程操作嵌入式关系型SQLite数据库的方法。分享给大家供大家参考,具体如下: SQLite特点 1.Android平台中嵌入了一个关系型数据库SQLite,和其他数据库不同的是SQLite存储数据时不区分类型 ...
  • SQLite数据库android系统内嵌的数据库,小巧强大,能够满足大多数SQL语句的处理工作,而SQLite数据库仅仅是个文件而已。虽然SQLite的有点很多,但并不是如同PC端的mysql般强大,而且android系统中不允许通过JDBC...
  • Android SQLite数据库相关实例源码,代码中的每一个intent都会带一个Bundle型的extras数据。需要对position和id进行一个很好的区分。position指的是点击的这个ViewItem在当前ListView中的位置,每一个和ViewItem绑定...
  • 下面咱咱就开始在Android上使用SQLite数据库android.database.sqlite软件包中提供了在Android上使用数据库所需的API。 咱先玩玩SQLite数据库,后面咱从SQLite迁移到Room。 注意:虽然这些API功能强大,但它们的...

    ②文件存储数据

    ③SQLite数据库存储数据

    ④使用ContentProvider存储数据

    ⑤网络存储数据

    使用SQLite保存数据


    对于重复数据或结构化数据(例如联系信息),将数据保存到数据库是理想选择。下面咱咱就开始在Android上使用SQLite数据库。android.database.sqlite软件包中提供了在Android上使用数据库所需的API。

    咱先玩玩SQLite数据库,后面咱从SQLite迁移到Room。

    注意:虽然这些API功能强大,但它们的级别较低,使用起来需要花费大量时间和精力:

    • 没有针对原始SQL查询的编译时验证。随着数据图表不断发生变化,你需要手动更新受影响的SQL查询。此过程既耗时又容易出错。

    • 你需要使用大量样板代码,在SQL查询和数据对象之间进行转换。

    出于这些原因,咱强烈建议将Room持久性库用作抽象层以访问应用的SQLite数据库中的信息。

    SQL的基本语法


    SQL本质上是一种编程语言,它的学名叫作“结构化查询语言”(全称为StructuredQuery Language,简称SQL)。不过SQL语言并非通用的编程语言,它专用于数据库的访问和处理,更像是一种操作命令,所以常说SQL语句而不说SQL代码。标准的SQL语句分为3类:数据定义、数据操纵和数据控制,但不同的数据库往往有自己的实现。

    SQLite是一种小巧的嵌入式数据库,使用方便、开发简单。如同MySQL、Oracle那样,SQLite也采用SQL语句管理数据,由于它属于轻型数据库,不涉及复杂的数据控制操作,因此App开发只用到数据定义和数据操纵两类SQL。此外,SQLite的SQL语法与通用的SQL语法略有不同。

    数据库帮助器SQLiteOpenHelper


    由于SQLiteDatabase存在局限性,一不小心就会重复打开数据库,处理数据库的升级也不方便;因此Android提供了数据库帮助器SQLiteOpenHelper,帮助开发者合理使用SQLite。

    SQLiteOpenHelper的具体使用步骤如下:

    ****步骤1:****新建一个继承自SQLiteOpenHelper的数据库操作类,按提示重写onCreate和onUpgrade两个方法。其中,onCreate方法只在第一次打开数据库时执行,在此可以创建表结构;而onUpgrade方法在数据库版本升高时执行,在此可以根据新旧版本号变更表结构。

    ****步骤2:****为保证数据库安全使用,需要封装几个必要方法,包括获取单例对象.打开数据库连接、关闭数据库连接,说明如下:

    • 获取单例对象:确保在App运行过程中数据库只会打开一次,避免重复打开引起错误。

    • 打开数据库连接:SQLite有锁机制,即读锁和写锁的处理;故而数据库连接也分两种,读连接可调用getReadableDatabase方法获得,写连接可调用getWritableDatabase获得。

    • 关闭数据库连接:数据库操作完毕,调用数据库实例的close方法关闭连接。

    ****步骤3:****提供对表记录增加、删除、修改、查询的操作方法。

    继承SQLiteOpenHelper类,重写onCreate、onUpgrade、onOpen方法

    public class UserDBHelper extends SQLiteOpenHelper {

    private static final String DB_NAME = “user.db”;//数据库的名称

    private static UserDBHelper mHelper = null;//数据库帮助器的实例

    private SQLiteDatabase mDB = null;//数据库的实例

    public static final String TABLE_NAME = “user_info”;

    public static final String _ID = “_id”;

    public static final String COLUMN_NAME = “name”;

    public static final String COLUMN_AGE = “age”;

    public static final String COLUMN_UPDATE_TIME = “update_time”;

    /**

    • @param context 上下文环境(例如,一个 Activity)

    •            DB_NAME  数据库名字
      
    •            factory  null  一个可选的游标工厂(通常是 Null)
      
    • @param version 数据库模型版本的整数

    •            会调用父类 SQLiteOpenHelper的构造函数
      

    */

    public UserDBHelper(Context context, int version) {

    super(context, DB_NAME, null, version);

    }

    //利用单例模式获取SQLiteOpenHelper的唯一实例

    public static UserDBHelper getInstance(Context context, int version) {

    if (version > 0 && mHelper == null) {

    mHelper = new UserDBHelper(context, version);

    }

    return mHelper;

    }

    //创建数据库表,执行建表语句

    @Override

    public void onCreate(SQLiteDatabase db) {

    }

    /**

    • 当数据库需要修改的时候(两个数据库版本不同),Android系统会主动的调用这个方法。

    • 一般我们在这个方法里边删除数据库表,并建立新的数据库表.

    */

    @Override

    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    @Override

    public void onOpen(SQLiteDatabase db) {

    //每次成功打开数据库后首先被执行

    super.onOpen(db);

    }

    }

    创建表

    表格的创建动作由create命令完成,格式为“CREATE TABLE IFNOT EXISTS表格名称(以逗号分隔的各字段定义);”。以用户信息表为例,它的建表语句如下所示:

    //创建数据库表,执行建表语句

    @Override

    public void onCreate(SQLiteDatabase db) {

    Log.e(getClass().getName(), “onCreate”);

    //创建表语句

    String SQL_CREATE_ENTRIES = "CREATE TABLE IF NOT EXISTS "

    • TABLE_NAME + “(”

    • _ID + " INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"

    • COLUMN_NAME+" VARCHAR NOT NULL,"

    • COLUMN_AGE+" INTEGER NOT NULL,"

    • COLUMN_UPDATE_TIME+" VARCHAR NOT NULL" + "); ";

    //执行完整的sQL语句

    db.execSQL(SQL_CREATE_ENTRIES);

    }

    上面的SQL语法与其他数据库的SQL语法有所出入,相关的注意点说明见下:

    ①SQL语句不区分大小写,无论是create与table这类关键词,还是表格名称、字段名称,都不区分大小写。唯一区分大小写的是被单引号括起来的字符串值。

    ②为避免重复建表,应加上IF NOT EXISTS关键词,例如CREATE TABLE

    《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

    【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

    IFNOT EXISTS表格名称…

    ③SQLite支持整型INTEGER、长整型LONG、字符串VARCHAR、浮点数FLOAT,但不支持布尔类型。布尔类型的数据要使用整型保存,如果直接保存布尔数据,在入库时sQLite会自动将它转为0或1,其中0表示false,1表示true。

    ④建表时需要唯一标识字段,它的字段名为_id。创建新表都要加上该字段定义,例如_id lNTEGER PRIMARY KEY AUTOINCREMENT NOT NULL。

    删除表

    表格的删除动作由drop命令完成,格式为“DROP TABLE IFEXISTS表格名称;”。下面是删除用户信息表的SQL语句例子:

    //删除表

    public void deleteTable(SQLiteDatabase db) {

    String SQL_DELETE_ENTRIES = "DROP TABLE IF EXISTS " + TABLE_NAME;

    db.execSQL(SQL_DELETE_ENTRIES);

    }

    打开数据库表

    下面这段代码会返回一个 SQLiteDatabase 类的实例,使用这个对象,你就可以查询或者修改数据库。

    //打开数据库的读连接(查询数据库)

    public SQLiteDatabase openReadLink() {

    if (mDB == null || !mDB.isOpen()) {

    mDB = mHelper.getReadableDatabase();

    }

    return mDB;

    }

    //打开数据库的写连接(可写数据库)

    public SQLiteDatabase openwriteLink() {

    if (mDB == null || !mDB.isOpen()) {

    mDB = mHelper.getWritableDatabase();

    }

    return mDB;

    }

    关闭数据库

    //由于在数据库关闭时,调用getWritableDatabase()和getReadableDatabase()的成本比较高,

    // 因此只要您有可能需要访问数据库,就应保持数据库连接处于打开状态。通常情况下,

    // 最好在发出调用的Activity的onDestroy()中关闭数据库。

    @Override

    protected void onDestroy() {

    userDBHelper.closeLink();

    super.onDestroy();

    }

    添加数据

    使用 SQLiteDatabase 对象的insert()。

    //往该表添加多条记录

    public long insert(List infoList) {

    long result = -1;

    for (int i = 0; i < infoList.size(); i++) {

    UserInfoBean info = infoList.get(i);

    //不存在唯一性重复的记录,则插入新记录

    ContentValues cv = new ContentValues();

    cv.put(_ID, info.get_id());

    cv.put(COLUMN_NAME, info.getName());

    cv.put(COLUMN_AGE, info.getAge());

    cv.put(COLUMN_UPDATE_TIME, info.getUpdate_time());

    //执行插入记录动作,该语句返回插入记录的行号

    result = mDB.insert(TABLE_NAME, “”, cv);

    if (result == -1) {//添加成功则返回行号,添加失败则返回-1

    return result;

    }

    }

    return result;

    }

    方法使用:

    List list = new ArrayList<>();

    list.add(new UserInfoBean(“10”, “帅次次”, 20, “09:00”));

    list.add(new UserInfoBean(“12”, “朱元璋”, 30, “11:00”));

    list.add(new UserInfoBean(“15”, “赵匡胤”, 40, “13:00”));

    list.add(new UserInfoBean(“18”, “李世民”, 50, “15:00”));

    long l = userDBHelper.insert(list);

    tv_sql.setText(“插入成功:” + l);

    修改数据

    使用SQLiteDatabase 对象的update()方法。

    //根据条件更新指定的表记录

    public int update(UserInfoBean info, String condition) {

    ContentValues cv = new ContentValues();

    cv.put(COLUMN_NAME, info.getName());

    cv.put(COLUMN_AGE, info.getAge());

    cv.put(COLUMN_UPDATE_TIME, info.getUpdate_time());

    //执行更新记录动作,该语句返回更新的记录数量

    return mDB.update(TABLE_NAME, cv, condition, null);

    }

    方法使用:

    UserInfoBean bean = new UserInfoBean(“武媚娘”, 32,“12:00”);

    userDBHelper.update(bean, “_id=18”);

    展开全文
  • Android SQLite数据库示例教程

    千次阅读 2020-07-09 12:54:52
    Welcome to Android SQLite Example Tutorial. Android SQLite is the mostly preferred way to store data for android applications. For many applications, SQLite is the apps backbone whether it’s used ...

    Welcome to Android SQLite Example Tutorial. Android SQLite is the mostly preferred way to store data for android applications. For many applications, SQLite is the apps backbone whether it’s used directly or via some third-party wrapper. Below is the final app we will create today using Android SQLite database.

    欢迎使用Android SQLite示例教程。 Android SQLite是为Android应用程序存储数据的首选方法。 对于许多应用程序而言,无论直接使用SQLite还是通过第三方包装器使用,SQLite都是应用程序的骨干。 以下是我们今天将使用Android SQLite数据库创建的最终应用程序。

    Android SQLite (Android SQLite)

    Android SQLite is a very lightweight database which comes with Android OS. Android SQLite combines a clean SQL interface with a very small memory footprint and decent speed. For Android, SQLite is “baked into” the Android runtime, so every Android application can create its own SQLite databases.

    Android SQLite是Android OS附带的非常轻量级的数据库。 Android SQLite结合了干净SQL界面,很小的内存占用和不错的速度。 对于Android,SQLite被“嵌入”到Android运行时中,因此每个Android应用程序都可以创建自己SQLite数据库。

    Android SQLite native API is not JDBC, as JDBC might be too much overhead for a memory-limited smartphone. Once a database is created successfully its located in data/data//databases/ accessible from Android Device Monitor.

    Android SQLite本机API不是JDBC,因为对于内存受限的智能手机而言,JDBC可能会产生过多开销。 成功创建数据库后,其位于data / data // databases /中,可通过Android Device Monitor访问。

    SQLite is a typical relational database, containing tables (which consists of rows and columns), indexes etc. We can create our own tables to hold the data accordingly. This structure is referred to as a schema.

    SQLite是一个典型的关系数据库 ,包含表(由行和列组成),索引等。我们可以创建自己的表来相应地保存数据。 此结构称为架构

    Android SQLite SQLiteOpenHelper (Android SQLite SQLiteOpenHelper)

    Android has features available to handle changing database schemas, which mostly depend on using the SQLiteOpenHelper class.

    Android具有可用于处理数据库模式更改的功能,这些功能主要取决于使用SQLiteOpenHelper类。

    SQLiteOpenHelper is designed to get rid of two very common problems.

    SQLiteOpenHelper旨在摆脱两个非常常见的问题。

    1. When the application runs the first time – At this point, we do not yet have a database. So we will have to create the tables, indexes, starter data, and so on.

      当应用程序首次运行时–此时,我们还没有数据库。 因此,我们将不得不创建表,索引,启动器数据等。
    2. When the application is upgraded to a newer schema – Our database will still be on the old schema from the older edition of the app. We will have option to alter the database schema to match the needs of the rest of the app.

      当应用程序升级到较新的架构时–我们的数据库仍将位于较旧版本的应用程序的旧架构上。 我们将具有更改数据库架构的选项,以匹配应用程序其余部分的需求。

    SQLiteOpenHelper wraps up these logic to create and upgrade a database as per our specifications. For that we’ll need to create a custom subclass of SQLiteOpenHelper implementing at least the following three methods.

    SQLiteOpenHelper了这些逻辑,以根据我们的规范创建和升级数据库。 为此,我们需要创建一个SQLiteOpenHelper的自定义子类,至少实现以下三种方法。

    1. Constructor : This takes the Context (e.g., an Activity), the name of the database, an optional cursor factory (we’ll discuss this later), and an integer representing the version of the database schema you are using (typically starting from 1 and increment later).
      public DatabaseHelper(Context context) {
              super(context, DB_NAME, null, DB_VERSION);
          }

      构造函数 :这需要Context(例如Activity),数据库名称,可选的游标工厂(我们将在后面讨论)和代表您所使用的数据库模式版本的整数(通常从1开始)然后再增加)。
    2. onCreate(SQLiteDatabase db) : It’s called when there is no database and the app needs one. It passes us a SQLiteDatabase object, pointing to a newly-created database, that we can populate with tables and initial data.

      onCreate(SQLiteDatabase db) :在没有数据库且应用程序需要一个数据库时调用。 它向我们传递了一个SQLiteDatabase对象,该对象指向一个新创建的数据库,我们可以在其中填充表和初始数据。
    3. onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) : It’s called when the schema version we need does not match the schema version of the database, It passes us a SQLiteDatabase object and the old and new version numbers. Hence we can figure out the best way to convert the database from the old schema to the new one.

      onUpgrade(SQLiteDatabase db,int oldVersion,int newVersion) :当我们需要的架构版本与数据库的架构版本不匹配时,将调用此方法,它会向我们传递一个SQLiteDatabase对象以及新旧版本号。 因此,我们可以找出将数据库从旧模式转换为新模式的最佳方法。

    We define a DBManager class to perform all database CRUD(Create, Read, Update and Delete) operations.

    我们定义一个DBManager类来执行所有数据库CRUD(创建,读取,更新和删除)操作。

    打开和关闭Android SQLite数据库连接 (Opening and Closing Android SQLite Database Connection)

    Before performing any database operations like insert, update, delete records in a table, first open the database connection by calling getWritableDatabase() method as shown below:

    在执行任何数据库操作(如插入,更新,删除表中的记录)之前,首先通过调用getWritableDatabase()方法打开数据库连接,如下所示:

    public DBManager open() throws SQLException {
            dbHelper = new DatabaseHelper(context);
            database = dbHelper.getWritableDatabase();
            return this;
        }

    The dbHelper is an instance of the subclass of SQLiteOpenHelper.

    dbHelperSQLiteOpenHelper子类的SQLiteOpenHelper

    To close a database connection the following method is invoked.

    要关闭数据库连接,将调用以下方法。

    public void close() {
            dbHelper.close();
        }

    将新记录插入Android SQLite数据库表 (Inserting new Record into Android SQLite database table)

    The following code snippet shows how to insert a new record in the android SQLite database.

    以下代码段显示了如何在android SQLite数据库中插入新记录。

    public void insert(String name, String desc) {
            ContentValues contentValue = new ContentValues();
            contentValue.put(DatabaseHelper.SUBJECT, name);
            contentValue.put(DatabaseHelper.DESC, desc);
            database.insert(DatabaseHelper.TABLE_NAME, null, contentValue);
        }

    Content Values creates an empty set of values using the given initial size. We’ll discuss the other instance values when we jump into the coding part.

    内容值会使用给定的初始大小创建一组空值。 当我们跳到编码部分时,我们将讨论其他实例值。

    更新Android SQLite数据库表中的记录 (Updating Record in Android SQLite database table)

    The following snippet shows how to update a single record.

    以下代码段显示了如何更新单个记录。

    public int update(long _id, String name, String desc) {
            ContentValues contentValues = new ContentValues();
            contentValues.put(DatabaseHelper.SUBJECT, name);
            contentValues.put(DatabaseHelper.DESC, desc);
            int i = database.update(DatabaseHelper.TABLE_NAME, contentValues, DatabaseHelper._ID + " = " + _id, null);
            return i;
        }

    Android SQLite –删除记录 (Android SQLite – Deleting a Record)

    We just need to pass the id of the record to be deleted as shown below.

    我们只需要传递要删除的记录的ID,如下所示。

    public void delete(long _id) {
            database.delete(DatabaseHelper.TABLE_NAME, DatabaseHelper._ID + "=" + _id, null);
        }

    Android SQLite游标 (Android SQLite Cursor)

    A Cursor represents the entire result set of the query. Once the query is fetched a call to cursor.moveToFirst() is made. Calling moveToFirst() does two things:

    游标代表查询的整个结果集。 提取查询后, 将对cursor.moveToFirst()进行调用。 调用moveToFirst()有两件事:

    • It allows us to test whether the query returned an empty set (by testing the return value)

      它允许我们测试查询是否返回空集(通过测试返回值)
    • It moves the cursor to the first result (when the set is not empty)

      它将光标移动到第一个结果(当集合不为空时)

    The following code is used to fetch all records:

    以下代码用于获取所有记录:

    public Cursor fetch() {
            String[] columns = new String[] { DatabaseHelper._ID, DatabaseHelper.SUBJECT, DatabaseHelper.DESC };
            Cursor cursor = database.query(DatabaseHelper.TABLE_NAME, columns, null, null, null, null, null);
            if (cursor != null) {
                cursor.moveToFirst();
            }
            return cursor;
        }

    Another way to use a Cursor is to wrap it in a CursorAdapter. Just as ArrayAdapter adapts arrays, CursorAdapter adapts Cursor objects, making their data available to an AdapterView like a ListView.

    使用Cursor的另一种方法是将其包装在CursorAdapter 。 就像ArrayAdapter适应数组一样, CursorAdapter适应Cursor对象,使它们的数据像ListView一样可用于AdapterView

    Let’s jump to our project that uses SQLite to store some meaningful data.

    让我们跳到使用SQLite存储一些有意义的数据的项目。

    Android SQLite示例项目结构 (Android SQLite Example Project Structure)

    In this application we wish to create records that store Country names and their respective currencies in the form of a ListView. We cover all the features discusses above.

    在此应用程序中,我们希望创建以ListView形式存储国家名称及其各自货币的记录。 我们涵盖了上面讨论的所有功能。

    Android SQLite项目代码 (Android SQLite Project Code)

    The application consists of 5 classes. We begin with defining with DatabaseHelper, which is a subclass of SQLiteOpenHelper as follows:

    该应用程序包含5个类。 我们首先使用DatabaseHelper进行定义,它是SQLiteOpenHelper的子类,如下所示:

    DatabaseHelper.java

    DatabaseHelper.java

    package com.journaldev.sqlite;
    
    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;
    import android.database.sqlite.SQLiteOpenHelper;
    
    public class DatabaseHelper extends SQLiteOpenHelper {
    
        // Table Name
        public static final String TABLE_NAME = "COUNTRIES";
    
        // Table columns
        public static final String _ID = "_id";
        public static final String SUBJECT = "subject";
        public static final String DESC = "description";
    
        // Database Information
        static final String DB_NAME = "JOURNALDEV_COUNTRIES.DB";
    
        // database version
        static final int DB_VERSION = 1;
    
        // Creating table query
        private static final String CREATE_TABLE = "create table " + TABLE_NAME + "(" + _ID
                + " INTEGER PRIMARY KEY AUTOINCREMENT, " + SUBJECT + " TEXT NOT NULL, " + DESC + " TEXT);";
    
        public DatabaseHelper(Context context) {
            super(context, DB_NAME, null, DB_VERSION);
        }
    
        @Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL(CREATE_TABLE);
        }
    
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
            onCreate(db);
        }
    }

    As discussed above we have overridden the onCreate() and onUpgrade() methods besides the constructor. We’ve assigned the names to the database and the table as JOURNALDEV_COUNTRIES.DB and COUNTRIES respectively. The index column is auto incremented whenever a new row is inserted. The column names for country and currency are “subject” and “description”.

    如上所述,除了构造函数之外,我们还重写了onCreate()onUpgrade()方法。 我们已将名称分别分配给数据库和表,分别为JournalDEV_COUNTRIES.DB和COUNTRIES。 每当插入新行时,索引列都会自动递增。 国家和货币的列名称为“主题”和“描述”。

    The DBManager classes is where the DatabaseHelper is initialized and the CRUD Operations are defined. Below is the code for this class:

    在DBManager类中,可以初始化DatabaseHelper并定义CRUD操作。 下面是该类的代码:

    DBManager.java

    DBManager.java

    package com.journaldev.sqlite;
    
    
    import android.content.ContentValues;
    import android.content.Context;
    import android.database.Cursor;
    import android.database.SQLException;
    import android.database.sqlite.SQLiteDatabase;
    
    public class DBManager {
    
        private DatabaseHelper dbHelper;
    
        private Context context;
    
        private SQLiteDatabase database;
    
        public DBManager(Context c) {
            context = c;
        }
    
        public DBManager open() throws SQLException {
            dbHelper = new DatabaseHelper(context);
            database = dbHelper.getWritableDatabase();
            return this;
        }
    
        public void close() {
            dbHelper.close();
        }
    
        public void insert(String name, String desc) {
            ContentValues contentValue = new ContentValues();
            contentValue.put(DatabaseHelper.SUBJECT, name);
            contentValue.put(DatabaseHelper.DESC, desc);
            database.insert(DatabaseHelper.TABLE_NAME, null, contentValue);
        }
    
        public Cursor fetch() {
            String[] columns = new String[] { DatabaseHelper._ID, DatabaseHelper.SUBJECT, DatabaseHelper.DESC };
            Cursor cursor = database.query(DatabaseHelper.TABLE_NAME, columns, null, null, null, null, null);
            if (cursor != null) {
                cursor.moveToFirst();
            }
            return cursor;
        }
    
        public int update(long _id, String name, String desc) {
            ContentValues contentValues = new ContentValues();
            contentValues.put(DatabaseHelper.SUBJECT, name);
            contentValues.put(DatabaseHelper.DESC, desc);
            int i = database.update(DatabaseHelper.TABLE_NAME, contentValues, DatabaseHelper._ID + " = " + _id, null);
            return i;
        }
    
        public void delete(long _id) {
            database.delete(DatabaseHelper.TABLE_NAME, DatabaseHelper._ID + "=" + _id, null);
        }
    
    }

    The CountryListActivity.java class is the activity which is launched when the application starts. Below is layout defined for it:

    CountryListActivity.java类是在应用程序启动时启动的活动。 下面是为其定义的布局:

    fragment_emp_list.xml

    fragment_emp_list.xml

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" >
    
        <ListView
            android:id="@+id/list_view"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:dividerHeight="1dp"
            android:padding="10dp" >
        </ListView>
    
        <TextView
            android:id="@+id/empty"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:text="@string/empty_list_text" />
    
    </RelativeLayout>

    Here a ListView component is defined to included the records stored in the database. Initially the ListView would be empty hence a TextView is used to display the same.

    在此,将ListView组件定义为包括存储在数据库中的记录。 最初,ListView将为空,因此使用TextView来显示它。

    CountryListActivity.java

    CountryListActivity.java

    package com.journaldev.sqlite;
    
    import android.content.Intent;
    import android.database.Cursor;
    import android.os.Bundle;
    import android.support.v4.widget.SimpleCursorAdapter;
    import android.support.v7.app.ActionBarActivity;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.View;
    import android.widget.AdapterView;
    import android.widget.ListView;
    import android.widget.TextView;
    
    public class CountryListActivity extends ActionBarActivity {
    
        private DBManager dbManager;
    
        private ListView listView;
    
        private SimpleCursorAdapter adapter;
    
        final String[] from = new String[] { DatabaseHelper._ID,
                DatabaseHelper.SUBJECT, DatabaseHelper.DESC };
    
        final int[] to = new int[] { R.id.id, R.id.title, R.id.desc };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            setContentView(R.layout.fragment_emp_list);
    
            dbManager = new DBManager(this);
            dbManager.open();
            Cursor cursor = dbManager.fetch();
    
            listView = (ListView) findViewById(R.id.list_view);
            listView.setEmptyView(findViewById(R.id.empty));
    
            adapter = new SimpleCursorAdapter(this, R.layout.activity_view_record, cursor, from, to, 0);
            adapter.notifyDataSetChanged();
    
            listView.setAdapter(adapter);
    
            // OnCLickListiner For List Items
            listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> parent, View view, int position, long viewId) {
                    TextView idTextView = (TextView) view.findViewById(R.id.id);
                    TextView titleTextView = (TextView) view.findViewById(R.id.title);
                    TextView descTextView = (TextView) view.findViewById(R.id.desc);
    
                    String id = idTextView.getText().toString();
                    String title = titleTextView.getText().toString();
                    String desc = descTextView.getText().toString();
    
                    Intent modify_intent = new Intent(getApplicationContext(), ModifyCountryActivity.class);
                    modify_intent.putExtra("title", title);
                    modify_intent.putExtra("desc", desc);
                    modify_intent.putExtra("id", id);
    
                    startActivity(modify_intent);
                }
            });
        }
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    
        @Override
        public boolean onOptionsItemSelected(MenuItem item) {
    
            int id = item.getItemId();
            if (id == R.id.add_record) {
    
                Intent add_mem = new Intent(this, AddCountryActivity.class);
                startActivity(add_mem);
    
            }
            return super.onOptionsItemSelected(item);
        }
    
    }

    In this activity the DBManager object is invoked to perform the CRUD Operations.

    在此活动中,将调用DBManager对象以执行CRUD操作。

    A SimpleCursorAdapter is defined to add elements to the list from the query results that are returned in an Cursor Object.
    On list item click an intent is performed to open the ModifyCountryActivity class.

    定义了一个SimpleCursorAdapter,以将游标对象中返回的查询结果中的元素添加到列表中。
    在列表项上单击一个意图,以打开ModifyCountryActivity类。

    The menu contains an item to add a new record from the ActionBar. Here again an intent is performed to open the AddCountryActivity class. Below is menu.xml code.

    该菜单包含一个用于从ActionBar添加新记录的项目。 在这里再次执行一个意图来打开AddCountryActivity类。 以下是menu.xml代码。

    menu.xml

    menu.xml

    <menu xmlns:android="https://schemas.android.com/apk/res/android"
        xmlns:app="https://schemas.android.com/apk/res-auto"
        xmlns:tools="https://schemas.android.com/tools"
        tools:context="com.example.sqlitesample.MainActivity" >
    
        <item
            android:id="@+id/add_record"
            android:icon="@android:drawable/ic_menu_add"
            android:orderInCategory="100"
            android:title="@string/add_record"
            app:showAsAction="always"/>
    
    </menu>

    The xml layout and code of AddCountryActivity.java file are defined below:

    AddCountryActivity.java文件的xml布局和代码定义如下:

    activity_add_record.xml

    activity_add_record.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="20dp" >
    
        <EditText
            android:id="@+id/subject_edittext"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10"
            android:hint="@string/enter_title" >
    
            <requestFocus />
        </EditText>
    
        <EditText
            android:id="@+id/description_edittext"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10"
            android:hint="@string/enter_desc"
            android:inputType="textMultiLine"
            android:minLines="5" >
        </EditText>
    
        <Button
            android:id="@+id/add_record"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:text="@string/add_record" />
    
    </LinearLayout>

    Two EditText components that take the inputs for country and currency along with a button to add the values to the database and display it in the ListView are defined.

    定义了两个EditText组件,这些组件接受国家和货币的输入以及一个将值添加到数据库并在ListView中显示的按钮。

    AddCountryActivity.java

    AddCountryActivity.java

    package com.journaldev.sqlite;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.EditText;
    
    public class AddCountryActivity extends Activity implements OnClickListener {
    
        private Button addTodoBtn;
        private EditText subjectEditText;
        private EditText descEditText;
    
        private DBManager dbManager;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            setTitle("Add Record");
    
            setContentView(R.layout.activity_add_record);
    
            subjectEditText = (EditText) findViewById(R.id.subject_edittext);
            descEditText = (EditText) findViewById(R.id.description_edittext);
    
            addTodoBtn = (Button) findViewById(R.id.add_record);
    
            dbManager = new DBManager(this);
            dbManager.open();
            addTodoBtn.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.add_record:
    
                    final String name = subjectEditText.getText().toString();
                    final String desc = descEditText.getText().toString();
    
                    dbManager.insert(name, desc);
    
                    Intent main = new Intent(AddCountryActivity.this, CountryListActivity.class)
                            .setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    
                    startActivity(main);
                    break;
            }
        }
    
    }

    The CRUD operation performed here is adding a new record to the database.

    此处执行的CRUD操作是将新记录添加到数据库中。

    The xml layout and code of ModifyCountryActivity.java file are defined below:

    下面定义ModifyCountryActivity.java文件的xml布局和代码:

    activity_modify_record.xml

    activity_modify_record.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="10dp" >
    
        <EditText
            android:id="@+id/subject_edittext"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginBottom="10dp"
            android:ems="10"
            android:hint="@string/enter_title" />
    
        <EditText
            android:id="@+id/description_edittext"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10"
            android:hint="@string/enter_desc"
            android:inputType="textMultiLine"
            android:minLines="5" >
        </EditText>
    
    
        <LinearLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:weightSum="2"
            android:gravity="center_horizontal"
            android:orientation="horizontal" >
    
            <Button
                android:id="@+id/btn_update"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/btn_update" />
    
            <Button
                android:id="@+id/btn_delete"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/btn_delete" />
        </LinearLayout>
    
    </LinearLayout>

    It’s similar to the previous layout except that modify and delete buttons are added.

    除了添加了“修改”和“删除”按钮之外,它与以前的布局相似。

    ModifyCountryActivity.java

    ModifyCountryActivity.java

    package com.journaldev.sqlite;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.EditText;
    
    public class ModifyCountryActivity extends Activity implements OnClickListener {
    
        private EditText titleText;
        private Button updateBtn, deleteBtn;
        private EditText descText;
    
        private long _id;
    
        private DBManager dbManager;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            setTitle("Modify Record");
    
            setContentView(R.layout.activity_modify_record);
    
            dbManager = new DBManager(this);
            dbManager.open();
    
            titleText = (EditText) findViewById(R.id.subject_edittext);
            descText = (EditText) findViewById(R.id.description_edittext);
    
            updateBtn = (Button) findViewById(R.id.btn_update);
            deleteBtn = (Button) findViewById(R.id.btn_delete);
    
            Intent intent = getIntent();
            String id = intent.getStringExtra("id");
            String name = intent.getStringExtra("title");
            String desc = intent.getStringExtra("desc");
    
            _id = Long.parseLong(id);
    
            titleText.setText(name);
            descText.setText(desc);
    
            updateBtn.setOnClickListener(this);
            deleteBtn.setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btn_update:
                    String title = titleText.getText().toString();
                    String desc = descText.getText().toString();
    
                    dbManager.update(_id, title, desc);
                    this.returnHome();
                    break;
    
                case R.id.btn_delete:
                    dbManager.delete(_id);
                    this.returnHome();
                    break;
            }
        }
    
        public void returnHome() {
            Intent home_intent = new Intent(getApplicationContext(), CountryListActivity.class)
                    .setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            startActivity(home_intent);
        }
    }

    The CRUD operations performed here are updating and deleting a record.

    此处执行的CRUD操作是更新和删除记录。

    The below images are the screenshots of the final output of our project.

    下图是我们项目最终输出的屏幕截图。

    The first image is the output seen when the application is launched for the first time.

    android sqlite

    第一个图像是首次启动应用程序时看到的输出。

    The second image is the result of clicking the menu option from the ActionBar to add a new record as shown below.

    android sqlite example create

    第二张图片是单击ActionBar中的菜单选项以添加新记录的结果,如下所示。

    The third image shows an output when 3 records are added :

    android sqlite example crud

    第三张图片显示了添加3条记录时的输出:

    The fourth image shows the output when any list item is clicked to modify or delete a record :

    android sqlite example update

    第四个图像显示了单击任何列表项以修改或删除记录时的输出:

    The final image is the output when a record is deleted. In this example we delete the first record :

    android sqlite example delete

    最终图像是删除记录时的输出。 在此示例中,我们删除第一条记录:

    打开Android SQLite数据库文件 (Opening the Android SQLite Database file)

    As we’ve discussed earlier in this tutorial, the database file is stored in the internal storage that is accessible from the Android Device Monitor as visible in the pic below.

    正如我们在本教程前面所讨论的那样,数据库文件存储在内部存储中,可从Android设备监视器访问该内部存储,如下图所示。

    To view this database we need to pull this file from the device to our desktop. This is done by clicking the menu option in the top right as seen in the image below :

    android sqlite pull file from device

    要查看此数据库,我们需要将该文件从设备中拉到桌面。 通过单击右上角的菜单选项来完成此操作,如下图所示:

    To open this file download the SQLiteBrowser from this link.

    要打开这个文件下载从SQLiteBrowser 这个链接。

    The snippets below show the schema and tables in the browser.

    下面的片段显示了浏览器中的架构和表。

    To view the table go to the Browse Data tab on top. The following image is seen:

    要查看该表,请转到顶部的“浏览数据”选项卡。 可以看到以下图像:

    This brings an end to Android SQLite tutorial. The final Android SQLite Project is downloadable from the below link.

    这结束了Android SQLite教程。 最终的Android SQLite项目可从下面的链接下载。

    翻译自: https://www.journaldev.com/9438/android-sqlite-database-example-tutorial

    展开全文
  • NULL 博文链接:https://yzxqml.iteye.com/blog/1717135
  • 一个简单的基于AndroidSqlite数据库的操作封装,它有如下的好处:便捷地创建表和增添表字...实例:SqliteLookup(Android内查看Sqlite数据库利器): https://github.com/YeDaxia/SqliteLookup 标签:SQLiteUtils
  • 主要介绍了Android操作存放在assets文件夹下SQLite数据库的方法,实例分析了Android操作SQLite数据库的相关技巧,需要的朋友可以参考下
  • 下面通过一个完整的实例来展示如何进行数据库操作。由于实例中使用的方法在上一篇博文中都已经讲述过,因此不再对具体的方法进行分析,主要通过完整的实例让读者有一个宏观的认知实例将通过创建 100条模拟数据,用...
  • 基于AndroidSQLite数据库操作

    千次阅读 2022-04-15 17:08:48
    基于AndroidSQLite数据库操作功能介绍一、创库二、基本操作1.实例化sql对象2.添加数据2.查询数据3.修改数据4.删除数据 功能介绍 本文的增删改查方法都Android自带的SQLiteOpenHelper,虽然直接用sql语句来映射...
  • 课程规划师 带有 sqlite 数据库实现的示例 Android 应用程序
  • 数据库操作类:SQLiteDatabase在Android系统之中,一个android.database,sqlite.SQLiteDatebase类的实例都代表了一个SQLite数据库的操作,通过SQLiteDatabase类可以执行SQL语句,可以完成对数据表的增加,修改,删除...
  • import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; public class Database extends SQLiteOpenHelper { private static String DatabaseName = "Entries.db"; ...
  • Android中使用SQLite数据库 目录标题Android中使用SQLite数据库1 SQLite和MySQL、Oracle等的区别2 SQLite在Android Studio中的用法2.1 第一种:利用工具类自动连接数据创建表对表的增删改查的四种方法:1 增加数据2 ...
  • 本文实例讲述了C#操作SQLite数据库之读写数据库的方法。分享给大家供大家参考,具体如下: 这里演示读写数据库并在窗体(Form)中显示其数据,其方式为: 读: Database(SQLite) -> DataAdapter -> DataSet -> ...
  • Android SQLite数据库基本操作 android SQLite是Android内置的小型数据库,支持标准的SQL语法,还遵循数据库的ACID事务。 SQLite与单独的大型数据库相比更加简单,不需要设置用户和密码。 与SharePerences相比 ...
  • 轻量的 Android SQLite 数据库工具集合, 适合用SQLite做一些数据存储的项目. 根据Java实体自动生成数据库表. 不需要书写任何SQL语句即可实现对数据库的 创表 增 删 查 改 分页 操作. 所有的操作方法都是静态的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,834
精华内容 9,533
热门标签
关键字:

安卓sqlite数据库实例