android数据库相关知识总结

1、 安卓数据存储相关知识总结：

（1） SharePreference：（配置信息存储）

除了SQLite数据库外，SharedPreferences也是一种轻型的数据存储方式，它的本质是基于XML文件存储key-value键值对数据，通常用来存储一些简单的配置信息。其存储位置在/data/data/<包名>/shared_prefs目录下。SharedPreferences对象本身只能获取数据而不支持存储和修改，存储修改是通过Editor对象实现。实现SharedPreferences存储的步骤如下：1）根据Context获取SharedPreferences对象；2）利用edit()方法获取Editor对象；3）通过Editor对象存储key-value键值对数据；4）通过commit()方法提交数据

（2） SQLite：

SQLite是一种转为嵌入式设备设计的轻型数据库，其只有五种数据类型，分别为：

NULL:空值INTEGER:整数REAL:浮点数TEXT:字符串BLOB:大数据

在SQLite中，并没有专门设计BOOLEAN和DATE类型，因为BOOLEAN型可以用INTEGER的0和1代替true和false，而DATE类型则可以拥有特定格式的TEXT、REAL和INTEGER的值来代替显示，为了能方便的操作DATE类型，SQLite提供了一组函数，详见：http://www.sqlite.org/lang_datefunc.html。这样简单的数据类型设计更加符合嵌入式设备的要求。关于SQLite的更多资料，请参看：http://www.sqlite.org/

（3） ContentProvider：

Android系统中能实现所有应用程序共享的一种数据存储方式，由于数据通常在各应用间的是互相私密的，所以此存储方式较少使用，但是其又是必不可少的一种存储方式。例如音频，视频，图片和通讯录，一般都可以采用此种方式进行存储。每个Content Provider都会对外提供一个公共的URI（包装成Uri对象），如果应用程序有数据需要共享时，就需要使用Content Provider为这些数据定义一个URI，然后其他的应用程序就通过Content Provider传入这个URI来对数据进行操作。

URI由3个部分组成:"content://"、数据的路径、标识ID(可选)。

（4） File：

提供一种I/O操作

2、 详细介绍SQLite进行数据存储：

1） 定义一个SQLiteDatabase类，如db（如果想要实现全局变量的效果，可以定义在oncreate函数的外面，并初始化为null）；

2） 通过如下语句创建名为login.db的数据库

try { db=this.openOrCreateDatabase("login.db", Context.MODE_PRIVATE, null);} catch(Exception e){ Log.e("ERROR", e.toString());   return;}

这里要说明一下：

mode的值：默认的模式为0或MODE_PRIVATE

 

MODE_PRIVATE则该配置文件只能被自己的应用程序访问；MODE_WORLD_READABLE则该配置文件除了自己访问外还可以被其它应该程序读取；MODE_WORLD_WRITEABLE，则该配置文件除了自己访问外还可以被其它应该程序读取和写入; 当使用前面这几种权限时，其他程序访问数据时启动本程序修改文件数据，其他程序得到的还是缓存数据得不到最新数据，其他程序想得最新数据，本程序在写文件时须用MODE_MULTI_PROCESS权限（参数是4）；权限参数还可相加，如Content.MODE_WORLD_READABLE+Content. MODE_WORLD_WRITEABLE

 

3） 通过如下语句在数据库中创建表（如果表不存在）

try { db.execSQL("create table if not exists student(name String primary key,password String)");} catch (Exception e) {  Log.e("ERROR", e.toString());  }

4） 通过如下语句对数据库中的表进行操作，包括插入、修改、删除等

A：查询，通过Cursor数据类型保存结果

String sql="select password from "+table_name+" where name="+"'"+name+"'";

Cursor c;//对于这个类需要进行说明如下：

Cursor 是每行的集合；使用 moveToFirst() 定位第一行；你必须知道每一列的名称；你必须知道每一列的数据类型；Cursor 是一个随机的数据源；所有的数据都是通过下标取得。

try{c=db.rawQuery(sql, null);

if(c!=null)

{

c.moveToFirst();

String pass_word=c.getString(0);

if(pass_word.equals(password))//判断两个字符串是否相等不能直接用==须用//equals函数进行判断，区别于QString

mes.setText("login success!");

else

mes.setText("password error!");

}}catch(Exception e) {  Log.e("ERROR", e.toString());  }

B:插入

sql="insert into "+table_name+" (name,password) values('"+name+"','"+password+"')";

try{db.execSQL(sql);} catch(Exception e) {  Log.e("ERROR", e.toString());  }

C:修改

String sql="update "+table_name+" set password='"+password+"' where name='"+name+"'";

   try{db.execSQL(sql);}

 catch(Exception e) {  Log.e("ERROR", e.toString());  }

D:删除

String sql="delete from "+table_name+" where name='"+name+"'";

   try{db.execSQL(sql);}

catch(Exception e) {  Log.e("ERROR", e.toString());  }

 

3、 详细介绍sharepreference的使用情况：

SharedPreferences的使用非常简单，能够轻松的存放数据和读取数据。SharedPreferences只能保存简单类型的数据，例如，String、int等。一般会将复杂类型的数据转换成Base64编码，然后将转换后的数据以字符串的形式保存在 XML文件中，再用SharedPreferences保存。

A:存数

1） 先创建SharedPreferences类对象，代码如下：

SharedPreferences share=getSharedPreferences("share",Context.MODE_PRIVATE);

其中“share”是定义生成的存储“键---值”对的share.xml文件，其存储路径为/data/data/<package name>/shared_prefs/下

注意：这里还没有生成对应 的文件，必须通过Editor对象进行提交才生成了存储路径定义的*.xml文件。

2） 定义Editor对象，对“键----值”对进行操作，如这里所示person代码如下：

Editor person=share.edit();

3） 通过Editor对象的putXXXX（”键_索引”,值_变量名）方法，将“键----值”对写入对应的xml文件中，注：其中的XXXX对应如String、Int等数据类型

4） 通过Editor对象的commit()函数将修改进行提交

B:取数

1）还是先要创建SharedPreferences类对象，代码如下：

SharedPreferences share=getSharedPreferences("share",Context.MODE_PRIVATE);

其中“share”是定义生成的存储“键---值”对的share.xml文件，其存储路径为/data/data/<package name>/shared_prefs/下

2）定义XXXX类型的变量保存通过share.getXXXX("键_索引", "++++");这里注意第一个参数必须与写进去时的键_索引完全一样（即使是空格也不允许）

3）再去利用获得的变量值进行其他操作吧

 

附加：访问其他程序的preference

方法一：提供文件路径，通过在该程序中创建一个文件保存其他程序对应的xml文件，再对本程序创建的文件进行读取使用操作。

 

代码实现如下：

SharedPreferences share_file=getSharedPreferences("otherapp",3);

Editor person=share_file.edit();

person.commit();//只有通过commit提交才能够生成对应的xml文件

String path_input="/data/data/com.example.test_sharepreference/shared_

prefs/share.xml";

String path_output="/data/data/com.example.sharepreference_otherapp/

shared_prefs/otherapp.xml";

File file_input=new File(path_input);

File file_output=new File(path_output);

try

{

byte[] buffer=new byte[1024];

FileInputStream  input=new FileInputStream(file_input);

FileOutputStream output=new FileOutputStream(file_output);

input.mark(CONTEXT_IGNORE_SECURITY);//这条语句解决了文件被其他应用//程序读取的权限设置模式过期问题

int len=0;

while((len=input.read(buffer))!=-1)

{

byte[] a=new byte[len];

for(int i=0;i<len;i++)

a[i]=buffer[i];

output.write(a);

} 

input.close();  

output.flush();

output.close(); 

  }catch(Exception e) {  Log.e("ERROR", e.toString());  }

  SharedPreferences share=getSharedPreferences("otherapp",3);

  String telephone=share.getString("电话", "++++");

  String name=share.getString("姓名", "++++");

  String addr=share.getString("住址", "++++");

  String mail=share.getString("邮编", "++++");

直接调用clone函数，a=buffer.clone();会把buffer最初new的大小的内容拷贝给a（而不管a用new分配的空间的大小）；这里可以通过for(int i=0;i<len;i++)

a[i]=buffer[i]; output.write(a);只是将特定大小的byte写入文件中。

 

方法二：直接读取使用其他程序对应的xml文件

对于这种方法还没有实现+++++++++++++

 

4、 详细介绍文件IO存储数据（对于数据，是以流的形式进行的，所以可以通过添加 等进行元素的标记）

注意：IO的介绍

针对字节（byte）、字符（String）有两种方式：

字节：字符则要转换成字节才能处理，用于简化对字符串的输入输出编程，即用于读写文本数据（操作二进制文件）

FileinputStream：

FileOutputStream：

字符：（操作文本文件）

writer：

reader：

 

 

 

二进制文件和文本文件的区别：

文本文件是基于字符编码的文件，基本上是定长编码的。那些没有规定格式的，由可理解的的ASCII以及其他编码文字组成的文件都是文本文件，如C源程序文件，HTML超文本，XML。

二进制文件是基于值编码的文件，二进制文件可看成是变长编码的，读文件时，会原封不动的读出文件的全部內容，写的時候，也是把內存缓冲区的內容原封不动的写到文件中。

A：FileInputStream读文件

1） 定义一个FileInputStream类对象，读取文件名为filename

也要定义byte[]类型变量，作为缓存buffer

FileInputStream inputfile=openFileInput(filename);

2） 定义读出后的暂存数据的数组，并且初始化已读数据长度len=0

ByteArrayOutputStream in=new ByteArrayOutputStream();

3） 通过read函数返回的读取的字节的个数来控制循环是否结束，read函数中的参数buffer保存读出的值，并写进暂存数据数组。实际代码如下：

while((len=inputfile.read(buffer))!=-1){ in.write(buffer, 0, len); }

4） 通过close函数关闭in和inputfile两个对象。

对应的代码实现：

byte[] buffer=new byte[1024]; 

   FileInputStream inputfile=openFileInput(filename);

ByteArrayOutputStream in=new ByteArrayOutputStream();

   int len=0;

   while((len=inputfile.read(buffer))!=-1)

   {in.write(buffer, 0, len);

Toast.makeText(Fileop.this,new String(buffer,0,len)+"ok", 

Toast.LENGTH_LONG).show();} 

    inputfile.close();

in.close();

 

还有一种不一定要用到这个2）中的ByteArrayOutputStream，而是可以通过,new String(buffer,0,len)存储实现。

byte[] buffer=new byte[1024]; 

FileInputStream inputfile=openFileInput(filename);

int len=0;

while((len=inputfile.read(buffer))!=-1)

{

Toast.makeText(Fileop.this,new String(buffer,0,len)+"ok", Toast.LENGTH_LONG).show();

}

inputfile.close();

 

B：FileOutputStream写文件

1）定义FileOutputStream类对象，构造函数中填入文件名、模式（同上面总结）

byte[] buffer=new byte[1024]; 

String a=*********;//要写入的内容

    buffer=a.getBytes();//将String类型转换成byte类型

FileOutputStream outputfile=openFileOutput(filename,Context.MODE_PRIVATE);

2）通过write函数直接进行写操作

outputfile.write(buffer);

3）关闭相关的数据文件

outputfile.flush();

outputfile.close();

对应的代码实现如下：

try{

byte[] buffer=new byte[1024]; 

String a="sdgdfghfgjhjlklklklklklklklkjljklkjljljjhhhhhhhg";

      buffer=a.getBytes();

FileOutputStream outputfile=openFileOutput(filename,Context.MODE_PRIVATE);

outputfile.write(buffer);

outputfile.flush();

outputfile.close();}

catch(Exception e) {  Log.e("ERROR", e.toString());  }

 

C：reader读文件

1）定义如下的char[]、CharArrayWriter的类对象进行数据的传递与缓存， FileReader对象传递的文件名必须要加路径，不然会显示read-only file system的错误。

byte[] buffer=new byte[1024]; 

2）读取、转化进行输出的测试

对应的代码如下：

String filename=getFilesDir().getPath().toString()+name.toString();

try{

char[] buffer=new char[1]; 

CharArrayWriter in=new CharArrayWriter();

//可有可无的一句BufferedReader inputfile=new BufferedReader(new FileReader(filename));

FileReader inputfile=new FileReader(filename);

while(inputfile.read(buffer)!=-1)

{in.write(buffer); }

buffer=in.toCharArray();

for(int i=0;i<buffer.length;i++)System.out.println(buffer[i]); 

inputfile.close();

}catch(Exception e) {  Log.e("ERROR", e.toString());  }

 

D：writer写文件

