Android操作SQLite数据库

最新推荐文章于 2024-03-19 10:49:53 发布

西南黑少

最新推荐文章于 2024-03-19 10:49:53 发布

阅读量3.3k

点赞数 4

分类专栏： android 文章标签：数据库 android sqlite 存储

本文链接：https://blog.csdn.net/XiNanHeiShao/article/details/73436291

版权

android 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章背景
程序猿或是程序媛们在开发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工具查看及操作该数据库。

如果是模拟器运行的话，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

西南黑少

关注

4
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Android操作SQLite数据库

文章背景程序猿或是程序媛们在开发Android项目的时候，难免需要在客户端数据本地持久化，那么Android中数据本地存储有四种，分别是SharedPreferences、文件存储、SQLite存储数据、ContentProvider存储数据。其中SQLite它以表的形式存放数据，这种使用表的结构、对于程序员意味着不仅方便存储各类复杂而且庞大的数据，而且还方便管理数据。
复制链接

扫一扫