Android开辟进修之SQLite数据存取浅析

转载地址：http://www.byywee.com/page/M0/S941/941492.html

一.SQLite的介绍

1.SQLite简介

 SQLite是一款轻型的数据库，是遵守ACID的接洽关系式数据库经管体系，它的设计目标是嵌入 式的，并且今朝已经在很多嵌入式产品中应用了它，它占用资料很是的低，在嵌入式设备中，可能只须要几百K的内存就够了。它可以或许支撑 Windows/Linux/Unix等等主流的操纵体系，同时可以或许跟很多法度说话相连络，比如Tcl、PHP、Java、C++、.Net等，还有ODBC接口，同样比起 Mysql、PostgreSQL这两款开源世界有名的数据库经管体系来讲，它的处理惩罚速度比他们都快。

2.SQLite的特点：

轻量级

SQLite和C/S模式的数据库软件不合，它是过程内的数据库引擎，是以不存在数据库的客户端和办事器。应用SQLite一般只须要带上它的一个动态 库，就可以享受它的全部功能。并且那个动态库的尺寸也挺小，以版本3.6.11为例，Windows下487KB、Linux下347KB。

不须要"安装"

SQLite的核心引擎本身不依附第三方的软件，应用它也不须要"安装"。有点类似那种绿色软件。

单一文件  

数据库中所有的信息（比如表、视图等）都包含在一个文件内。这个文件可以复制到其它目次或其它机械上。

跨平台/可移植性

除了主流操纵体系 windows，linux之后，SQLite还支撑其它一些不常用的操纵体系。

弱类型的字段

同一列中的数据可所以不合类型

开源

这个信赖大师都懂的！

 3.SQLite数据类型

一般数据采取的固定的静态数据类型，而SQLite采取的是动态数据类型，会按照存入值主动断定。SQLite具有以下五种常用的数据类型：

NULL: 这个值为空值

VARCHAR（n）：长度不固定且其最大长度为 n 的字串，n不克不及跨越 4000。

CHAR（n）：长度固定为n的字串，n不克不及跨越 254。

INTEGER: 值被标识为整数，根据值的大小可以依次被存储为1，2，3，4，5，6，7，8.

REAL: 所有值都是浮动的数值，被存储为8字节的IEEE浮动标识表记标帜序号.

TEXT: 值为文本字符串，应用数据库编码存储（TUTF-8， UTF-16BE or UTF-16-LE）.

BLOB: 值是BLOB数据块，以输入的数据格局进行存储。如何输入就如何存储，不改  变格局。

DATA ：包含了 年份、月份、日期。

TIME： 包含了 小时、分钟、秒。

信赖学过数据库的童鞋对这些数据类型都不陌生的!!!!!!!!!!

二.SQLiteDatabase的介绍

Android供给了创建和是用SQLite数据库的API。SQLiteDatabase代表一个数据库对象，供给了操纵数据库的一些办法。在Android的SDK目次下有sqlite3对象，我们可以哄骗它创建数据库、创建表和履行一些SQL语句。下面是SQLiteDatabase的常用办法。 

SQLiteDatabase的常用办法 

办法名称	办法描述
openOrCreateDatabase（String path，SQLiteDatabase.CursorFactory factory）	打开或创建数据库
（String table，String nullColumnHack，ContentValues values）	添加一笔记录
（String table，String whereClause，String[] whereArgs）	删除一笔记录
query（String table，String[] columns，String ion，String[] ionArgs，String groupBy，String having，String orderBy）	查询一笔记录
（String table，ContentValues values，String whereClause，String[] whereArgs）	批改记录
execSQL（String sql）	履行一条SQL语句
close（）	封闭数据库

1、打开或者创建数据库

在Android 中以应用SQLiteDatabase的静态办法openOrCreateDatabase（String path，SQLiteDatabae.CursorFactory factory）打开或者创建一个数据库。它会主动去检测是否存在这个数据库，若是存在则打开，不存在则创建一个数据库；创建成功则返回一个SQLiteDatabase对象，不然抛出异常FileNotFoundException。

下面是创建名为“stu.db”数据库的代码：

1. db=SQLiteDatabase.openOrCreateDatabase（"/data/data/com.lingdududu.db/databases/stu.db"，null）; 
   

2、创建表

创建一张表很简单。起首，编写创建表的SQL语句，然后，调用SQLiteDatabase的execSQL（）办法来履行SQL语句便可以创建一张表了。

下面的代码创建了一张用户表，属性列为：_id（主键并且主动增长）、sname（学生姓名）、snumber（学号）

1. private void createTable（SQLiteDatabase db）{  
   
2. 
   
3.       //创建表SQL语句  
   
4.       String stu_table="create table usertable（_id integer primary key autoincrement，sname text，snumber text）";  
   
5. 
   
6.       //履行SQL语句   
   
7.       db.execSQL（stu_table）;  
   
8. }  
   

3、插入数据

插入数占领两种办法：

①SQLiteDatabase的（String table，String nullColumnHack，ContentValues values）办法，参数一是表名称，参数二是空列的默认值，参数三是ContentValues类型的一个封装了列名称和列值的Map；

②编写插入数据的SQL语句，直接调用SQLiteDatabase的execSQL（）办法来履行

第一种办法的代码：

1. private void （SQLiteDatabase db） {  
   
2. 
   
3.     //实例化常量值  
   
4.     ContentValues cValue = new ContentValues（）;  
   
5. 
   
6.     //添加用户名  
   
7.     cValue.put（"sname"，"xiaoming"）;  
   
8. 
   
9.     //添加暗码  
   
10.     cValue.put（"snumber"，"01005"）;  
    
11. 
    
12.     //调用（）办法插入数据  
    
13.     db.（"stu_table"，null，cValue）;  
    
14. }  
    

第二种办法的代码：

1. private void （SQLiteDatabase db）{   
   
2. 
   
3.      //插入数据SQL语句  
   
4.      String stu_sql=" into stu_table（sname，snumber） values（""xiaoming""，""01005""）";  
   
5. 
   
6.     //履行SQL语句  
   
7.      db.execSQL（sql）;  
   
8. }  
   

4、删除数据

删除数据也有两种办法：

①调用SQLiteDatabase的（String table，String whereClause，String[] whereArgs）办法，参数一是表名称，参数二是删除前提，参数三是删除前提值数组；

②编写删除SQL语句，调用SQLiteDatabase的execSQL（）办法来履行删除。

第一种办法的代码：

1. private void （SQLiteDatabase db） {  
   
2. 
   
3.    //删除前提  
   
4.    String whereClause = "_id=？";  
   
5. 
   
6.    //删除前提参数  
   
7.    String[] whereArgs = {String.valueOf（2）};  
   
8. 
   
9.    //履行删除  
   
10.    db.（"stu_table"，whereClause，whereArgs）;   
    
11. }  
    

第二种办法的代码：

1. private void （SQLiteDatabase db） {  
   
2. 
   
3.    //删除SQL语句  
   
4.    String sql = "  stu_table where _id  = 6";  
   
5. 
   
6.    //履行SQL语句  
   
7.    db.execSQL（sql）;  
   
8. }  
   

5、批改数据

批改数占领两种办法：

①调用SQLiteDatabase的（String table，ContentValues values，String whereClause， String[] whereArgs）办法。参数是表名称，参数是更行列ContentValues类型的键值对（Map），参数是更新前提（where字句），参数是更新前提数组。

②编写更新的SQL语句，调用SQLiteDatabase的execSQL履行更新。

第一种办法的代码：

1. private void （SQLiteDatabase db） {  
   
2. 
   
3.     //实例化内容值  
   
4.     ContentValues values = new ContentValues（）;  
   
5. 
   
6.     //在values中添加内容   
   
7.     values.put（"snumber"，"101003"）;  
   
8. 
   
9.     //批改前提   
   
10.     String whereClause = "id=？";  
    
11. 
    
12.     //批改添加参数  
    
13.     String[] whereArgs={String.valuesOf（1）};  
    
14. 
    
15.     //批改  
    
16.     db.（"usertable"，values，whereClause，whereArgs）;   
    
17. }  
    

第二种办法的代码：

1. private void （SQLiteDatabase db）{  
   
2. 
   
3.     //批改SQL语句  
   
4.     String sql = " stu_table set snumber = 654321 where id = 1";  
   
5. 
   
6.     //履行SQL  
   
7.     db.execSQL（sql）;   
   
8. }  
   

6、查询数据

在Android中查询数据是经由过程Cursor类来实现的，应用SQLiteDatabase.query（）办法时，会获得一个Cursor对象，Cursor指向的就是每一条数据。它供给了很多有关查询的办法，具体办法如下：

public Cursor query（String table，String[] columns，String ion，String[] ionArgs，String groupBy，String having，String orderBy，String limit）;