1）定义如下的char[]、CharArrayReader类对象进行数据的传递与缓存，其中FileWriter对象传递的文件名必须要加路径，不然会显示read-only file system的错误（同上）。

2）读取、转化进行输出测试。

对应的代码如下：

String filename=getFilesDir().getPath().toString()+name.toString();

try{ 

//可有可无BufferedWriter outputfile=new BufferedWriter(new FileWriter(filename));

FileWriter outputfile=new FileWriter(filename);

char[] array={'a','b','c','d','e','f','h','h','h'};

char[] tmp=new char[1];

CharArrayReader out=new CharArrayReader(array);

while((out.read(tmp))!=-1)

{ outputfile.write(tmp); }

out.close();

outputfile.flush();

outputfile.close(); 

}catch(Exception e) {  Log.e("ERROR", e.toString());  }

 

注意：

1）openFileOutput()方法的第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。创建的文件保存/data/data/<package name>/files目录。所以要针对这个问题对传递的路径进行相关的处理。这种方法可以自己定义对文件的操作权限。

2）不使用openFileOutput()的方法，而是直接使用构造函数的形式来创建对象，这种方式没有提供对文件操作权限的模式设置，对于此问题出现的解决通过对输入文件调用mark方法：FileInputStream  input=new FileInputStream(file_input);

input.mark(CONTEXT_IGNORE_SECURITY)实现

3）通过读取文件生成另一个文件，通过bytes[]进行数据的传送与缓存，bytes[]通过读取的文件的后缀名的编码格式自动选用读取的文件对应的编码格式。对于编码格式的讲解可以见java中中文编码的参考网址：

http://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/

5、 通过ContentProvider类实现数据的存储：ContentProvider对外共享数据的好处是统一了数据的访问方式

ContentProvider包括：Browser：存储浏览器信息；CallLog：存储通话记录等信息；Contacts：存储联系人等信息；MediaStore：存储媒体文件的信息；Settings：存储设备的设置与首选项信息。需要在androidmainifest.xml中注册才能够使用。ContentResolver中执行ContentProvider暴露出来的任何方法，而bulkInsert()方法用于插入多条数据。

1）第一步需要继承ContentProvider并重写下面方法：

contentProvider实现的几个方法需要重写：onCreate():初始化提供者；query(Uri,String[],String,String[],String): 查询数据，返回一个数据Cursor对象；insert(Uri a, ContentValues b)：插入一条数据；update(Uri a, ContentValues b, String c, String[] d)：根据条件更新数据；delete(Uri a, String b, String[] c)：根据条件删除数据；getType(Uri a) 返回MIME类型对应内容的URI。

2）在AndroidMainifest.xml中的<application>属性里面使用<Provider>属性来对ContentProvider进行配置，为了能让其他应用找到该ContentProvider ，ContentProvider采用了authorities（主机名/域名）对它进行唯一标识。authority的书写是：authorities 是provider所在的包的名字+provider本身定义的名称。

 

ContentProvider（内容提供者）的scheme已经由Android所规定， scheme为：content://主机名（或叫Authority）用于唯一标识这个ContentProvider，外部调用者可以根据这个标识来找到它。路径（path）可以用来表示我们要操作的数据，路径的构建应根据业务而定。

要操作person表中id为10的记录，可以构建这样的路径:/person/10
要操作person表中id为10的记录的name字段， person/10/name
要操作person表中的所有记录，可以构建这样的路径:/person
要操作xxx表中的记录，可以构建这样的路径:/xxx
当然要操作的数据不一定来自数据库，也可以是文件、xml或网络等其他存储方式，如下:要操作xml文件中person节点下的name节点，可以构建这样的路径：/person/name
如果要把一个字符串转换成Uri，可以使用Uri类中的parse()方法

