Android操作SQLite資料庫
阿新 • • 發佈：2019-02-19
文章背景
程式猿或是程式媛們在開發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 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
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的資料插入其實有兩種:
第一種：
圖中引數解釋如下：
引數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是我的包裝類第二種：
編寫插入資料的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的資料刪除也有兩種:
第一種：
圖中引數解釋如下：
引數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的資料修改也有兩種:
第一種：
圖中引數解釋如下：
引數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是我的包裝類資料查詢
如圖所示，在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();
如果對你有所幫助的話，賞我1元奶粉錢吧,多謝！
微信:
支付寶:
