Android数据库操作
“云朵舒芙蕾”通过精心收集，向本站投稿了6篇Android数据库操作，下面是小编为大家整理后的Android数据库操作，供大家参考借鉴，希望可以帮助您。
篇1：Android数据库操作
SQLiteDatabase数据库操作
SQLiteDatabase 打开管理工具 SQLiteExpertSetup
创建数据库
自动创建数据库功能SQLiteOpenHelper .getReadableDatabase 或.getWriteableDatabase
创建DBOpenHelper extends SQLiteOpenHelper
{
public DBOpenHelper(Context context)
{
super(context,“itcast.db”,null,1); //数据库名称，版本号 默认保存目录 <包>/databases/
}
public void onCreate(SQLiteDatabase db) //是在数据库每一次被创建时调用的
{
//通过类SQLiteDatabase的实例来操作SQL语句
db.execSQL(“CREATE TABLE person(personid integer primary key autoincrement,name varchar(20))”);
}
public void onUpgrade(SQLiteDatabase db,int oldVersion,int newVersion)
{
//文件版本号发生变更时调用,如版本由1变为2
db.execSQL(“ALTER TABLE person ADD phone VARCHAR(12) NULL”);
}
}
Person表类
public class Person
{
private Integer id;
private String name;
private String phone;
public Integer getId()
{
return id;
}
public void setId(Integer id)
{
this.id=id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
public String getPhone()
{
return phone;
}
public void setPhone(String phone)
{
this.phone=phone;
}
public String toString()
{
return “Person [id=” +id+“ , name=”+ name +“, phone=”+phone+“]”;
}
}
业务PersonService
private DBOpenHelper dbOpenHelper;
public PersonService(Context context){
this.dbOpenHelper = new DBOpenHelper(context);
}
public class PersonService{
public void save(Person person)
{
SQLiteDatabase db=dbOpenHelper.getWriteableDatabase();
db.execSQL(“insert into person(name,phone) values (?,?)”, new Object[]{person.getName(),+person.getPhone()});
//db.close();
}
public void delete(Person person)
{
SQLiteDatabase db=dbOpenHelper.getWriteableDatabase();
db.execSQL(“delete from person where personid=?”, new Object[]{id});
}
public void update(Person person)
{
SQLiteDatabase db=dbOpenHelper.getWriteableDatabase();
db.execSQL(“update person set name=?,phone=? where personid=?”,new Object[]{person.getName(),person.getPhone(),person.getId()});
}
public void find(Person person)
{
SQLiteDatabase db=dbOpenHelper.getReadableDatabase();
Cursor cursor= db.rawQuery(“select * from person where personid=?”, new String[]{id.toString()}); //cursor用于对查询结果集进行随机访问
if(cursor.moveToFirst())
{
int personid=cursor.getInt(cursor.getColumnIndex(“personid”));
String name=cursor.getString(cursor.getColumnIndex(“name”));
String phone=cursor.getString(cursor.getColumnIndex(“phone”));
return new Person(personid,name,phone);
}
cursor.close();
return null;
}
/**
*分页获取记录
*@param offset 跳过前面多少条记录
*@param maxResult 每页获取多少条记录
*@return
**/
public List
getScrollData(int offset,int maxResult)
{
List
persons = new ArrayList
();
SQLiteDatabase db=dbOpenHelper.getReadableDatabase();
Cursor cursor= db.rawQuery(“select * from person order by personid asc limit ?,?”, new String[]{String.valueOf(offset),String.valueOf(maxResult)});
while(cursor.moveToNext()) //类似ResultSet.next()
{
int personid=cursor.getInt(cursor.getColumnIndex(“personid”));
String name=cursor.getString(cursor.getColumnIndex(“name”));
String phone=cursor.getString(cursor.getColumnIndex(“phone”));
person.add(new Person(personid,name,phone));
}
cursor.close();
return persons;
}
public long getCount()
{
SQLiteDatabase db=dbOpenHelper.getReadableDatabase();
Cursor cursor=db.rawQuery(“select count(*) from person”,null);
cursor.moveToFirst();
long result=cursor.getLong(0);
cursor.close();
return result;
}
}
测试类：
public class PersonServiceTest extends AndroidTestCase
{
private static final String TAG=“PersonServiceTest”;
public void testCreateDB() throws Exception
{
DBOpenHelper dbOpenHelper=new DBOpenHelper(getContext());
dbOpenHelper.getWriteableDatabase();
}
public void testSave() throws Exception
{
PersonService service = new PersonService(this.getContext());
for(int i=0;i<20;i++)
{
Person person =new Person(“zhangxx”+i,“132234324”+i);
service.save(person);
}
}
public void testDelete() throws Exception
{
PersonService service= new PersonService(this.getContext());
service.delete(21);
}
public void testUpdate() throws Exception
{
PersonService service= new PersonService(this.getContext());
Person person=service.find(1);
person.setName(“zhangxiaoxiao”);
service.update(person);
}
public void testFind() throws Exception
{
PersonService service= new PersonService(this.getContext());
Person person=service.find(1);
Log.i(TAG,person.toString());
}
public void testScrollData() throws Exception
{
PersonService service= new PersonService(this.getContext());
List
person=service.getScrollData(0,5);
for(Person person :persons)
{
Log.i(TAG,person.toString());
}
}
public void testCount() throws Exception
篇2：android数据库SQLite3操作
Android采用关系型数据库SQLite3，它是一个支持SQL轻量级的嵌入式数据库，在嵌入式操作系统上有很广泛的应用，WM采用的也是SQLite3关于过于、原理方面的东西在这篇文章里不会提到，但是如果你想能够快速的学会操作SQLite3，那这就是你要找的文章！
首先，我们看一下api，所有数据库相关的接口、类都在android.database和android.database.sqlite两个包下，虽然只有两个包，但是如果你英文不好或是太懒的话也要迷茫一段时间，其实，我们真正用的到的没有几个！
1、SQLiteOpenHelper（android.database.sqlite.SQLiteOpenHelper）
这是一个抽象类，关于抽象类我们都知道，如果要使用它，一定是继承它！
这个类的方法很少，有一个构造方法
SQLiteOpenHelper(android.content.Context context, java.lang.String name, android.database.sqlite.SQLiteDatabase. CursorFactory factory, int version);
参数不做过多的解释，CursorFactory一般直接传null就可以
public void onCreate(SQLiteDatabase db)
此方法在创建数据库是被调用，所以，应该把创建表的操作放到这个方法里面，一会儿在后面我们会再详细的说如何创建表
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
从方法名上我们就能知道这个方法是执行更新的，没错，当version改变是系统会调用这个方法，所以在这个方法里应该执行删除现有表，然后手动调用onCreate的操作
SQLiteDatabase getReadableDatabase()
获取可读的SQLiteDatabase对象
SQLiteDatabase getWritableDatabase()
获取可写的SQLiteDatabase对象
2、SQLiteDatabase（android.database.sqlite.SQLiteDatabase）
关于操作数据库的工作（增、删、查、改）都在这个类里
execSQL(sql)
执行SQL语句，用这个方法+SQL语句可以非常方便的执行增、删、查、改
除此之外，Android还提供了功过方法实现增、删、查、改
long insert(TABLE_NAME, null, contentValues)添加记录
int delete(TABLE_NAME, where, whereValue)删除记录
int update(TABLE_NAME, contentValues, where, whereValue) 更新记录
Cursor query(TABLE_NAME, null, null, null, null, null, null) 查询记录
除此之外，还有很多方法，如：beginTransaction()开始事务、endTransaction()结束事务...有兴趣的可以自己看api，这里就不多赘述了
3、Cursor（android.database.Cursor）
游标（接口），这个很熟悉了吧，Cursor里的方法非常多，常用的有：
boolean moveToPosition(position)将指针移动到某记录
getColumnIndex(Contacts.People.NAME)按列名获取id
int getCount()获取记录总数
boolean requery()重新查询
boolean isAfterLast()指针是否在末尾
boolean isBeforeFirst()时候是开始位置
boolean isFirst()是否是第一条记录
boolean isLast()是否是最后一条记录
boolean moveToFirst()、boolean moveToLast()、boolean moveToNext()同moveToPosition(position)
4、SimpleCursorAdapter（android.widget.SimpleCursorAdapter）
也许你会奇怪了，之前我还说过关于数据库的操作都在database和database.sqlite包下，为什么把一个Adapter放到这里，如果你用过Android的SQLite3，你一定会知道
，这是因为我们对数据库的操作会经常跟列表联系起来
经常有朋友会在这出错，但其实也很简单
SimpleCursorAdapter adapter = new SimpleCursorAdapter(
this,
R.layout.list,
myCursor,
new String[] {DB.TEXT1,DB. TEXT2},
new int[]{ R.id.listTextView1,R.id.listTextView2 });
myListView.setAdapter(adapter);
一共5个参数，具体如下：
参数1:Content
参数2:布局
参数3:Cursor游标对象
参数4:显示的字段，传入String[]
参数5:显示字段使用的组件，传入int[]，该数组中是TextView组件的id
到这里，关于数据库的操作就结束了，但是到目前为止我只做了翻译的工作，有些同学可能还是没有掌握，放心，下面我们一起顺着正常开发的思路理清一下头绪！
前面的只是帮没做过的朋友做下普及，下面才是你真正需要的！
一、写一个类继承SQLiteOpenHelpe
public class DatabaseHelper extends SQLiteOpenHelper
构造方法：
DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
在onCreate方法里写建表的操作
public void onCreate(SQLiteDatabase db) {
String sql = “CREATE TABLE tb_test (_id INTEGER DEFAULT '1' NOT NULL PRIMARY KEY AUTOINCREMENT,class_jb TEXT NOT NULL,class_ysbj TEXT NOT NULL,title TEXT NOT NULL,content_ysbj TEXT NOT NULL)”;
db.execSQL(sql);//需要异常捕获
}
在onUpgrade方法里删除现有表，然后手动调用onCtreate创建表
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
String sql = “drop table ”+tbname;
db.execSQL(sql);
onCreate(db);
}
定义对表增、删、查、改的方法，这里用的是SQLiteOpenHelper提供的方法，也可以用sql语句实现，都是一样的
关于获取可读/可写SQLiteDatabase，我不说大家也应该会想到，只有查找才会用到可读的SQLiteDatabase
/**
*添加数据
*/
public long insert(String tname, int tage, String ttel){
SQLiteDatabase db= getWritableDatabase();//获取可写SQLiteDatabase对象
//ContentValues类似map，存入的是键值对
ContentValues contentValues = new ContentValues();
contentValues.put(“tname”, tname);
contentValues.put(“tage”, tage);
contentValues.put(“ttel”, ttel);
return db.insert(tbname, null, contentValues);
}
/**
*删除记录
* @param _id
*/
public void delete(String _id){
SQLiteDatabase db= getWritableDatabase();
db.delete(tbname,
“_id=?”,
new String[]{_id});
}
/**
*更新记录的，跟插入的很像
*/
public void update(String _id,String tname, int tage, String ttel){
SQLiteDatabase db= getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(“tname”, tname);
contentValues.put(“tage”, tage);
contentValues.put(“ttel”, ttel);
db.update(tbname, contentValues, “_id=?”, new String[]{_id});
}
/**
*查询所有数据
* @return Cursor
*/
public Cursor select(){
SQLiteDatabase db = getReadableDatabase();
return db.query(
tbname,
new String[]{“_id”,“tname”,“tage”,“ttel”,“taddr”},
null,
null, null, null, “_id desc”);
}
关于db.query方法的参数，有很多，为了防止大家弄乱，我简单说一下
参数1：表名
参数2：返回数据包含的列信息，String数组里放的都是列名
参数3：相当于sql里的where，sql里where后写的内容放到这就行了，例如：tage>?
参数4：如果你在参数3里写了?（知道我为什么写tage>?了吧），那个这里就是代替?的值 接上例：new String[]{“30”}
参数5：分组，不解释了，不想分组就传null
参数6：having，想不起来的看看SQL
参数7：orderBy排序
到这里，你已经完成了代码最多的第一步！我们来看看都用到了那些类：
SQLiteOpenHelper我们继承使用的
SQLiteDatabase增删查改都离不开它，即使你直接用sql语句，也要用到execSQL(sql)
二、这里无非是对DatabaseHelper类定义方法的调用，没什么可说的，不过我还是对查询再唠叨几句吧
Android查询出来的结果一Cursor形式返回
cursor = sqLiteHelper.select();//是不是很简单？
查询出来的cursor一般会显示在listView中，这就要用到刚才提到的SimpleCursorAdapter
SimpleCursorAdapter adapter = new SimpleCursorAdapter(
this,
R.layout.list_row,
cursor,
new String[]{“tname”,“ttel”},
new int[]{R.id.TextView01,R.id.TextView02}
);
是不是很简单呢，任何复杂的工程都是通过简单的代码实现的.
篇3：Android上的事件流操作数据库
最近在浏览某篇有关事件流的文章时，里面提到了数据的流处理，兴趣来了，就想看看能否在Android端实现一个，
根据文章的介绍，将每次数据的变更事件，像是插入，删除或者更新等，记为一个不可变的事件，让数据在事件中流淌，而不是对数据库进行破坏性的写入，也就是说，直接读取数据的聚合结果就能获取最好的性能。
事件流可以完成下面的工作：
1.获取所有的原始事件，可能需要进行转换，然后将它们加载到一个大型的数据仓库中供分析人员使用；
2.更新全文搜索索引，使用户可以搜索最新的数据；
3.更新缓存，使系统可以从快速缓存中读取数据，并保证缓存中的数据是最新的；
4.通过对事件流进行处理创建一个新的事件流，然后将后者作为另一个系统的输入。
可能带来的好处如下：
1.松耦合：数据读写使用不同的数据库模式，读取的数据经由写入的数据转换而来，应用程序不同部分间的耦合度降低了；
2.读写性能：规范化（写入快）和非规范化（读取快）的争论源于数据读写使用同一个模式的假设，如果数据读写使用不同的数据库模式，读写速度都会得到提升；
3.扩展性：因为事件流是一种简单的抽象，而且允许开发人员将应用程序分解成流的生产者和消费者，所以容易跨机器并行和扩展；
4.灵活性：原始事件简单明确，模式迁移不会造成多大影响，而向用户展示数据要复杂得多，但如果有一个转换过程可以实现从原始事件到缓存内容的转换，那么当需要新的用户界面时，只需要使用新的逻辑构建新的缓存；
5.错误场景：原始事件是不变的事实，如果系统出现问题，那么开发人员总是可以用相同的顺序将事件重放。
如果是这样的设计， 编写查询或者规则来匹配满足特定模式的事件，还要在流上进行全文搜索，在流上事先注册一个查询，当有事件匹配查询时发送通知。
由此衍生出几个概念：
1.响应式：主要是将事件流提供给用户界面使用；
2.变更数据捕获：按照我们熟悉的方式使用数据库，但要将任何插入，更新和删除操作抽取到一个数据变更事件流中。
初步的实现已经出来了，大概的实现如下：
1.创建数据库和表
在assets文件夹下创建database.xml文件，里面配置数据库的名字，版本号和数据库的表：
<?xml version=“1.0” encoding=“utf-8”?>
然后初始化DatabaseCache：
DatabaseCache cache = DatabaseCache.getInstance(this);
该操作应该是在Application中声明，因为该动作涉及到数据库和表的创建。
2.基本使用
声明一个model类，继承自BaseTable:
@Table(table = “status”) public class Status extends BaseTable { @Column private String name; @Column private String statusId; public void setName(String name) { this.name = name; } public String getName { return name; } public void setStatusId(String id) { this.statusId = id; } public String getStatusId() { return statusId; } }
其中，@Table声明的是该model对应的表的名字，@Column声明的是该字段对应的数据库中的类型，
如果该字段的类型和数据库中的类型不一致，可以通过@ColumnType来指定类型。
3.数据插入
Status status = new Status();
status.setName(“转发”);
status.setStatusId(“01”);
InsertEvent insertStatusEvent = new InsertEvent();
insertStatusEvent.to(Status.class).insert(status);
4.数据更新
UpdateEvent updateEvent = new UpdateEvent();
updateEvent.to(Status.class).where(“id”, “01”).update(“name”, “你好”);
5.数据查询
List
这样就是查询Status表中的statusId为01的所有记录。当然，也可以查询所有数据：
List
6.数据读取
DatabaseCache cache = DatabaseCache.getInstance(this);
List
该操作应该在Application中执行，然后执行相应的数据插入：
for(Status status : statusList){
InsertEvent insertEvent = new InsertEvent();
insertEvent.to(Status.class).insert(status);
}
这样数据就会从数据库转移到事件流中。
7.数据存储
DatabaseCache cache = DatabaseCache.getInstance(this);
cache.insertToDb(Status.class);
这样就会将和Status有关的数据插入到数据库中。
8.数据删除
DeleteEvent deleteEvent = new DeleteEvent();
deleteEvent.to(Status.class).where(“id”, “01”).delete();
这样就是删除id为01的数据。
如果是删除某个集合的全部数据，则是:
List 如果是删除表的全部数据： deleteEvent.to(Status.class).deleteAll(); 这是目前的实现，后面会有时间讲解一下实现的过程，具体的项目地址放在github上：github.com/wenjiang/EventStreamDB，有兴趣可以上去看看，顺便给个星星。 android 数据库 总结 第一步：自己编写一个类 继承 SQLiteOpenHelper，如下 package com.example.wxj2048;import android.content.ContentValues;import android.content.Context;import android.database.Cursor;import android.database.sqlite.SQLiteDatabase;import android.database.sqlite.SQLiteOpenHelper;public class Dbdao extends SQLiteOpenHelper{ private static final String DBNAME = “mldn.db”; private static final int DBVERSION = 1; private static final String TABNAME = “game2048”; public Dbdao(Context context){ super(context, DBNAME, null, DBVERSION); } @Override public void onCreate(SQLiteDatabase db) { // TODO Auto-generated method stub String sql =“ CREATE TABLE ”+ TABNAME+“ (” + “ id INTEGER ,” + “ score INTEGER ”+ “) ”; db.execSQL(sql); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // TODO Auto-generated method stub String sql = “ DROP TABLE IF EXISTS ” + TABNAME; db.execSQL(sql); this.onCreate(db); } public void insert(Integer score){ SQLiteDatabase db = getWritableDatabase(); ContentValues values = new ContentValues(); values.put(“id”, 1); values.put(“score”, score); db.insert(TABNAME, null, values); db.close(); } public void delete(){ SQLiteDatabase db = getWritableDatabase(); String[] data = new String[1]; data[0] = “1”; db.delete(TABNAME,“id = ?”,data); db.close(); } public Integer query(){ SQLiteDatabase db = getWritableDatabase(); Cursor c = db.query(TABNAME, null, null, null, null, null, null); c.moveToFirst(); int index = c.getColumnIndex(“score”); String result = c.getString(index); db.close(); return Integer.valueOf(result); }} 第二步；就可以创建 Dbdao 对象，然后使用数据库 我们总结一下 Cursor 的重要方法 close() 关闭游标，释放资源 getColumnCount() 返回所有列的总数 getColumnIndex(String columnName) 返回指定列的名称，如果不存在返回-1 getColumnName(int columnIndex) 从给定的索引返回列名 getColumnNames() 返回一个字符串数组的列名 getCount() 返回Cursor 中的行数 moveToFirst() 移动光标到第一行 moveToLast() 移动光标到最后一行 moveToNext() 移动光标到下一行 访问 Cursor 的下标获得其中的数据 int nameColumnIndex = cur.getColumnIndex(People.NAME); String name = cur.getString(nameColumnIndex); ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 /** * YDL_Hibernate概要 * (一)支持功能: 1.自动建表,支持属性来自继承类:可根据注解自动完成建表,并且对于继承类中的注解字段也支持自动建表. 2.自动支持增删改 * ,增改支持对象化操作:增删改是数据库操作的最基本单元,不用重复写这些增删改的代码,并且添加和更新支持类似于hibernate中的对象化操作. * 3.查询方式灵活:支持android框架提供的方式,也支持原生sql方式. * 4.查询结果对象化:对于查询结果可自动包装为实体对象,类似于hibernate框架. * 5.查询结果灵活:查询结果支持对象化,也支持结果为List * 6.日志较详细:因为android开发不支持热部署调试,运行报错时可根据日志来定位错误,这样可以减少运行Android的次数. * (二)不足之处: * 1.id暂时只支持int类型,不支持uuid,在sqlite中不建议用uuid. * 2.现在每个方法都自己开启和关闭事务,暂时还不支持在一个事务中做多个操作然后统一提交事务. * (三)作者寄语: * 昔日有JavaScript借Java发展,今日也希望YDL_Hibernate借Hibernate之名发展. * 希望这个项目以后会成为开源社区的重要一员,更希望这个项目能给所有Android开发者带便利. * 欢迎访问我的博客:blog.csdn.net/linglongxin24, * 这里有这个框架的使用范例和源码,希望朋友们多多交流完善这个框架,共同推动中国开源事业的发展,YDL_Hibernate期待与您共创美好未来!!! */ public class MainActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // 熟悉用接口的朋友注意哦,这里也可以定义为接口哦,见StudentDaoImpl.java中的注释. TeacherDaoImpl teacherDao = new TeacherDaoImpl(MainActivity.this); StudentDaoImpl studentDao = new StudentDaoImpl(MainActivity.this); // 添加 Teacher teacher = new Teacher; teacher.setName(“米老师”); teacher.setAge(50); teacher.setTitle(“教授”); Long teacherId = teacherDao.insert(teacher); Student student1 = new Student(); student1.setName(“lk”); student1.setAge(26); student1.setClasses(“五”); student1.setTeacherId(teacherId.intValue()); Long studentId1 = studentDao.insert(student1); Student student2 = new Student(); student2.setName(“cls”); student2.setAge(26); student2.setClasses(“五”); student2.setTeacherId(teacherId.intValue()); Long studentId2 = studentDao.insert(student2); Student student3 = new Student(); student3.setName(“lb”); student3.setAge(27); student3.setClasses(“五期”); student3.setTeacherId(teacherId.intValue()); Long studentId3 = studentDao.insert(student3); // 查询 // 方式1:根据Id查询单个对象 // 结果:student1Student [id=1, name=lk,age=26,teacherId=1, classes=五] Student student4 = studentDao.get(studentId1.intValue()); System.out.println(“student4” + student4); // 方式2:查询出表中的所有记录 // 执行结果如下: // list1:Student [id=1, name=lk,age=26,teacherId=1, classes=五] // list1:Student [id=2, name=cls,age=26,teacherId=1, classes=五] // list1:Student [id=3, name=lb,age=27,teacherId=1, classes=五期] List for (Student student : list1) { System.out.println(“list1:” + student); } // 方式3:限制条件查询和查询结果 // 执行结果:list2:Student [id=2, name=cls,age=0,teacherId=0, classes=null] List “ id = ? ”, new String[] { studentId2.toString() }, null, null, null, null); for (Student student : list2) { System.out.println(“list2:” + student); } // 方式4:使用sql查询出结果,此种方式是2,3,4中最灵活的. // 执行结果: // list3:Student [id=2, name=cls,age=26,teacherId=1, classes=五] // list3:Student [id=3, name=lb,age=27,teacherId=1, classes=五期] List “select * from t_student where id in (?,?) ”, new String[] { studentId2.toString(), studentId3.toString() }); for (Student student : list3) { System.out.println(“list3:” + student); } // 方式4进阶:如果想查询出米老师的学生,可以这样实现: // 执行结果: // list4:Student [id=1, name=lk,age=26,teacherId=1, classes=五] // list4:Student [id=2, name=cls,age=26,teacherId=1, classes=五] // list4:Student [id=3, name=lb,age=27,teacherId=1, classes=五期] List .rawQuery( “select s.* from t_student s join t_teacher t on s.teacher_id = t.id where t.name= ? ”, new String[] { “米老师” }); for (Student student : list4) { System.out.println(“list4:” + student); } // 方式5:我只想知道姓名和年龄,查询得到List // 结果: // listMap1: name:lk;age:26 // listMap1: name:cls;age:26 // listMap1: name:lb;age:27 List “select name,Age from t_student ”, null); for (Map // 查询的List中的map以查询sql中的属性值的小写形式为key,注意是小写形式哦. System.out.println(“listMap1: name:” + map.get(“name”) + “;age:” + map.get(“age”)); } // 方式5进阶:我想知道前2名学生的姓名和班主任姓名,这种方式是不是超灵活啊,用其他的方式查询都没这种方式好用吧,哈哈. // 结果: // listMap2: student_name:lk;teacher_name:米老师 // listMap2: student_name:cls;teacher_name:米老师 List .query2MapList( “select s.name sname,t.name tname from t_student s join t_teacher t on s.teacher_id = t.id limit ? ”, new String[] { “2” }); for (Map System.out.println(“listMap2: student_name:” + map.get(“sname”) + “;teacher_name:” + map.get(“tname”)); } // 更新 // 结果: Student [id=1, name=李坤,age=26,teacherId=1, classes=五期] student1 = studentDao.get(studentId1.intValue()); student1.setName(“李坤”); student1.setClasses(“五期”); studentDao.update(student3); System.out.println(student1); // 删除:支持单个id删除,也支持多个id同时删除哦. studentDao.delete(studentId1.intValue()); studentDao.delete(new Integer[] { studentId2.intValue(), studentId3.intValue() }); // 支持执行sql语句哦. teacherDao.execSql(“insert into t_teacher(name,age) values('米教授',50)”, null); } } public class MySQLiteHelper extends SQLiteOpenHelper {public static final String SQL_CREATE= “create table news (” + “_id integer primary key autoincrement, ” + “nametext, ” + “agetext, )”; public MySQLiteHelper(Context context, String name, CursorFactory factory, int version) { super(context, name, factory, version);} @Overridepublic void onCreate(SQLiteDatabase db) { db.execSQL(SQL_CREATE); } @Overridepublic void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {} } 当我们如上创建了个SQLiteHelper，我们知道会在本地的目录database中生成了个.db数据库文件！ 可是我们遇到版本迭代往往要做更多的事情 这时候的会再创建个新的数据库 这时候我们编译完成之后发现没有在database相对应的目录下生成一个相对应的表， Android中数据库升级篇4：android 数据库 总结
篇5：Android数据库hibernate框架
用法
篇6：Android中数据库升级
@Override“ int=”int“ name=”code“ newversion=”newVersion)“ oldversion=”oldVersion,“ oncreatedb=”onCreate(db);“ onupgradesqlitedatabase=”onUpgrade(SQLiteDatabase“ pre=”pre“ public=”public“ void=”void">主要思路就是更新version，就是说你用户现有装的app上version是1的时候，在迭代版本更新的时候要更新version为>1的值 这样我们在new MySQLiteHelper() 的时候就会执行onUpgrade()方法，然后在在该方法中写入相对应的操作就会在database下生产相对应的表而不需要用户去清除应用的数据。
当然这种方法有一个很严重的弊端就是 可能我们在发布版本的时候忘记修改该version导致无法操作数据引起一系列不可收拾的bug。 所以推荐使用LitePal开源库进行对数据库操作！详情可见 点击打开链接
【Android数据库操作】相关文章：
5.操作计划
10.化工操作工作总结
文档为doc格式