Uri uri=Uri.parse(“content://com.ljq.provider.personprovider/person”)

UriMatcher类的使用：

 

6、 

 

 

注意：

如果采用文件操作模式对外共享数据，数据的访问方式会因数据存储的方式而不同，导致数据的访问方式无法统一，如：采用xml文件对外共享数据，需要进行xml解析才能读取数据；采用sharedpreferences共享数据，需要使用sharedpreferences API读取数据。

 

 

 

 

 

 

一、 SQLite介绍 
SQLite是android内置的一个很小的关系型数据库。 
SQLite的官网是http://www.sqlite.org/，可以去下载一些文档或相关信息。 
博客中有一篇有稍微详细一点的介绍，大家可以去看一下。 

二、 SQLiteOpenHelper的使用方法 
SQLiteOpenHelper是一个辅助类来管理数据库的创建和版本。 
可以通过继承这个类，实现它的一些方法来对数据库进行一些操作。 
所有继承了这个类的类都必须实现下面这样的一个构造方法： 
public DatabaseHelper(Context context, String name, CursorFactory factory, int version) 
第一个参数：Context类型，上下文对象。 
第二个参数：String类型，数据库的名称 
第三个参数：CursorFactory类型 
第四个参数：int类型，数据库版本 
下面是这个类的几个方法： 

方法名 返回类型 描述 备注 
getReadableDatabase() synchronized SQLiteDatabase 创建或打开一个数据库 可以通过这两个方法返回的SQLiteDatabase对象对数据库进行一系列的操作，如新建一个表，插入一条数据等 
getWritableDatabase() synchronized SQLiteDatabase 创建或打开一个可以读写的数据库 
onCreate(SQLiteDatabase db) abstract void 第一次创建的时候调用 
onOpen(SQLiteDatabase db) void 打开数据库 
onUpgrade(SQLiteDatabase db,int oldVersion,int newVersion) abstract void 升级数据库 
close() synchronized void 关闭所有打开的数据库对象 

下面有一个例子，当点击按钮时进行相应的操作，效果图如下： 

 
介于代码中有详细备注了，在此我就不多写了，直接贴代码了，代码如下： 
DatabaseHelper类： 

Java代码  

1. package android.sqlite;  
3. import android.content.Context;  
4. import android.database.sqlite.SQLiteDatabase;  
5. import android.database.sqlite.SQLiteOpenHelper;  
6. import android.database.sqlite.SQLiteDatabase.CursorFactory;  
8. /** 
9. * SQLiteOpenHelper是一个辅助类，用来管理数据库的创建和版本他，它提供两个方面的功能 
10. * 第一，getReadableDatabase()、getWritableDatabase()可以获得SQLiteDatabase对象，通过该对象可以对数据库进行操作 
11. * 第二，提供了onCreate()、onUpgrade()两个回调函数，允许我们再创建和升级数据库时，进行自己的操作 
12. */  
13. public class DatabaseHelper extends SQLiteOpenHelper {  
14. private static final int VERSION = 1;  
16. /** 
17. * 在SQLiteOpenHelper的子类当中，必须有该构造函数 
18. * @param context   上下文对象 
19. * @param name      数据库名称 
20. * @param factory 
21. * @param version   当前数据库的版本，值必须是整数并且是递增的状态 
22. */  
23. public DatabaseHelper(Context context, String name, CursorFactory factory,  
24. int version) {  
25. //必须通过super调用父类当中的构造函数  
26. super(context, name, factory, version);  
27. }  
29. public DatabaseHelper(Context context, String name, int version){  
30. this(context,name,null,version);  
31. }  
33. public DatabaseHelper(Context context, String name){  
34. this(context,name,VERSION);  
35. }  
37. //该函数是在第一次创建的时候执行，实际上是第一次得到SQLiteDatabase对象的时候才会调用这个方法  
38. @Override  
39. public void onCreate(SQLiteDatabase db) {  
40. // TODO Auto-generated method stub  
41. System.out.println("create a database");  
42. //execSQL用于执行SQL语句  
43. db.execSQL("create table user(id int,name varchar(20))");  
44. }  
46. @Override  
47. public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {  
48. // TODO Auto-generated method stub  
49. System.out.println("upgrade a database");  
50. }  
51. }  

Activity类： 

Java代码  

1. package android.sqlite;  
3. import android.app.Activity;  
4. import android.content.ContentValues;  
5. import android.database.Cursor;  
6. import android.database.sqlite.SQLiteDatabase;  
7. import android.os.Bundle;  
8. import android.view.View;  
9. import android.view.View.OnClickListener;  
10. import android.widget.Button;  
12. public class SQLiteActivity extends Activity {  
13. /** Called when the activity is first created. */  
14. private Button createDatabaseButton = null;  
15. private Button updateDatabaseButton = null;  
16. private Button insertButton = null;  
17. private Button updateButton = null;  
18. private Button selectButton = null;  
19. private Button deleteButton = null;  
21. @Override  
22. public void onCreate(Bundle savedInstanceState) {  
23. super.onCreate(savedInstanceState);  
24. setContentView(R.layout.main);  
25. // 根据控件id获得相应的控件对象  
26. createDatabaseButton = (Button) findViewById(R.id.createDatabase);  
27. updateDatabaseButton = (Button) findViewById(R.id.updateDatabase);  
28. insertButton = (Button) findViewById(R.id.insert);  
29. updateButton = (Button) findViewById(R.id.update);  
30. selectButton = (Button) findViewById(R.id.select);  
31. deleteButton = (Button) findViewById(R.id.delete);  
32. // 为按钮设置监听器  
33. createDatabaseButton  
34. .setOnClickListener(new CreateDatabaseOnClickListener());  
35. updateDatabaseButton  
36. .setOnClickListener(new UpdateDatabaseOnClickListener());  
37. insertButton.setOnClickListener(new InsertOnClickListener());  
38. updateButton.setOnClickListener(new UpdateOnClickListener());  
39. selectButton.setOnClickListener(new SelectOnClickListener());  
40. deleteButton.setOnClickListener(new DeleteOnClickListener());  
41. }  
43. // createDatabaseButton点击事件监听器  
44. class CreateDatabaseOnClickListener implements OnClickListener {  
45. public void onClick(View v) {  
46. // 创建了一个DatabaseHelper对象，只执行这句话是不会创建或打开连接的  
47. DatabaseHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,  
48. "test_yangyz_db");  
49. // 只有调用了DatabaseHelper的getWritableDatabase()方法或者getReadableDatabase()方法之后，才会创建或打开一个连接  
50. SQLiteDatabase sqliteDatabase = dbHelper.getReadableDatabase();  
51. }  
52. }  
54. // updateDatabaseButton点击事件监听器  
55. class UpdateDatabaseOnClickListener implements OnClickListener {  
56. public void onClick(View v) {  
57. // TODO Auto-generated method stub  
58. DatabaseHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,  
59. "test_yangyz_db", 2);  
60. // 得到一个只读的SQLiteDatabase对象  
61. SQLiteDatabase sqliteDatabase = dbHelper.getReadableDatabase();  
62. }  
64. }  
66. // insertButton点击事件监听器  
67. class InsertOnClickListener implements OnClickListener {  
68. public void onClick(View v) {  
69. // 创建ContentValues对象  
70. ContentValues values = new ContentValues();  
71. // 向该对象中插入键值对，其中键是列名，值是希望插入到这一列的值，值必须和数据库当中的数据类型一致  
72. values.put("id", 1);  
73. values.put("name", "yangyz");  
74. // 创建DatabaseHelper对象  
75. DatabaseHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,  
76. "test_yangyz_db", 2);  
77. // 得到一个可写的SQLiteDatabase对象  
78. SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase();  
79. // 调用insert方法，就可以将数据插入到数据库当中  
80. // 第一个参数:表名称  
81. // 第二个参数：SQl不允许一个空列，如果ContentValues是空的，那么这一列被明确的指明为NULL值  
82. // 第三个参数：ContentValues对象  
83. sqliteDatabase.insert("user", null, values);  
84. }  
85. }  
87. // updateButton点击事件监听器  
88. class UpdateOnClickListener implements OnClickListener {  
89. public void onClick(View v) {  
90. // 创建一个DatabaseHelper对象  
91. DatabaseHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,  
92. "test_yangyz_db", 2);  
93. // 得到一个可写的SQLiteDatabase对象  
94. SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase();  
95. // 创建一个ContentValues对象  
96. ContentValues values = new ContentValues();  
97. values.put("name", "zhangsan");  
98. // 调用update方法  
99. // 第一个参数String：表名  
100. // 第二个参数ContentValues：ContentValues对象  
101. // 第三个参数String：where字句，相当于sql语句where后面的语句，？号是占位符  
102. // 第四个参数String[]：占位符的值  
103. sqliteDatabase.update("user", values, "id=?", new String[] { "1" });  
104. System.out.println("-----------update------------");  
105. }  
106. }  
108. // selectButton点击事件监听器  
109. class SelectOnClickListener implements OnClickListener {  
110. public void onClick(View v) {  
111. String id = null;  
112. String name = null;  
113. //创建DatabaseHelper对象  
114. DatabaseHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,  
115. "test_yangyz_db", 2);  
116. // 得到一个只读的SQLiteDatabase对象  
117. SQLiteDatabase sqliteDatabase = dbHelper.getReadableDatabase();  
118. // 调用SQLiteDatabase对象的query方法进行查询，返回一个Cursor对象：由数据库查询返回的结果集对象  
119. // 第一个参数String：表名  
120. // 第二个参数String[]:要查询的列名  
121. // 第三个参数String：查询条件  
122. // 第四个参数String[]：查询条件的参数  
123. // 第五个参数String:对查询的结果进行分组  
124. // 第六个参数String：对分组的结果进行限制  
125. // 第七个参数String：对查询的结果进行排序  
126. Cursor cursor = sqliteDatabase.query("user", new String[] { "id",  
127. "name" }, "id=?", new String[] { "1" }, null, null, null);  
128. // 将光标移动到下一行，从而判断该结果集是否还有下一条数据，如果有则返回true，没有则返回false  
129. while (cursor.moveToNext()) {  
130. id = cursor.getString(cursor.getColumnIndex("id"));  
131. name = cursor.getString(cursor.getColumnIndex("name"));  
132. }  
133. System.out.println("-------------select------------");  
134. System.out.println("id: "+id);  
135. System.out.println("name: "+name);  
136. }  
137. }  
139. // deleteButton点击事件监听器  
140. class DeleteOnClickListener implements OnClickListener {  
141. public void onClick(View v) {  
142. //创建DatabaseHelper对象  
143. DatabaseHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,"test_yangyz_db",2);  
144. //获得可写的SQLiteDatabase对象  
145. SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase();  
146. //调用SQLiteDatabase对象的delete方法进行删除操作  
147. //第一个参数String：表名  
148. //第二个参数String：条件语句  
149. //第三个参数String[]：条件值  
150. sqliteDatabase.delete("user", "id=?", new String[]{"1"});  
151. System.out.println("----------delete----------");  
152. }  
153. }  
154. }  

