graceting

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
Android开发--数据存储之数据库操作

简介：

SQLite 的介绍：

SQLite数据库属于文本型的数据库，它是以文本的形式来保存的。Android提供了对 SQLite 数据库的完全支持，应用程序中的任何类都可以通过名称来访问任何的数据库，但是应用程序之外的就不能访问。建议创建一个新的数据库的方式就是创建一个子类继承 SQLiteOpenHelper 然后重写它的 onCreate() 方法，这样就可以在数据库中执行 SQLite的语法命令来创建表；

SQLiteOpenHelper 类的介绍：

是一个帮助类，作用是管理数据库的创建和版本的管理，可创建一个子类来实现 onCreate(SQLiteDatabase), onUpgrade(SQLiteDatabase, int, int) 方法， onOpen(SQLiteDatabase)可以选择是否要实现。这个类负责在数据库存在的情况下，打开数据库，如果它不存在则会创建数据库，并且在必要的时候更新它。事务也会被使用到，这样才能确保数据库总是在合理的状态。

ex:

public class DictionaryOpenHelper extends SQLiteOpenHelper {

    private static final int DATABASE_VERSION = 2;
    private static final String DICTIONARY_TABLE_NAME = "dictionary";
    private static final String DICTIONARY_TABLE_CREATE =
                "CREATE TABLE " + DICTIONARY_TABLE_NAME + " (" +
                KEY_WORD + " TEXT, " +
                KEY_DEFINITION + " TEXT);";

    DictionaryOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(DICTIONARY_TABLE_CREATE);
    }
}
SQLiteDatabase类的介绍:

主要是用来管理数据库，它有一些方法来完成创建，删除，执行SQL语句，还有执行其他相同数据库管理的任务。
查看相关方法，可以发现这个类里面的方法很多都是用来维护数据库的，类似查询等。
   查看这个 public void execSQL (String sql, Object[] bindArgs) 方法用来执行一个SQL语句,在这个方法说明中,Android建议我们使用以下这种方式来进行对数据库的增删改查的。
   insert(String, String, ContentValues)
   insertOrThrow(String, String, ContentValues)
   insertWithOnConflict(String, String, ContentValues, int)
同理还有其他操作数据库的操作，详情请参考api文档：file:///F:/Android/SDK/docs/reference/android/database/sqlite/SQLiteDatabase.html
另外，数据库也可以通过调用execSQL (String sql, Object[] bindArgs) 方法来执行SQL语句实现上述功能。

一：数据库的创建和更新(DDL)

1) DBOpenHelper.java 用来更新或者创建数据库使用

package com.android.sqlitedemo.db;

import android.content.Context;
import android.database.DatabaseErrorHandler;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase.CursorFactory;

public class DBOpenHelper extends SQLiteOpenHelper {

    /**
     * 查看SQLiteOpenHelper api文档的，它的构造方法
     * public SQLiteOpenHelper (Context context, String name, SQLiteDatabase.CursorFactory factory, int version)
     * 创建一个帮助类的对象来创建，打开，或者管理一个数据库，这个方法总是会快速的返回，
     * <span style="background-color: rgb(255, 255, 0);">这个数据库实际上是没有被创建或者打开的，直到getWritableDatabase() 或者 getReadableDatabase() 方法中的一个被调用时才会进行创建或者打开</span>
     * 参数：
     *   context ： 上下文对象，用来打开或者创建数据库
     *   name ： 数据库文件的名称，如果是创建内存中则为null ，
     *   factory ： 用来创建游标对象，默认的是为null
     *   version ： 数据库的版本号(以版本数字号1开始)，如果数据库比较旧，就会用 onUpgrade(SQLiteDatabase, int, int) 方法来更新数据库，
     *       why？？<span style="background-color: rgb(255, 255, 102);">如果数据库比较新，就使用 onDowngrade(SQLiteDatabase, int, int)  方法来 回退数据库</span>
     * 【注意】 : 我们声明完这个构造方法之后，包括初始化它的名称 和 版本之后，实际上它还是没有马上被创建起来的。
     */
    private static String name = "mydb.db"; //表示数据库的名称
    //private static int version = 1; //表示数据库的版本号
    private static int version = 2; //更新数据库的版本号，此时会执行 onUpgrade()方法
    public DBOpenHelper(Context context) {
        super(context, name, null, version);
        // TODO Auto-generated constructor stub
    }

