Android操作SQLite数据库

原创 2017年06月18日 18:35:31

文章背景
程序猿或是程序媛们在开发Android项目的时候,难免需要在客户端数据本地持久化,那么Android中数据本地存储有四种,分别是SharedPreferences、文件存储、SQLite存储数据、ContentProvider存储数据。其中SQLite它以表的形式存放数据,这种使用表的结构、对于程序员意味着不仅方便存储各类复杂而且庞大的数据,而且还方便管理数据。
其实Android手机里面的短信数据也是使用SQLite的方式存储的在/data/data/com.android.providers.telephony/databases/mmssms.db位置可以拿到,不过需要root。既然系统中都这么设计了,那我们也很有必要好好研究一下SQLite,不说精通,也要会熟练使用吧。

文章目标
实现SQLite数据库建库建表
实现SQLite增删改查操作
提供一个数据库操作工具给大伙。

SQLite简单介绍
SQLite是一款轻量型的数据库,支持 SQL 语言,操作起来及其方便类似于Sqlserver、mysql,相对于它们处理速度更快,具有跨平台、可移植性,同一套SQLite数据库不仅可以用在Android应用中,而且适用于iOS等一切嵌入式设备中。

不以Demo角度去演示、是以项目中实战的角度来演示SQLite的使用。
演示架构图
架构图

演示效果

效果图

OpenHelper
OpenHelper继承自SQLiteOpenHelper,OpenHelper作为一个访问SQLite的助手类,提供两个方面的功能,
第一,getReadableDatabase(),getWritableDatabase()可以获得SQLiteDatabse对象,通过该对象可以对数据库进行操作
第二,提供了onCreate()和onUpgrade()两个回调函数,允许我们在创建和升级数据库时,进行自己的操作

package com.example.yangdechengapplication.data;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

/**
 * ydc 20170616
 */
public class OpenHelper extends SQLiteOpenHelper {

    public OpenHelper(Context context, String dbname, CursorFactory factory, int version) {
        super(context, dbname, factory, version);
    }
//该函数是在第一次创建数据库的时候执行,实际上是在第一次得到SQLiteDatabse对象的时候,才会调用这个方法
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(DBHelperService.getInstance().getCreateCustomerTableSQL());
        Log.d("mydebug", "OpenHelper创建数据库");
    }

    //当数据库需要升级的时候,Android系统会主动的调用这个方法
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

}

BaseDBHelper
SQLite中SQLiteDatabase代表一个数据库对象,提供了操作数据库的一些方法。我把SQLiteDatabase获取操作以及该类的数据库增删改查操作都置于该类中,BaseDBHelper是SQLiteDatabase各种操作的包装类,在本案例中该类属于核心类。

package com.example.yangdechengapplication.data;

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

public class BaseDBHelper {
    private static BaseDBHelper instance = new BaseDBHelper();
    public static BaseDBHelper getInstance(){
        return instance;
    }

    private String TAG = "BaseDBHelper";

    private String DB_NAME = "mydata";
    //private String DB_NAME = "xd";
    private int DB_VERSION = 1; 
    private Context context;
    private OpenHelper openHelper;

    public void init(Context context) {
        this.context = context;
    }

    public void destroy() {
        context = null;
        instance = null;
    }

    public SQLiteDatabase getDBHelper() {
        synchronized (this) {
            if (openHelper == null) {
                openConnection(DB_NAME);
            }
            return openHelper.getWritableDatabase();
        }
    }

    /**
     * 建立连接
     * @param dbName
     */
    private void openConnection(String dbName) {
        try {
            openHelper = new OpenHelper(context, dbName, null, DB_VERSION);
        } catch (Exception e) {
        }
    }

    /**
     * 关闭数据库
     */
    public void closeDatabase() {
        if (openHelper != null) {
            openHelper.close();
            openHelper = null;
        }
    }

    /**
     * 数据库是否存在
     * @param tableName
     * @return
     */
    public boolean isExistDB(String tableName) {
        //ZWLog.i(TAG, "isExistDB");
        return existTable(getDBHelper(), tableName);
    }