各个参数的意义申明：

①table:表名称

②columns:列名称数组

③ion:前提字句，相当于where

④ionArgs:前提字句，参数数组

⑤groupBy:分组列

⑥having:分组前提

⑦orderBy:排序列

⑧limit:分页查询限制

⑨Cursor:返回值，相当于成果集ResultSet

Cursor是一个游标接口，供给了遍历查询成果的办法，如移动指针办法move（），获得列值办法getString（）等.

Cursor游标常用办法

办法名称	办法描述
getCount（）	获得总的数据项数
isFirst（）	断定是否第一笔记录
isLast（）	断定是否最后一笔记录
moveToFirst（）	移动到第一笔记录
moveToLast（）	移动到最后一笔记录
move（int offset）	移动到指定记录
moveToNext（）	移动到下一笔记录
moveToPrevious（）	移动到上一笔记录
getColumnIndexOrThrow（String columnName）	按照列名称获得列索引
getInt（int columnIndex）	获得指定列索引的int类型值
getString（int columnIndex）	获得指定列缩影的String类型值

下面就是用Cursor来查询数据库中的数据，具体代码如下：

1. private void query（SQLiteDatabase db）  
   
2. {  
   
3. 
   
4.    //查询获得游标  
   
5.    Cursor cursor = db.query   （"usertable"，null，null，null，null，null，null）;  
   
6. 
   
7.    //断定游标是否为空  
   
8.    if（cursor.moveToFirst（） {  
   
9. 
   
10.        //遍历游标  
    
11.        for（int i=0;i
    
12. 
    
13.             cursor.move（i）;  
    
14. 
    
15.             //获得ID  
    
16.             int id = cursor.getInt（0）;  
    
17. 
    
18.             //获得用户名  
    
19.             String username=cursor.getString（1）;  
    
20. 
    
21.             //获得暗码  
    
22.             String password=cursor.getString（2）;  
    
23. 
    
24.             //输出用户信息  
    
25.             System.out.println（id+":"+sname+":"+snumber）;  
    
26.        }  
    
27.    }   
    
28. }  
    
    

 7、删除指定表
 编写插入数据的SQL语句，直接调用SQLiteDatabase的execSQL（）办法来履行

1. private void drop（SQLiteDatabase db）{          
   
2.      //删除表的SQL语句        
   
3.      String sql ="DROP TABLE stu_table";           
   
4.     //履行SQL       
   
5.     db.execSQL（sql）;     
   
6. }   
   
   

 三. SQLiteOpenHelper

该类是SQLiteDatabase一个帮助类。这个类首要生成一 个数据库，并对数据库的版本进行经管。当在法度傍边调用这个类的办法getWritableDatabase（）或者 getReadableDatabase（）办法的时辰，若是当时没稀有据，那么Android体系就会主动生成一个数据库。 SQLiteOpenHelper 是一个抽象类，我们凡是须要持续它，并且实现里面的3个函数：

 1.onCreate（SQLiteDatabase）

在数据库第一次生成的时辰会调用这个办法，也就是说，只有在创建数据库的时辰才会调用，当然也有一些其它的景象，一般我们在这个办法里边生成数据库表。

2.  onUpgrade（SQLiteDatabase，int，int）

当数据库须要进级的时辰，Android体系会主动的调用这个办法。一般我们在这个办法里边删除数据表，并建树新的数据表，当然是否还须要做其他的操纵，完全取决于应用的需求。

3.  onOpen（SQLiteDatabase）：

这是当打开数据库时的回调函数，一般在法度中不是很常应用。

写了这么多，改改用实际例子来申明上方的内容了。下面这个操纵数据库的实例实现了创建数据库，创建表以及数据库的增删改查的操纵。

SQLiteActivity.java

1. package com.lingdududu.testSQLite;  
   
2. 
   
3. import com.lingdududu.testSQLiteDb.StuDBHelper;  
   
4. 
   
5. import android.app.Activity;  
   
6. import android.content.ContentValues;  
   
7. import android.database.Cursor;  
   
8. import android.database.sqlite.SQLiteDatabase;  
   
9. import android.os.Bundle;  
   
10. import android.view.View;  
    
11. import android.view.View.OnClickListener;  
    
12. import android.widget.Button;  
    
13. /*  
    
14.  * ＠author lingdududu  
    
15.  */ 
    