    //当数据库创建的时候，是第一次被执行，完成对数据库的表的创建
    @Override
    public void onCreate(SQLiteDatabase db) {
        // TODO Auto-generated method stub
        //SQLite 数据创建支持的数据类型： <span style="background-color: rgb(255, 255, 0);">整型数据，字符串类型，日期类型，二进制的数据类型</span>
        //数据库这边有一个特点，就是SQLite数据库中文本类型没有过多的约束，也就是可以把布尔类型的数据存储到文本类型中，这样也是可以的
        String sql = "create table person(id integer primary key autoincrement,name varchar(64),address varchar(64))";
        db.execSQL(sql); //完成数据库的创建 
    }

    /**
     * onUpgrade() 方法是在什么时候被执行呢？
     * 查看API文档中 onUpgrade()介绍
     *   当数据库需要升级时调用这个方法[在开发过程中涉及到数据库的设计存在缺陷的时候进行升级，不会损坏原来的数据]，这种实现方式会使用方法来减少表，或者增加表，或者做版本更新的需求。
     * 在这里就可以执行 SQLite Alter语句了，你可以使用 ALTER TABLE 来增加新的列插入到一张表中，你可以使用 ALTER TABLE 语句来重命名列或者移除列，或者重命名旧的表。
     * 你也可以创建新的表然后将旧表的内容填充到新表中。
     *   此方法会将事务之内的事件一起执行，如果有异常抛出，任何改变都会自动回滚操作。
     *   参数：
     *     db ： 数据库
     *     oldVersion ： 旧版本数据库
     *     newVersion ： 新版本数据库
     * 【注意】：这里的删除等操作必须要保证新的版本必须要比旧版本的版本号要大才行。[即 Version 2.0 > Version 1.0 ] 所以这边我们不需要对其进行操作。
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // TODO Auto-generated method stub
        String sql = "alter table person add sex varchar(8)";
        db.execSQL(sql);
    }

}
2) MainActivity.java 主程序的实现

这地方可以使用一个简单的MyTest.java实现即可，对onCreate()函数进行单元测试，然后通过File Filter ->data ->data查看生成的mydb.db文件。

package com.android.sqlitedemo;

import com.android.sqlitedemo.db.DBOpenHelper;

import android.os.Bundle;
import android.app.Activity;
import android.content.Context;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initComponent();
        button.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                DBOpenHelper helper = new DBOpenHelper(MainActivity.this);
                <span style="background-color: rgb(255, 255, 102);">// 调用 getWritableDatabase()或者 getReadableDatabase()其中一个方法将数据库建立</span>
                helper.getWritableDatabase();
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }
    private void initComponent() {
        button = (Button) findViewById(R.id.button1);
    }

}
二：数据库的增删改操作（DML）
2.1:使用execSQL (String sql, Object[] bindArgs) 方法实现，主要代码如下：

1）PersonService.java 定义增删改查接口

package com.android.sqlitedemo.service;

import java.util.List;
import java.util.Map;


/**
 * 定义好增删改查接口，面向接口编程
 */
public interface PersonService {

    public boolean addPersion(Object[] params); 
    
    public boolean deletePerson(Object[] params);
    
    public boolean updatePerson(Object[] params);
    
    //使用 Map<String, String> 做一个封装，比如说查询数据库的时候返回的单条记录
    public Map<String, String> viewPerson(String[] selectionArgs);
    
    //使用 List<Map<String, String>> 做一个封装，比如说查询数据库的时候返回的多条记录
    public List<Map<String, String>> listPersonMaps(String[] selectionArgs);
}
2）PersonDao.java 实现增删改查功能
package com.android.sqlitedemo.dao;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import com.android.sqlitedemo.db.DBOpenHelper;
import com.android.sqlitedemo.service.PersonService;


/**
 * 数据库的访问工具类
 * 实现定义好的增删改查接口
 *
 */
public class PersonDao implements PersonService {

    //获得 helper对象用来操纵数据库
    private DBOpenHelper helper = null;
    public PersonDao(Context context) {
        helper = new DBOpenHelper(context);
    }

    /**
     * 下面四个方法实现对数据库的增删改查功能 
     */
    
    @Override
    public boolean addPersion(Object[] params) {
        boolean flag = false;
        SQLiteDatabase database = null;
        try {
            //这里面问好表示占位符，所以要需要传入所有的占位符的值,传入值有这个方法中的参数传递
            String sql = "insert into person(name,address,sex) values(?,?,?)";
            database = helper.getWritableDatabase(); //实现对数据库写的操作
            database.execSQL(sql, params);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(database != null) {
                database.close();
            }
        }
        return flag;
    }