    /**
     * 数据库是否存在
     * @param db
     * @param tableName
     * @return
     */
    private boolean existTable(SQLiteDatabase db, String tableName) {
        StringBuilder builder = new StringBuilder("select 1 from sqlite_master where type='table' and name='");
        builder.append(tableName).append("';");
        Cursor cur = null;
        try {
            cur = db.rawQuery(builder.toString(), null);
            if (cur.moveToNext()) {
                return true;
            } else {
                return false;
            }
        } finally {
            if (cur != null) {
                cur.close();
            }
        }
    }

    /**
     * 执行sql语句
     * 
     * @param sql
     */
    public void execSQL(String sql) {
        try {
            getDBHelper().execSQL(sql);
        } catch (Exception e) {
        }
    }

    /**
     * rawQuery
     * @param sql
     * @param selectionArgs
     * @return
     */
    public synchronized Cursor rawQuery(String sql, String[] selectionArgs){
        return getDBHelper().rawQuery(sql, selectionArgs);
    }

    /**
     * 数据库查询
     * 
     * @param table
     * @param columns
     * @param selection
     * @return
     */
    public synchronized Cursor query(String table, String[] columns, String selection, String orderBy) {
        return query(false, table, columns, selection, null, null, null, orderBy, null);
    }

    /**
     * query
     * @param table
     * @param columns
     * @param selection
     * @param selectionArgs
     * @param orderBy
     * @param limit
     * @return
     */
    public synchronized Cursor query(String table, String[] columns, String selection, String[] selectionArgs, String orderBy, String limit) {
        return query(false, table, columns, selection, selectionArgs, null, null, orderBy, limit);
    }

    /**
     * query
     * @param distinct
     * @param table
     * @param columns
     * @param selection
     * @param selectionArgs
     * @param groupBy
     * @param having
     * @param orderBy
     * @param limit
     * @return
     */
   public synchronized Cursor query(boolean distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit){
        if(columns == null){
            columns = new String[]{" * "};
        }
        return getDBHelper().query(distinct, table, columns, selection, selectionArgs, groupBy, having, orderBy, limit);
    }

    /**
     * 数据删除
     * 
     * @param tableName
     * @param whereClause
     */
    public int delete(String table) {
        return delete(table, null, null);
    }

    /**
     * 数据删除
     * 
     * @param tableName
     * @param whereClause
     * @param whereArgs
     * @return
     */
    public int delete(String table, String whereClause, String[] whereArgs) {
        return getDBHelper().delete(table, whereClause, whereArgs);
    }

    /**
     * insert
     * @param tableName
     * @param values
     * @return id 如果成功,否则返回-1.
     */
    public int insert(String table, ContentValues values) {
        return (int) getDBHelper().insert(table, "Null", values);
    }

    /**
     * update
     * @param table
     * @param values
     * @return
     */
    public int update(String table, ContentValues values) {
        return getDBHelper().update(table, values, null, null);
    }

    /**
     * update
     * @param table
     * @param values
     * @param whereClause
     * @return
     */
    public int update(String table, ContentValues values, String whereClause) {
        return getDBHelper().update(table, values, whereClause, null);
    }

    /**
     * update
     * @param table
     * @param values
     * @param whereClause
     * @param whereArgs
     * @return
     */
    public int update(String table, ContentValues values, String whereClause, String[] whereArgs) {
        return getDBHelper().update(table, values, whereClause, whereArgs);
    }

}

DBHelperService
封装了BaseDBHelper,这样便于日后项目数据源的可替换,同时也符合软件设计中的开放-封闭原则,Vive只需知道该类,只只需要操作该类即可。

/**
 * 
 */
package com.example.yangdechengapplication.data;

import android.content.ContentValues;
import android.database.Cursor;


/** 
 * @ClassName: DBHelperService 
 * @Description: 数据库操作服务类 
 * @author 杨德成
 * @date 2017年6月16日 下午2:46:30
 *  
 */
public class DBHelperService {
    public String TABLE_CUSTOMER="customer";

    private final static DBHelperService dbService = new DBHelperService();
    public static DBHelperService getInstance(){
        return dbService;
    }