16. public class SQLiteActivity extends Activity {  
    
17.     /** Called when the activity is first created. */ 
    
18.     //声明各个按钮  
    
19.     private Button createBtn;  
    
20.     private Button Btn;  
    
21.     private Button Btn;  
    
22.     private Button queryBtn;  
    
23.     private Button Btn;  
    
24.     private Button ModifyBtn;  
    
25.     ＠Override 
    
26.     public void onCreate（Bundle savedInstanceState） {  
    
27.         super.onCreate（savedInstanceState）;  
    
28.         setContentView（R.layout.main）;  
    
29. 
    
30.         //调用creatView办法  
    
31.         creatView（）;  
    
32.         //setListener办法  
    
33.         setListener（）;          
    
34.     }  
    
35. 
    
36.     //经由过程findViewById获得Button对象的办法  
    
37.     private void creatView（）{  
    
38.         createBtn = （Button）findViewById（R.id.createDatabase）;  
    
39.         Btn = （Button）findViewById（R.id.Database）;  
    
40.         Btn = （Button）findViewById（R.id.）;  
    
41.         ModifyBtn = （Button）findViewById（R.id.）;  
    
42.         queryBtn = （Button）findViewById（R.id.query）;  
    
43.         Btn = （Button）findViewById（R.id.）;  
    
44.     }  
    
45. 
    
46.     //为按钮注册的办法  
    
47.     private void setListener（）{  
    
48.         createBtn.setOnClickListener（new CreateListener（））;  
    
49.         Btn.setOnClickListener（new UpdateListener（））;  
    
50.         Btn.setOnClickListener（new InsertListener（））;  
    
51.         ModifyBtn.setOnClickListener（new  ModifyListener（））;  
    
52.         queryBtn.setOnClickListener（new QueryListener（））;  
    
53.         Btn.setOnClickListener（new DeleteListener（））;  
    
54.     }  
    
55. 
    
56.     //创建数据库的办法  
    
57.     class CreateListener implements OnClickListener{  
    
58. 
    
59.         ＠Override 
    
60.         public void onClick（View v） {  
    
61.             //创建StuDBHelper对象  
    
62.             StuDBHelper dbHelper = new StuDBHelper（SQLiteActivity.this，"stu_db"，null，1）;  
    
63.             //获得一个可读的SQLiteDatabase对象  
    
64.             SQLiteDatabase db =dbHelper.getReadableDatabase（）;  
    
65.         }         
    
66.     }  
    
67. 
    
68.     //更新数据库的办法  
    
69.     class UpdateListener implements OnClickListener{  
    
70. 
    
71.         ＠Override 
    
72.         public void onClick（View v） {  
    
73.             // 数据库版本的更新，由本来的1变为2  
    
74.             StuDBHelper dbHelper = new StuDBHelper（SQLiteActivity.this，"stu_db"，null，2）;  
    
75.             SQLiteDatabase db =dbHelper.getReadableDatabase（）;  
    
76.         }         
    
77.     }  
    
78. 
    
79.     //插入数据的办法  
    
80.     class InsertListener implements OnClickListener{  
    
81. 
    
82.         ＠Override 
    
83.         public void onClick（View v） {  
    
84. 
    
85.             StuDBHelper dbHelper = new StuDBHelper（SQLiteActivity.this，"stu_db"，null，1）;  
    
86.             //获得一个可写的数据库  
    
87.             SQLiteDatabase db =dbHelper.getWritableDatabase（）;  
    
88. 
    
89.             //生成ContentValues对象 //key:列名，value:想插入的值    
    
90.             ContentValues cv = new ContentValues（）;  
    
91.             //往ContentValues对象存放数据，键-值对模式  
    
92.             cv.put（"id"， 1）;  
    
93.             cv.put（"sname"， "xiaoming"）;  
    
94.             cv.put（"sage"， 21）;  
    
95.             cv.put（"ssex"， "male"）;  
    
96.             //调用办法，将数据插入数据库  
    
97.             db.（"stu_table"， null， cv）;  
    
98.             //封闭数据库  
    
99.             db.close（）;  
    
100.         }         
     
101.     }  
     
102. 
     
103.     //查询数据的办法  
     
104.     class QueryListener implements OnClickListener{  
     
105. 
     
106.         ＠Override 
     
107.         public void onClick（View v） {  
     
108. 
     
109.             StuDBHelper dbHelper = new StuDBHelper（SQLiteActivity.this，"stu_db"，null，1）;  
     
110.             //获得一个可写的数据库  
     
111.             SQLiteDatabase db =dbHelper.getReadableDatabase（）;  
     
112.             //参数1：表名    
     
113.             //参数2：要想显示的列    
     
114.             //参数3：where子句    
     
115.             //参数4：where子句对应的前提值    
     
116.             //参数5：分组体式格式    
     
117.             //参数6：having前提    
     
118.             //参数7：排序体式格式    
     
119.             Cursor cursor = db.query（"stu_table"， new String[]{"id"，"sname"，"sage"，"ssex"}， "id=？"， new String[]{"1"}， null， null， null）;  
     
120.             while（cursor.moveToNext（））{  
     
121.                 String name = cursor.getString（cursor.getColumnIndex（"sname"））;  
     
122.                 String age = cursor.getString（cursor.getColumnIndex（"sage"））;  
     
123.                 String sex = cursor.getString（cursor.getColumnIndex（"ssex"））;  
     
124.                 System.out.println（"query------->" + "姓名："+name+" "+"春秋："+age+" "+"性别："+sex）;  
     
125.             }  
     
126.             //封闭数据库  
     
127.             db.close（）;  
     
128.         }         
     
129.     }  
     
130. 
     
131.     //批改数据的办法  
     
132.     class ModifyListener implements OnClickListener{  
     
133. 
     
134.         ＠Override 
     
135.         public void onClick（View v） {  
     
136. 
     
137.             StuDBHelper dbHelper = new StuDBHelper（SQLiteActivity.this，"stu_db"，null，1）;  
     
138.             //获得一个可写的数据库  
     
139.             SQLiteDatabase db =dbHelper.getWritableDatabase（）;  
     
140.             ContentValues cv = new ContentValues（）;  
     
141.             cv.put（"sage"， "23"）;  
     
142.             //where 子句 "？"是占位符号，对应后面的"1"，  
     
143.             String whereClause="id=？";  
     
144.             String [] whereArgs = {String.valueOf（1）};  
     
145.             //参数1 是要更新的表名  
     
146.             //参数2 是一个ContentValeus对象  
     
147.             //参数3 是where子句  
     
148.             db.（"stu_table"， cv， whereClause， whereArgs）;  
     
149.         }  
     
150.     }  
     
151. 
     
152.     //删除数据的办法  
     
153.     class DeleteListener implements OnClickListener{  
     
154. 
     
155.         ＠Override 
     
156.         public void onClick（View v） {  
     
157. 
     
158.             StuDBHelper dbHelper = new StuDBHelper（SQLiteActivity.this，"stu_db"，null，1）;  
     
159.             //获得一个可写的数据库  
     
160.             SQLiteDatabase db =dbHelper.getReadableDatabase（）;  
     
161.             String whereClauses = "id=？";  
     
162.             String [] whereArgs = {String.valueOf（2）};  
     
163.             //调用办法，删除数据   
     
164.             db.（"stu_table"， whereClauses， whereArgs）;  
     
165.         }     
     
166.     }  
     
167. } 
     
     