    @Override
    public boolean deletePerson(Object[] params) {
        boolean flag = false;
        SQLiteDatabase database = null;
        try {
            String sql = "delete from person where id = ? ";
            database = helper.getWritableDatabase();
            database.execSQL(sql, params);
            flag = true;            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(database != null) {
                database.close();
            }
        }
        return flag;
    }

    @Override
    public boolean updatePerson(Object[] params) {
        boolean flag = false;
        SQLiteDatabase database = null;
        try {
            String sql = "update person set name = ?, address = ?, sex = ? where id = ? ";
            database = helper.getWritableDatabase();
            database.execSQL(sql, params);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(database != null) {
                database.close();
            }
        }
        return flag;
    }

    //根据Id号来查询，查询的每一行数据返回用 Map 集合来存储
    @Override
    public Map<String, String> viewPerson(String[] selectionArgs) {
        Map<String, String> map = new HashMap<String, String>();
        SQLiteDatabase database = null;
        try {
            String sql = "select * from person where id = ? ";
            database = helper.getReadableDatabase(); //查询读取数据，查询结果使用Map来存储
            //声明一个游标，这个是行查询的操作，支持原生SQL语句的查询
            Cursor cursor = database.rawQuery(sql, selectionArgs); //ID所在行查询           
            int colums = cursor.getColumnCount();//获得数据库的列的个数
            //cursor.moveToNext() 移动到下一条记录
            while(cursor.moveToNext()){
                for(int i = 0; i < colums; i++) {
                    String cols_name = cursor.getColumnName(i); //提取列的名称
                    String cols_value = cursor.getString(cursor.getColumnIndex(cols_name)); //根据列的名称提取列的值
                    //数据库中有写记录是允许有空值的,所以这边需要做一个处理
                    if(cols_value == null) {
                        cols_value = "";
                    }
                    map.put(cols_name, cols_value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(database != null){
                database.close();
            }
        }
        return map;
    }

    //多条记录 用 List<Map<String, String>> 来封装,每一行产生一个 Map集合来装载这一行的数据
    //这样就有多个Map值，然后放入List中.
    @Override
    public List<Map<String, String>> listPersonMaps(String[] selectionArgs) {
        List<Map<String, String>> list = new ArrayList<Map<String,String>>();
        SQLiteDatabase database = null;
        try {
            String sql = "select * from person "; //这个是查询表中所有的内容，所以就不需要传入的这个参数值了
            database = helper.getReadableDatabase();
            Cursor cursor = database.rawQuery(sql, selectionArgs);
            int colums = cursor.getColumnCount();
            while(cursor.moveToNext()) {
                Map<String, String> map = new HashMap<String, String>();
                for(int i = 0; i < colums; i++) {
                    String cols_name = cursor.getColumnName(i);
                    String cols_value = cursor.getString(cursor.getColumnIndex(cols_name));
                    if(cols_name == null) {
                        cols_value = "";  
                    }
                    map.put(cols_name, cols_value);
                }
                list.add(map);
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if(database != null){
                database.close();
            }
        }
        return list;
    }  
}
3）MainActivity.java 文件

package com.android.sqlitedemo;

import java.util.List;
import java.util.Map;

import com.android.sqlitedemo.dao.PersonDao;
import com.android.sqlitedemo.db.DBOpenHelper;
import com.android.sqlitedemo.service.PersonService;

import android.os.Bundle;
import android.app.Activity;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

    private Button button1;
    private Button button2;
    private Button button3;
    private Button button4;
    private Button button5;
    private Button button6;
    
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initComponent();
        button1.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                DBOpenHelper helper = new DBOpenHelper(MainActivity.this);
                //调用 getWritableDatabase()或者 getReadableDatabase()其中一个方法将数据库建立
                helper.getWritableDatabase();
            }
        });
        button2.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                PersonService service = new PersonDao(MainActivity.this);
                //Object[] params = {"张三","北京","男"};
                <span style="background-color: rgb(255, 255, 102);">Object[] params = {"李四","上海","男"};</span> //新增加一条记录
                boolean flag = service.addPersion(params);
                Log.i(TAG, "--->" + flag);
            }
        });
        button3.setOnClickListener(new OnClickListener() {           
            @Override
            public void onClick(View v) {
                PersonService service = new PersonDao(MainActivity.this);
                <span style="background-color: rgb(255, 255, 102);">Object[] params = {1};</span>
                //将ID为1的记录删除
                boolean flag = service.deletePerson(params);
                Log.i(TAG, "---->" + flag);
            }
        });
        button4.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                //将ID为3的这一条记录修改
                PersonService service = new PersonDao(MainActivity.this);
                <span style="background-color: rgb(255, 255, 102);">Object[] params = {"snowy", "厦门", "男", "3"};</span>
                boolean flag = service.updatePerson(params);
                Log.i(TAG, "--->" + flag);
            }
        });
        button5.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                //查询ID为3的单条记录
                PersonService service = new PersonDao(MainActivity.this);
                <span style="background-color: rgb(255, 255, 102);">String[] seleStrings = {"3"};</span>
                Map<String, String> map = service.viewPerson(seleStrings);
                Log.i(TAG, "------查询单条记录--> " + map.toString());
            }
        });
        button6.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                //查询多条记录，这里我们不需要传递参数，所以可以参数可以置为null
                PersonService service = new PersonDao(MainActivity.this);
                List<Map<String, String>> list = service.listPersonMaps(null);
                Log.i(TAG, "---查询所有记录--->> " + list.toString());
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }
    
    private void initComponent(){
        button1 = (Button)findViewById(R.id.button1);
        button2 = (Button)findViewById(R.id.button2);
        button3 = (Button)findViewById(R.id.button3);
        button4 = (Button)findViewById(R.id.button4);
        button5 = (Button)findViewById(R.id.button5);
        button6 = (Button)findViewById(R.id.button6);
    }

}
2.2：使用Android推荐操作数据库的方法实现
1）方法概要：