    /**
     *
     * @Title: getCreateCustomerTableSQL()
     * @Description: 创建投资人信息表
     * @param @return    设定文件
     * @return String    返回类型
     * @throws
     */
    public String getCreateCustomerTableSQL(){
        StringBuilder sb = new StringBuilder();
        sb.append("create table if not exists ").append(TABLE_CUSTOMER).append("(");
        sb.append("ID").append(" integer primary key autoincrement, ");
        sb.append("customerid").append(" varchar(64), ");
        sb.append("name").append(" varchar(64), ");
        sb.append("pinyin").append(" varchar(64), ");
        sb.append("phone").append(" varchar(64), ");
        sb.append("sex").append(" varchar(64), ");
        sb.append("avatarUrl").append(" varchar(64) ");

        sb.append(");");
        return sb.toString();
    }

    /**
     * 
    * @Title: createDB 
    * @Description: 创建数据库
    * @param @return    设定文件 
    * @return boolean    返回类型 
    * @throws
     */
    public boolean createDB(){
        return BaseDBHelper.getInstance().isExistDB("");
    }


    /**
     * 
    * @Title: insert 
    * @Description: 插入数据 
    * @param @param table
    * @param @param values
    * @param @return    设定文件 
    * @return int    返回类型 
    * @throws
     */
     public int insert(String table, ContentValues values){
         return BaseDBHelper.getInstance().insert(table, values);
     }

    public int update(String table, ContentValues values,String customerid){
        return BaseDBHelper.getInstance().update(table,values,"customerid=?", new String[]{customerid});
    }

     /**
         * query
         * @param table
         * @param columns
         * @param selection
         * @param selectionArgs
         * @param orderBy
         * @param limit
         * @return
         */
     public  Cursor  query(String table, String[] columns, String selection, String[] selectionArgs, String orderBy, String limit){

         return BaseDBHelper.getInstance().query(table, columns, selection, selectionArgs,  orderBy,limit);

     }

     /**
      * 
     * @Title: query 
     * @Description: 去除重复数据
     * @param @param distinct
     * @param @param table
     * @param @param columns
     * @param @param selection
     * @param @param selectionArgs
     * @param @param groupBy
     * @param @param having
     * @param @param orderBy
     * @param @param limit
     * @param @return    设定文件 
     * @return Cursor    返回类型 
     * @throws
      */
     public  Cursor query(boolean distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit){

          return BaseDBHelper.getInstance().query(distinct,table,columns, selection,selectionArgs, groupBy,having,orderBy,limit);
      }

    /**
     * 根据sql语句查询数据
     * @param keyword
     * @return
     */
    public  Cursor rawQuery(String keyword){
        String selectStr= "select * from "+TABLE_CUSTOMER+ " where name like \"%" + keyword
                        + "%\" or pinyin like \"%" + keyword + "%\"";
        return BaseDBHelper.getInstance().rawQuery(selectStr,null);
    }

     /**
      * 
     * @Title: delete 
     * @Description: 数据删除
     * @param @param table
     * @param @param whereClause
     * @param @param whereArgs
     * @param @return    设定文件 
     * @return int    返回类型 
     * @throws
      */
     public int delete(String table, String whereClause, String[] whereArgs){
        return BaseDBHelper.getInstance().delete(table, whereClause, whereArgs);
     }


     /**
      * 
     * @Title: isExistDB 
     * @Description: TODO判断数据库是否存在
     * @param @return    设定文件 
     * @return boolean    返回类型 
     * @throws
      */
     public boolean isExistDB(){
         return BaseDBHelper.getInstance().isExistDB(TABLE_CUSTOMER);
     }
}

SqliteActivity

package com.example.yangdechengapplication;

import android.content.ContentValues;
import android.database.Cursor;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.example.yangdechengapplication.data.DBHelperService;

/**
 * Created by Administrator on 2017/6/18.
 */

public class SqliteActivity  extends AppCompatActivity {
    private Button delete;
    private Button insertButton;
    private Button updateButton;
    private Button queryButton;
    private TextView tv_info;

    private DBHelperService dbservice;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sqlite);
        dbservice=new DBHelperService();

        delete = (Button)findViewById(R.id.delete);
        updateButton = (Button)findViewById(R.id.update);
        insertButton = (Button)findViewById(R.id.insert);
        queryButton = (Button)findViewById(R.id.query);
        tv_info=(TextView)findViewById(R.id.tv_info);

        delete.setOnClickListener(new CreateListener());
        updateButton.setOnClickListener(new UpdateListener());
        insertButton.setOnClickListener(new InsertListener());
        queryButton.setOnClickListener(new QueryListener());


    }

    class InsertListener implements View.OnClickListener {

        @Override
        public void onClick(View v) {
            //生成ContentValues对象
            ContentValues values = new ContentValues();
            // 相对对象中插入键值对,其中键是列名,值是存入的值,该对象当中插入键值对,其中键是列名,值是希望插入到这一列的值,值必须和数据库当中的数据类型一致
            values.put("customerid", "1");
            values.put("name", "张三");
            values.put("pinyin","yang");
            values.put("phone", "08080808");
            values.put("sex", "男");
            values.put("avatarUrl", "");
            int k=dbservice.insert(dbservice.TABLE_CUSTOMER, values);
        }
    }
    //更新操作就相当于执行SQL语句当中的update语句
    //UPDATE table_name SET XXCOL=XXX WHERE XXCOL=XX...
    class UpdateListener implements View.OnClickListener {

        @Override
        public void onClick(View arg0) {
            ContentValues values = new ContentValues();
            values.put("name", "李四");
            //第一个参数是要更新的表名
            //第二个参数是一个ContentValeus对象
            //第三个参数是where子句
           dbservice.update(dbservice.TABLE_CUSTOMER,values,"1");
        }
    }

    class QueryListener implements View.OnClickListener {

        @Override
        public void onClick(View v) {
            Cursor cursor = dbservice.query(false,dbservice.TABLE_CUSTOMER, new String[] { "ID", "customerid","name", "pinyin","phone","sex","avatarUrl"},null,null,null,null, null, null);
            try{
                String infoStr="";
                while (cursor.moveToNext()) {
                    String customerid= cursor.getString(cursor.getColumnIndex("customerid"));
                    String name = cursor.getString(cursor.getColumnIndex("name"));
                    String pinyin = cursor.getString(cursor.getColumnIndex("pinyin"));
                    String phone = cursor.getString(cursor.getColumnIndex("phone"));
                    String sex= cursor.getString(cursor.getColumnIndex("sex"));
                    String avatarUrl= cursor.getString(cursor.getColumnIndex("avatarUrl"));
                    infoStr+="测试数据显示:"+name;
                    Log.d("CustomerInfo", "投资人姓名->"+name+" "+pinyin);
                }
                cursor.close();

                tv_info.setText(infoStr);

            }catch (Exception e){
                e.printStackTrace();

            }
        }
    }
    class CreateListener implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            try {
                boolean flag=dbservice.isExistDB();
                if(flag){
                    int q=dbservice.delete(dbservice.TABLE_CUSTOMER, null, null);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

注入Context

package com.example.yangdechengapplication;

import android.app.Application;

import com.example.yangdechengapplication.data.BaseDBHelper;
import com.example.yangdechengapplication.tools.CrashHandler;
import com.example.yangdechengapplication.tools.LogToFile;

/**
 * Created by Administrator on 2017/6/15.
 */

public class MyApplication extends Application {
    private final static float HEAP_UTILIZATION = 0.75f;
    private final static int MIN_HEAP_SIZE = 6* 1024* 1024 ;
    @Override
    public void onCreate() {
        super.onCreate();

        // 异常处理,不需要处理时注释掉这两句即可!
        CrashHandler crashHandler = CrashHandler.getInstance();
        // 注册crashHandler
        crashHandler.init(getApplicationContext());
        LogToFile.init(getApplicationContext());
        //ydc 20170616 初始化数据库
        BaseDBHelper.getInstance().init(getApplicationContext());
    }
}

数据库创建
SQLite的数据库的创建有两大种:
第一种:
使用SQLiteOpenHelper的构造方法SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version)先创建一个SQLiteOpenHelper对象。参数解释:
参数1 上下文对象
参数2 数据库名称
参数3 CursorFactory 非必填
参数4 数据库版本号,用来升级数据库使用

    private String DB_NAME = "mydata";
    //private String DB_NAME = "xd";
    private int DB_VERSION = 1; 
    private Context context;
    private OpenHelper openHelper;

    public void init(Context context) {
        this.context = context;
    }

    public void destroy() {
        context = null;
        instance = null;
    }

    public SQLiteDatabase getDBHelper() {
        synchronized (this) {
            if (openHelper == null) {
                openConnection(DB_NAME);
            }
            return openHelper.getWritableDatabase();
        }
    }

    /**
     * 建立连接
     * @param dbName
     */
    private void openConnection(String dbName) {
        try {
            openHelper = new OpenHelper(context, dbName, null, DB_VERSION);
        } catch (Exception e) {
        }
    }

然后再调用SQLiteOpenHelper.getReadableDatabase()或者SQLiteOpenHelper.getWritableDatabase()完成数据库的创建工作:

//只有调用了DatabaseHelper对象的getReadableDatabase()方法,或者是getWritableDatabase()方法之后,才会创建,或打开一个数据库
            SQLiteDatabase db = dbHelper.getReadableDatabase();

第二种:
使用SQLiteDatabase的静态方法openOrCreateDatabase(String path,SQLiteDatabae.CursorFactory factory)打开或者创建一个数据库。它会自动去检测是否存在这个数据库,如果存在则打开,不存在则创建一个数据库;创建成功则返回一个SQLiteDatabase对象,否则抛出异常FileNotFoundException。
参数说明:
参数1 数据库创建的路径
参数2 一般设置为null就可以了

// 用户数据库文件的版本
    private static final int DB_VERSION = 3;
    // 数据库文件目标存放路径为系统默认位置,com.droid 是你的包名
    //private static String DB_PATH = "/data/data/com.droid/databases/";

    /*private static String DB_PATH = "/data/data/com.bravowhale.bank/databases/";*/
    private static String DB_PATH =
      android.os.Environment.getExternalStorageDirectory().getAbsolutePath() +
             "/data/data/";
    /*
     * //如果你想把数据库文件存放在SD卡的话 private static String DB_PATH =
     * android.os.Environment.getExternalStorageDirectory().getAbsolutePath() +
     * "/arthurcn/drivertest/packfiles/";
     */
    private static String DB_NAME = "mydata.db";

// 检查数据库是否有效
    private boolean checkDataBase() {
        SQLiteDatabase checkDB = null;
        String myPath = DB_PATH + DB_NAME;
        try {
            checkDB = SQLiteDatabase.openDatabase(myPath, null,
                    SQLiteDatabase.OPEN_READONLY);
        } catch (SQLiteException e) {
            // database does't exist yet.
        }
        if (checkDB != null) {
            checkDB.close();
        }
        return checkDB != null ? true : false;
    }


public void createDataBase() throws IOException {
        boolean dbExist = checkDataBase();
        if (dbExist) {
            // 数据库已存在,do nothing.
        } else {
            // 创建数据库
            try {
                File dir = new File(DB_PATH);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                File dbf = new File(DB_PATH + DB_NAME);
                if (dbf.exists()) {
                    dbf.delete();
                }
                SQLiteDatabase.openOrCreateDatabase(dbf, null);

            } catch (IOException e) {
                throw new Error("数据库创建失败");
            }
        }
    }

如果你的手机已Root,可以在data/data/你的包名下位置下面看到所创建的DB。
同时可以把数据库文件拷贝到你的PC中使用SQLiteStudio工具查看及操作该数据库。
SQLiteStudio

如果是模拟器运行的话,Android系统底层是linux构建的,所以我们可以使用adb shell命令来查看我们所创建的数据库,步骤如下:
adb shell
su
ls -l
cd data
ls -l
cd data
ls -l
cd 你的包名
ls -l
cd databases
ls -l

adb01

adb02

adb03

adb04

adb05

adb06

SQLite建表
1.编写创建表的SQL语句
2.调用SQLiteDatabase的execSQL()方法来执行SQL语句
3.把建表的操作放在SQLiteOpenHelper中的onCreate(SQLiteDatabase db)方法中

/**
 * ydc 20170616
 */
public class OpenHelper extends SQLiteOpenHelper {

    public OpenHelper(Context context, String dbname, CursorFactory factory, int version) {
        super(context, dbname, factory, version);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(DBHelperService.getInstance().getCreateCustomerTableSQL());//建表

    }

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

    }

}


/**
     *
     * @Title: getCreateCustomerTableSQL()
     * @Description: 创建投资人信息表
     * @param @return    设定文件
     * @return String    返回类型
     * @throws
     */
    public String getCreateCustomerTableSQL(){
        StringBuilder sb = new StringBuilder();
        sb.append("create table if not exists ").append(TABLE_CUSTOMER).append("(");
        sb.append("ID").append(" integer primary key autoincrement, ");
        sb.append("customerid").append(" varchar(64), ");
        sb.append("name").append(" varchar(64), ");
        sb.append("pinyin").append(" varchar(64), ");
        sb.append("phone").append(" varchar(64), ");
        sb.append("sex").append(" varchar(64), ");
        sb.append("avatarUrl").append(" varchar(64) ");

        sb.append(");");
        return sb.toString();
    }

插入数据:
SQLite的数据插入其实有两种:
第一种:
insert
图中参数解释如下:
参数1 表名称;
参数2 空列的默认值;
参数3 ContentValues类型的一个封装了列名称和列值的Map。
该方法如果插入成功会返回一个>0的值,该值每次都会递增1。

 ContentValues values = new ContentValues();
            // 相对对象中插入键值对,其中键是列名,值是存入的值,该对象当中插入键值对,其中键是列名,值是希望插入到这一列的值,值必须和数据库当中的数据类型一致
            values.put("customerid", "1");
            values.put("name", "张三");
            values.put("pinyin","yang");
            values.put("phone", "08080808");
            values.put("sex", "男");
            values.put("avatarUrl", "");
            int k=dbservice.insert(dbservice.TABLE_CUSTOMER, values);//dbservice是我的包装类