StuDBHelper.java

1. package com.lingdududu.testSQLiteDb;  
   
2. 
   
3. import android.content.Context;  
   
4. import android.database.sqlite.SQLiteDatabase;  
   
5. import android.database.sqlite.SQLiteDatabase.CursorFactory;  
   
6. import android.database.sqlite.SQLiteOpenHelper;  
   
7. import android.util.Log;  
   
8. 
   
9. public class StuDBHelper extends SQLiteOpenHelper {  
   
10. 
    
11.     private static final String TAG = "TestSQLite";  
    
12.     public static final int VERSION = 1;  
    
13. 
    
14.     //必必要有机关函数  
    
15.     public StuDBHelper（Context context， String name， CursorFactory factory，  
    
16.             int version） {  
    
17.         super（context， name， factory， version）;  
    
18.     }  
    
19. 
    
20.     // 当第一次创建数据库的时辰，调用该办法   
    
21.     public void onCreate（SQLiteDatabase db） {  
    
22.         String sql = "create table stu_table（id int，sname varchar（20），sage int，ssex varchar（10））";  
    
23.         //输出创建数据库的日记信息  
    
24.         Log.i（TAG， "create Database------------->"）;  
    
25.         //execSQL函数用于履行SQL语句  
    
26.         db.execSQL（sql）;  
    
27.     }  
    
28. 
    
29.     //当更新数据库的时辰履行该办法  
    
30.     public void onUpgrade（SQLiteDatabase db， int oldVersion， int newVersion） {  
    
31.         //输出更新数据库的日记信息  
    
32.         Log.i（TAG， " Database------------->"）;  
    
33.     }  
    
34. }  
    
    