布局文件： 

Xml代码  

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3. android:orientation="vertical"  
4. android:layout_width="fill_parent"  
5. android:layout_height="fill_parent"  
6. >  
7. <TextView    
8. android:layout_width="fill_parent"   
9. android:layout_height="wrap_content"   
10. android:text="@string/hello"  
11. />  
13. <Button  
14. android:id="@+id/createDatabase"  
15. android:layout_width="fill_parent"  
16. android:layout_height="wrap_content"  
17. android:text="@string/createDatabaseButton"  
18. />  
20. <Button  
21. android:id="@+id/updateDatabase"  
22. android:layout_width="fill_parent"  
23. android:layout_height="wrap_content"  
24. android:text="@string/updateDatabaseButton"  
25. />  
27. <Button  
28. android:id="@+id/insert"  
29. android:layout_width="fill_parent"  
30. android:layout_height="wrap_content"  
31. android:text="@string/insertButton"  
32. />  
34. <Button  
35. android:id="@+id/update"  
36. android:layout_width="fill_parent"  
37. android:layout_height="wrap_content"  
38. android:text="@string/updateButton"  
39. />  
41. <Button  
42. android:id="@+id/select"  
43. android:layout_width="fill_parent"  
44. android:layout_height="wrap_content"  
45. android:text="@string/selectButton"  
46. />  
48. <Button  
49. android:id="@+id/delete"  
50. android:layout_width="fill_parent"  
51. android:layout_height="wrap_content"  
52. android:text="@string/deleteButton"  
53. />  
54. </LinearLayout>  

String文件： 

Xml代码  

1. <?xml version="1.0" encoding="utf-8"?>  
2. <resources>  
3. <string name="hello">Hello World, SQLiteActivity!</string>  
4. <string name="app_name">SQLiteTest</string>  
5. <string name="createDatabaseButton">createDatabase</string>  
6. <string name="updateDatabaseButton">updateDatabase</string>  
7. <string name="insertButton">insert</string>  
8. <string name="updateButton">update</string>  
9. <string name="selectButton">select</string>  
10. <string name="deleteButton">delete</string>  
11. </resources>