第二种:
insert2
编写插入数据的SQL语句,直接调用SQLiteDatabase的execSQL()方法来执行即可

String sql="insert into "+ dbservice.TABLE_CUSTOMER+"(customerid,name,pinyin,phone,sex,avatarUrl) values('10','王麻子','yang','0909800999','女','baidu')";
            dbservice.insertByExecSQL(sql);// dbservice是我的包装类

奇怪的是这个方法并没有返回是否插入成功与否的标识。本人也不明白为啥先调用该方法,再调用了executeSql方法,后者是有返回值的。

删除数据
SQLite的数据删除也有两种:
第一种:
delete
图中参数解释如下:
参数1 表名称
参数2 删除条件
参数3 删除条件值数组
该方法若删除成功会返回一个>0的标识。

int q=dbservice.delete(dbservice.TABLE_CUSTOMER, null, null);// dbservice是我的包装类

第二种:
编写插入数据的SQL语句,直接调用SQLiteDatabase的execSQL()方法来执行即可。

 String sql="delete from  "+dbservice.TABLE_CUSTOMER+"  where customerid = 10";
                    dbservice.execSQL(sql);// dbservice是我的包装类

数据修改
SQLite的数据修改也有两种:
第一种:
update
图中参数解释如下:
参数1 表名称
参数2 跟行列ContentValues类型的键值对Key-Value
参数3 更新条件(where字句)
参数4 更新条件数组
该方法若修改成功会返回一个>0的标识。

 ContentValues values = new ContentValues();
            values.put("name", "李四");
            //第一个参数是要更新的表名
            //第二个参数是一个ContentValeus对象
            //第三个参数是where子句
           dbservice.update(dbservice.TABLE_CUSTOMER,values,"1");// dbservice是我的包装类

第二种:
编写插入数据的SQL语句,直接调用SQLiteDatabase的execSQL()方法来执行即可。

 String sql="update  "+dbservice.TABLE_CUSTOMER+" set name='孙悟空' where customerid = 10";
            dbservice.execSQL(sql);// dbservice是我的包装类