main.xml

1. < xmlversion="1.0" encoding="utf-8" > 
   
2. 
   
3.     android:orientation="vertical" 
   
4.     android:layout_width="fill_parent" 
   
5.     android:layout_height="fill_parent" 
   
6.     > 
   
7.    
   
8.         android:layout_width="fill_parent"   
   
9.         android:layout_height="wrap_content"   
   
10.         android:text="＠string/hello" 
    
11.         /> 
    
12.     
    
13.         android:id="＠+id/createDatabase" 
    
14.         android:layout_width="fill_parent"   
    
15.         android:layout_height="wrap_content"   
    
16.         android:text="创建数据库" 
    
17.         />        
    
18.     
    
19.         android:id="＠+id/Database" 
    
20.         android:layout_width="fill_parent"   
    
21.         android:layout_height="wrap_content"   
    
22.         android:text="更新数据库" 
    
23.         />    
    
24.     
    
25.         android:id="＠+id/" 
    
26.         android:layout_width="fill_parent"   
    
27.         android:layout_height="wrap_content"   
    
28.         android:text="插入数据" 
    
29.         /> 
    
30.     
    
31.         android:id="＠+id/" 
    
32.         android:layout_width="fill_parent"   
    
33.         android:layout_height="wrap_content"   
    
34.         android:text="更新数据" 
    
35.         /> 
    
36.     
    
37.         android:id="＠+id/query" 
    
38.         android:layout_width="fill_parent"   
    
39.         android:layout_height="wrap_content"   
    
40.         android:text="查询数据" 
    
41.         /> 
    
42.      
    
43.         android:id="＠+id/" 
    
44.         android:layout_width="fill_parent"   
    
45.         android:layout_height="wrap_content"   
    
46.         android:text="删除数据" 
    
47.         /> 
    
48. </LinearLayout> 
    
    

法度运行的结果图：

 当点击创建数据库按钮：

LogCat窗口输出的信息为：

当点击更新数据库按钮：

LogCat窗口输出的信息为：

当点击查询数据库按钮：

LogCat窗口输出的信息为：

应用adb号令查看数据库：

1.在号令行窗口输入adb shell回车，就进入了Linux号令行，如今就可以应用Linux的号令了。

2.ls回车，显示所有的器材，此中有个data。（ls:显示所有，cd:进入）

3.cd data回车，再ls回车，cd data回车，ls回车后就会看到很多的com.。。。，那就是体系上的应用法度包名，找到你数据库法度的包名，然掉队入。

4.进去后在查看所有，会看到有databases，进入databases，显示所有就会发明你的数据库名字，这里应用的是"stu_db"。

5.sqlite3 stu_db回车就进入了你的数据库了，然后“.schema”就会看到该应用法度的所有表及建表语句。

6.之后就可以应用标准的SQL语句查看刚才生成的数据库及对数据履行增删改查了。

＃ sqlite3 stu_db
sqlite3 stu_db
SQLite version 3.6.22
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .schema
.schema
CREATE TABLE android_metadata （locale TEXT）;
CREATE TABLE stu_table（id int，sname varchar（20），sage int，ssex varchar（10））;  --->创建的表
sqlite>  * stu_table;
* stu_table;
1|xiaoming|21|male
sqlite>

 插入数据

sqlite>  into stu_table values（2，""xiaohong""，20，""female""）;

插入的数据记得要和表中的属性一一对应
into stu_table values（2，""xiaohong""，20，""female""）;
sqlite> * stu_table;
* stu_table;
1|xiaoming|21|male
2|xiaohong|20|female   --------------> 插入的数据
sqlite>

当点击批改数据的按钮时辰

sqlite> * stu_table;
* stu_table;
1|xiaoming|23|male  -------------->春秋被批改为23
2|xiaohong|20|female
sqlite>

当点击删除数据的按钮

sqlite> * stu_table;
* stu_table;
1|xiaoming|23|male        id=2的数据已经被删除

总之，我们可以在代码中履行数据库的增删改查，也可以在adb号令行下实现。不过因为SQLite没有客户端，不克不及直接的查看数据库变更后的信息，所以常用adb号令行查看数据库改变后的信息。