（1） 插入：
insert(String, String, ContentValues)
insertOrThrow(String, String, ContentValues)
insertWithOnConflict(String, String, ContentValues, int)

(2) 更新:
update(String, ContentValues, String, String[])
updateWithOnConflict(String, ContentValues, String, String[], int)

(3) 删除：
  • delete(String, String, String[]
API文档中介绍：
  •     public long insert (String table, String nullColumnHack, ContentValues values)
    插入一行数据到数据库中
参数：
table ： 需要插入行的表的名称
nullColumnHack ： 这个参数是可选的，可以为null, SQL 不允许插入一个至少一列都不命名的完全空的行。如果你提供的 values 是空的，而且没有已知的的列名，这就是一个空行，这是不能被插入的。如果设置非空，nullColumnHack 参数提供一个可为空的列的名称，当插入的 values 是空的时候，就将这个列名置为NULL，然后values值插入。
values ： 指定行对应的列的值，这个类型很类似Map，key表示列的名称，values表示列的值
返回值：
返回新插入的行的ID，如果存在错误默认返回 -1
[备注]第二个参数翻译的有些拘谨，我们可以这样理解
当在没有任何已知的列名的情况下，values参数为空的时候，insert是会失败的（数据库不允许插入一个空行），为了防止Insert()方法要求必须添加一条除了主键之外其它字段为Null值的记录，我们要在这里必须指定一个列名[因为values值是以ContentValues 的形式来存储的]，到时候如果发现将要插入的行为空行时，就会将你指定的这个列名的值设为null，然后再将values值向NULL列中插入。查看源代码，我们可以发现 Android 中操作数据库的方法底层也是通过构造SQL语句来实现的。

public int delete (String table, String whereClause, String[] whereArgs)
删除操作 
参数：
table ： 表示表名
whereClause ： 可选项，是可以通过 SQL语句中where语句来过滤条件删除的条目，如果是null 表示删除所有行
whereArgs ： 紧跟第二个参数，作为删除过滤条件的占位符，详情请看下面程序 PersonDao2 的 deletePerson() 方法的操作。
返回值：
如果是 0 表示未删除任何行，如果已经有删除行的操作 会得到 count > 0的数，表示删除的行数
public int update (String table, ContentValues values, String whereClause, String[] whereArgs)
更新操作

参数 ：
table ：表示表名
values :  Map 中指定列名用来更新新的值，如果是null 值则为修改为 NULL
whereClause ： 可选项，支持SQL中的更新语句，用来做条件过滤，如果设置null 则会更新所有行
whereArgs ： 紧跟第二个参数，作为更新过滤条件的占位符，详情请看下面程序 PersonDao2 的updatePerson () 方法的操作。
返回值：
返回所更新的数据库的行数

SQLiteDatabase 中的query()查询

   查询操作 query(),可以发现 SQLiteDatabase 中有大量的 query() 查询的重载方法，其实这边它不管怎么重载，都是遵循 SQL 语句来的这里我就剖析一个最为常见的查询方法，其他的读者自己查看文档说明.

public Cursor query (boolean distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit)
参数：
distinct :  判断是否返回的行是唯一值，如果想要返回唯一的行，则为true，否则为false。
table ：需要查询的表的名称。
columns ：需要返回的列，如果要返回所有列则置为null。
selection :过滤需要返回的行，格式遵从SQL中 SQL WHERE 语句(除了Where关键字以外).如果返回给定表的所有行，则置为Null。
selectionArgs ： 过滤条件的占位符，这里的值会代替过滤语句中 "?"。
groupBy ： 过滤条件对行进行分组，格式遵从SQL中 SQL GROUP BY 语句 (除了关键字GROUP BY之外)，如果不分组，置为Null。
having ： 对分组过滤条件的占位符操作。
orderBy ： 如何进行排序，遵从SQL中的SQL ORDER BY 语句, 如果是null表示使用默认的排序顺序。
limit ：是否对数据库进行分页的查询。
返回值：一个游标
2）代码实现
（1） PersonService2.java 定义操作数据库(增删改查)的接口

package com.android.sqlitedemo.service;

import android.content.ContentValues;

import java.util.List;
import java.util.Map;


/**
 * 定义好增删改查接口
 *
 */
public interface PersonService2 {

    public boolean addPersion(<span style="background-color: rgb(255, 255, 51);">ContentValues values</span>); 
    
    public boolean deletePerson(<span style="background-color: rgb(255, 255, 102);">String whereClause, String[] whereArgs</span>);
    
    public boolean updatePerson(<span style="background-color: rgb(255, 255, 51);">ContentValues values, String whereClause, String[] whereArgs</span>);
    
    //使用 Map<String, String> 做一个封装，比如说查询数据库的时候返回的单条记录
    public Map<String, String> viewPerson(String selection, String[] selectionArgs);
    
    //使用 List<Map<String, String>> 做一个封装，比如说查询数据库的时候返回的多条记录
    public List<Map<String, String>> listPersonMaps(String selection, String[] selectionArgs);
}
（2）PersonDao2.java 实现操作数据库的增删改查的功能
package com.android.sqlitedemo.dao;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import com.android.sqlitedemo.db.DBOpenHelper;
import com.android.sqlitedemo.service.PersonService2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PersonDao2 implements PersonService2 {

    private DBOpenHelper helper = null;

    public PersonDao2(Context context) {
        helper = new DBOpenHelper(context);
    }

    @Override
    public boolean addPersion(ContentValues values) {
        // TODO Auto-generated method stub
        boolean flag = false;
        SQLiteDatabase database = null;
        long id = -1;
        try {
            database = helper.getWritableDatabase();
            id = database.insert("person", null, values);
            flag = (id != -1 ? true : false);
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (database != null) {
                database.close();
            }
        }
        return flag;
    }

    @Override
    public boolean deletePerson(String whereClause, String[] whereArgs) {
        // TODO Auto-generated method stub
        boolean flag = false;
        SQLiteDatabase database = null;
        int count = 0;
        try {
            database = helper.getWritableDatabase();
            count = database.delete("person", whereClause, whereArgs);
            flag = (count > 0 ? true : false);
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (database != null) {
                database.close();
            }
        }
        return flag;
    }

    @Override
    public boolean updatePerson(ContentValues values, String whereClause, String[] whereArgs) {
        // TODO Auto-generated method stub
        boolean flag = false;
        SQLiteDatabase database = null;
        int count = 0; // 影响数据库的行数
        try {
            database = helper.getWritableDatabase();
            count = database.update("person", values, whereClause, whereArgs);
            flag = (count > 0 ? true : false);
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (database != null) {
                database.close();
            }
        }
        return flag;
    }

    // 查询单条记录
    @Override
    public Map<String, String> viewPerson(String selection, String[] selectionArgs) {
        // TODO Auto-generated method stub
        // select * from
        // * 表示 返回的列的名称(投影查询) from
        SQLiteDatabase database = null;
        Cursor cursor = null;
        Map<String, String> map = new HashMap<String, String>();
        try {
            database = helper.getReadableDatabase();
            cursor = database.query(true, "person", null, selection, selectionArgs, null,
                    null, null, null); //查询单条记录，记录是唯一的，所以第一个参数置为 true.
            int cols_len = cursor.getColumnCount(); // 获取游标个数，即查询所得的结果数目
            while (cursor.moveToNext()) {
                for (int i = 0; i < cols_len; i++) {
                    String cols_name = cursor.getColumnName(i);
                    String cols_values = cursor.getString(cursor.getColumnIndex(cols_name));
                    if (cols_values == null) {
                        cols_values = "";
                    }
                    map.put(cols_name, cols_values);
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            if (database != null) {
                database.close();
            }
        }
        return map;
    }

    // 查询多条记录
    @Override
    public List<Map<String, String>> listPersonMaps(String selection, String[] selectionArgs) {
        // TODO Auto-generated method stub
        SQLiteDatabase database = null;
        Cursor cursor = null;
        List<Map<String, String>> list = new ArrayList<Map<String,String>>();
        try {
            database = helper.getReadableDatabase();
            cursor = database.query(false, "person", null, selection, selectionArgs, null,
                    null, null, null); //查询所有记录，所以有重复的数据也要全部检出，所以第一参数置为false.
            int cols_len = cursor.getColumnCount();
            while (cursor.moveToNext()) {
                Map<String, String> map = new HashMap<String, String>();
                for (int i = 0; i < cols_len; i++) {
                    String cols_name = cursor.getColumnName(i);
                    String cols_values = cursor.getString(cursor.getColumnIndex(cols_name));
                    if (cols_values == null) {
                        cols_values = "";
                    }
                    map.put(cols_name, cols_values);
                }
                list.add(map);
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            if (database != null) {
                database.close();
            }
        }
        return list;
    }
}
(3)MainActivity.java 点击按钮触发操作数据的事件
package com.android.sqlitedemo;

import java.util.List;
import java.util.Map;

import com.android.sqlitedemo.dao.PersonDao2;
import com.android.sqlitedemo.db.DBOpenHelper;
import com.android.sqlitedemo.service.PersonService2;

import android.os.Bundle;
import android.app.Activity;
import android.content.ContentValues;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

    private Button button1;
    private Button button2;
    private Button button3;
    private Button button4;
    private Button button5;
    private Button button6;

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initComponent();
        button1.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                DBOpenHelper helper = new DBOpenHelper(MainActivity.this);
                // 调用 getWritableDatabase()或者 getReadableDatabase()其中一个方法将数据库建立
                helper.getWritableDatabase();
            }
        });
        button2.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                PersonService2 service2 = new PersonDao2(MainActivity.this);
                ContentValues values = new ContentValues();
                values.put("name", "AHuier");
                values.put("address", "XIAMEN");
                values.put("sex", "male");
                boolean flag = service2.addPersion(values);
                Log.i(TAG, "---- addPersion --->" + flag);
            }
        });
        button3.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                PersonService2 service2 = new PersonDao2(MainActivity.this);
                // 删除的SQL语句 ：delete from person where id = ?
                // 不包含 where 关键字
                boolean flag = service2.deletePerson(" id = ? ", new String[] {
                    "4"
                });
                Log.i(TAG, "---- deletePerson ---->" + flag);
            }
        });
        button4.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                PersonService2 service2 = new PersonDao2(MainActivity.this);
                ContentValues values = new ContentValues();
                values.put("name", "AHuier");
                values.put("address", "XIAMEN");
                values.put("sex", "female");
                boolean flag = service2.updatePerson(values, " id = ? ", new String[] {
                    "1"
                });
                Log.i(TAG, "---- updatePerson --->" + flag);
            }
        });
        button5.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                PersonService2 service2 = new PersonDao2(MainActivity.this);
                Map<String, String> map = service2.viewPerson(" id = ? ", new String[] { "2" });
                Log.i(TAG, "---- viewPerson --->" + map.toString());
            }
        });
        button6.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                PersonService2 service2 = new PersonDao2(MainActivity.this);
                // select * from person
                List<Map<String, String>> list = service2.listPersonMaps(null, null);
                Log.i(TAG, "---- viewPerson --->" + list.toString());
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    private void initComponent() {
        button1 = (Button) findViewById(R.id.button1);
        button2 = (Button) findViewById(R.id.button2);
        button3 = (Button) findViewById(R.id.button3);
        button4 = (Button) findViewById(R.id.button4);
        button5 = (Button) findViewById(R.id.button5);
        button6 = (Button) findViewById(R.id.button6);
    }

}


posted on 2015-01-10 17:29  IT-tingting  阅读(778)  评论(0)  编辑  收藏  举报