数据查询
query
如图所示,在Android中查询数据是通过Cursor类来实现的,当我们使用SQLiteDatabase.query()方法时,会得到一个Cursor对象,Cursor指向的就是每一条数据。
各个参数的意义说明:

参数table:表名称

参数columns:列名称数组

参数selection:条件字句,相当于where

参数selectionArgs:条件字句,参数数组

参数groupBy:分组列

参数having:分组条件

参数orderBy:排序列

参数limit:分页查询限制

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

Cursor是一个游标接口,提供了遍历查询结果的方法,如移动指针方法move(),获得列值方法getString()等.

// dbservice是我的包装类
            Cursor cursor = dbservice.query(false,dbservice.TABLE_CUSTOMER, new String[] { "ID", "customerid","name", "pinyin","phone","sex","avatarUrl"},null,null,null,null, null, null);
            try{
                String infoStr="测试数据显示:";
                while (cursor.moveToNext()) {
                    String customerid= cursor.getString(cursor.getColumnIndex("customerid"));
                    String name = cursor.getString(cursor.getColumnIndex("name"));
                    String pinyin = cursor.getString(cursor.getColumnIndex("pinyin"));
                    String phone = cursor.getString(cursor.getColumnIndex("phone"));
                    String sex= cursor.getString(cursor.getColumnIndex("sex"));
                    String avatarUrl= cursor.getString(cursor.getColumnIndex("avatarUrl"));
                    infoStr+=name+";";
                    Log.d("CustomerInfo", "投资人姓名->"+name+" "+pinyin);
                }
                cursor.close();

                tv_info.setText(infoStr);

            }catch (Exception e){
                e.printStackTrace();

第三方数据库操作神器http://blog.csdn.net/xinanheishao/article/details/73730639

Demo下载地址:http://download.csdn.net/download/xinanheishao/9873896

如果对你有所帮助的话,赏我1元奶粉钱吧,多谢!

微信:

001

支付宝:

002

相关文章推荐

Android之SQLite数据库的使用方法

这篇博文是笔记,主要介绍SQLite数据库的使用方法,这里以一个建立黑名单数据库为例子     第一步,建立数据库    建立数据库需要先建立一张表,然后再根据这张表建立起数据库 package...

C++著名程序库的比较和学习经验(STL.Boost.GUI.XML.网络等等)

1、C++各大有名库的介绍——C++标准库 2、C++各大有名库的介绍——准标准库Boost 3、C++各大有名库的介绍——GUI 4、C++各大有名库的介绍——网络通信 5、C++各大有名库...
  • oldmtn
  • oldmtn
  • 2012年05月08日 12:59
  • 1412

自己来制作iso镜像用于安装OpenBSD

安装OpenBSD时,到最后安装阶段时(就是安装一些xxx.tgz之类的文件时),使用网络下载速度慢,其原因是默认的那些文件服务器基本都在国外。 连接时总是延迟特别大,导致安装的过程极为漫长,而且链接...

android SQLite使用SQLiteOpenHelper类对数据库进行操作

一、 SQLite介绍  SQLite是android内置的一个很小的关系型数据库。  SQLite的官网是http://www.sqlite.org/,可以去下载一些文档或相关信息。  博客中...
  • yuanbohx
  • yuanbohx
  • 2014年04月10日 22:53
  • 10682

android sqlite数据库操作

  • 2012年01月04日 19:43
  • 107KB
  • 下载

Android SQLite数据库操作Demo

  • 2014年05月07日 09:48
  • 1.63MB
  • 下载

android SQLite使用SQLiteOpenHelper类对数据库进行操作

一、 SQLite介绍  SQLite是android内置的一个很小的关系型数据库。  SQLite的官网是http://www.sqlite.org/,可以去下载一些文档或相关信息。  博客中...

Android数据库SQLite基本操作工程

  • 2015年12月10日 15:18
  • 1.38MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android操作SQLite数据库
举报原因:
原因补充:

(最多只允许输入30个字)