Android中常用的五種資料儲存方式
第一種： 使用SharedPreferences儲存資料
適用範圍：
儲存少量的資料，且這些資料的格式非常簡單：字串型、基本型別的值。比如應用程式的各種配置資訊（如是否開啟音效、是否使用震動效果、小遊戲的玩家積分等），解鎖口 令密碼等
核心原理：
儲存基於XML檔案儲存的key-value鍵值對資料，通常用來儲存一些簡單的配置資訊。通過DDMS的File Explorer面板，展開檔案瀏覽樹,很明顯SharedPreferences資料總是儲存在/data/data//shared_prefs目錄下。SharedPreferences物件本身只能獲取資料而不支援儲存和修改,儲存修改是通過SharedPreferences.edit()獲取的內部介面Editor物件實現。 SharedPreferences本身是一 個介面，程式無法直接建立SharedPreferences例項，只能通過Context提供的getSharedPreferences(String name, int mode)方法來獲取SharedPreferences例項，該方法中name表示要操作的xml檔名，第二個引數具體如下：
Context.MODE_PRIVATE
Context.MODE_WORLD_READABLE: 指定該SharedPreferences資料能被其他應用程式讀，但不能寫。
Context.MODE_WORLD_WRITEABLE: 指定該SharedPreferences資料能被其他應用程式讀，寫
Editor有如下主要重要方法：
1.SharedPreferences.Editor clear():清空SharedPreferences裡所有資料
2.SharedPreferences.Editor putXxx(String key , xxx value): 向 SharedPreferences存入指定key對應的資料，其中xxx 可以是boolean,float,int等各種基本型別據
3.SharedPreferences.Editor remove(): 刪除SharedPreferences中指定key對應的資料項
4.boolean commit(): 當Editor編輯完成後，使用該方法提交修改
實際案例：執行介面如下
這裡只提供了兩個按鈕和一個輸入文字框，佈局簡單，故在此不給出介面佈局檔案了,程式核心程式碼如下：
class ViewOcl implements View.OnClickListener{
@Override
public void onClick(View v) {
switch(v.getId()){
case R.id.btnSet://步驟1：獲取輸入值
String code = txtCode.getText().toString().trim();
//步驟2-1：建立一個SharedPreferences.Editor介面物件，lock表示要寫入的XML檔名，MODE_WORLD_WRITEABLE寫操作 第二種： 檔案儲存資料
核心原理:
Context提供了兩個方法來開啟資料檔案裡的檔案IO流 FileInputStream openFileInput(String name); FileOutputStream(String name , int mode),這兩個方法第一個引數 用於指定檔名，第二個引數指定開啟檔案的模式。具體有以下值可選：
MODE_PRIVATE：
為預設操作模式，代表該檔案是私有資料，只能被應用本身訪問，在該模式下，寫入的內容會覆蓋原檔案的內容，如果想把新寫入的內容追加到原檔案中。可 以使用Context.MODE_APPEND
MODE_APPEND：
模式會檢查檔案是否存在，存在就往檔案追加內容，否則就建立新檔案。
表示當前檔案可以被其他應用讀取；
MODE_WORLD_WRITEABLE：
表示當前檔案可以被其他應用寫入。
除此之外，Context還提供瞭如下幾個重要的方法：
getDir(String name , int mode):在應用程式的資料資料夾下獲取或者建立name對應的子目錄
File getFilesDir():獲取該應用程式的資料資料夾得絕對路徑
String[] fileList():返回該應用資料資料夾的全部檔案
實際案例：介面沿用上圖
核心程式碼如下：
public String read() {
try {
FileInputStream inStream = this.openFileInput("message.txt");
byte[] buffer = new byte[1024];
int hasRead = 0;
StringBuilder sb = new StringBuilder();
while ((hasRead = inStream.read(buffer)) != -1) {
sb.append(new String(buffer, 0, hasRead));
}
inStream.close();
return sb.toString();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public void write(String msg){
// 步驟1：獲取輸入值
if(msg == null) return;
try {
// 步驟2:建立一個FileOutputStream物件,MODE_APPEND追加模式
FileOutputStream fos = openFileOutput("message.txt",
MODE_APPEND);
// 步驟3：將獲取過來的值放入檔案
fos.write(msg.getBytes());
// 步驟4：關閉資料流
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}openFileOutput()方法的第一引數用於指定檔名稱，不能包含路徑分隔符“/” ，如果檔案不存在，Android 會自動建立它。建立的檔案儲存在/data/data//files目錄，如： /data/data/cn.tony.app/files/message.txt，
下面講解某些特殊檔案讀寫需要注意的地方:
其中讀寫步驟按如下進行:
1、呼叫Environment的getExternalStorageState()方法判斷手機上是否插了sd卡,且應用程式具有讀寫SD卡的許可權，如下程式碼將返回true
Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)
2、呼叫Environment.getExternalStorageDirectory()方法來獲取外部儲存器，也就是SD卡的目錄,或者使用”/mnt/sdcard/”目錄
3、使用IO流操作SD卡上的檔案
注意點：手機應該已插入SD卡，對於模擬器而言，可通過mksdcard命令來建立虛擬儲存卡
必須在AndroidManifest.xml上配置讀寫SD卡的許可權
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>案例程式碼：
// 檔案寫操作函式
private void write(String content) {
if (Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED)) { // 如果sdcard存在
File file = new File(Environment.getExternalStorageDirectory()
.toString()
+ File.separator
+ DIR
+ File.separator
+ FILENAME); // 定義File類物件
if (!file.getParentFile().exists()) { // 父資料夾不存在
file.getParentFile().mkdirs(); // 建立資料夾
}
PrintStream out = null; // 列印流物件用於輸出
try {
out = new PrintStream(new FileOutputStream(file, true)); // 追加檔案
out.println(content);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (out != null) {
out.close(); // 關閉列印流
}
}
} else { // SDCard不存在，使用Toast提示使用者
Toast.makeText(this, "儲存失敗，SD卡不存在！", Toast.LENGTH_LONG).show();
}
}
// 檔案讀操作函式
private String read() {
if (Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED)) { // 如果sdcard存在
File file = new File(Environment.getExternalStorageDirectory()
.toString()
+ File.separator
+ DIR
+ File.separator
+ FILENAME); // 定義File類物件
if (!file.getParentFile().exists()) { // 父資料夾不存在
file.getParentFile().mkdirs(); // 建立資料夾
}
Scanner scan = null; // 掃描輸入
StringBuilder sb = new StringBuilder();
try {
scan = new Scanner(new FileInputStream(file)); // 例項化Scanner
while (scan.hasNext()) { // 迴圈讀取
sb.append(scan.next() + "\n"); // 設定文字
}
return sb.toString();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (scan != null) {
scan.close(); // 關閉列印流
}
}
} else { // SDCard不存在，使用Toast提示使用者
Toast.makeText(this, "讀取失敗，SD卡不存在！", Toast.LENGTH_LONG).show();
}
return null;
}第三種：SQLite儲存資料
SQLite是輕量級嵌入式資料庫引擎，它支援 SQL 語言，並且只利用很少的記憶體就有很好的效能。現在的主流移動裝置像Android、iPhone等都使用SQLite作為複雜資料的儲存引擎，在我們為移動裝置開發應用程式時，也許就要使用到SQLite來儲存我們大量的資料，所以我們就需要掌握移動裝置上的SQLite開發技巧
SQLiteDatabase類為我們提供了很多種方法，上面的程式碼中基本上囊括了大部分的資料庫操作；對於新增、更新和刪除來說，我們都可以使用
1 db.executeSQL(String sql);
2 db.executeSQL(String sql, Object[] bindArgs);//sql語句中使用佔位符，然後第二個引數是實際的引數集
除了統一的形式之外，他們還有各自的操作方法：
1 db.insert(String table, String nullColumnHack, ContentValues values);
2 db.update(String table, Contentvalues values, String whereClause, String whereArgs);
3 db.delete(String table, String whereClause, String whereArgs);
以上三個方法的第一個引數都是表示要操作的表名；insert中的第二個引數表示如果插入的資料每一列都為空的話，需要指定此行中某一列的名稱，系統將此列設定為NULL，不至於出現錯誤；insert中的第三個引數是ContentValues型別的變數，是鍵值對組成的Map，key代表列名，value代表該列要插入的值；update的第二個引數也很類似，只不過它是更新該欄位key為最新的value值，第三個引數whereClause表示WHERE表示式，比如“age > ? and age < ?”等，最後的whereArgs引數是佔位符的實際引數值；delete方法的引數也是一樣
下面給出demo
資料的新增
1.使用insert方法
ContentValues cv = new ContentValues();//例項化一個ContentValues用來裝載待插入的資料
cv.put("title","you are beautiful");//新增title
cv.put("weather","sun"); //新增weather
cv.put("context","xxxx"); //新增context
String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
.format(new Date());
cv.put("publish ",publish); //新增publish
db.insert("diary",null,cv);//執行插入操作2.使用execSQL方式來實現
String sql = "insert into user(username,password) values ('Jack Johnson','iLovePopMuisc');//插入操作的SQL語句
db.execSQL(sql);//執行SQL語句資料的刪除
1.使用delete
String whereClause = "username=?";//刪除的條件
String[] whereArgs = {"Jack Johnson"};//刪除的條件引數
db.delete("user",whereClause,whereArgs);//執行刪除2使用execSQL方式的實現
String sql = "delete from user where username='Jack Johnson'";//刪除操作的SQL語句
db.execSQL(sql);//執行刪除操作資料修改
1.使用update
ContentValues cv = new ContentValues();//例項化ContentValues
cv.put("password","iHatePopMusic");//新增要更改的欄位及內容
String whereClause = "username=?";//修改條件
String[] whereArgs = {"Jack Johnson"};//修改條件的引數
db.update("user",cv,whereClause,whereArgs);//執行修改2使用exeSQL方式
String sql = "update user set password = 'iHatePopMusic' where username='Jack Johnson'";//修改的SQL語句
db.execSQL(sql);//執行修改資料查詢
下面來說說查詢操作。查詢操作相對於上面的幾種操作要複雜些，因為我們經常要面對著各種各樣的查詢條件，所以系統也考慮到這種複雜性，為我們提供了較為豐富的查詢形式：
1 db.rawQuery(String sql, String[] selectionArgs);
2 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy);
3 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);
4 db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);上面幾種都是常用的查詢方法，第一種最為簡單，將所有的SQL語句都組織到一個字串中，使用佔位符代替實際引數，selectionArgs就是佔位符實際引數集；
各引數說明：
table：表名稱
colums：表示要查詢的列所有名稱集
selection：表示WHERE之後的條件語句，可以使用佔位符
selectionArgs：條件語句的引數陣列
groupBy：指定分組的列名
having：指定分組條件,配合groupBy使用
orderBy：y指定排序的列名
limit：指定分頁引數
distinct：指定“true”或“false”表示要不要過濾重複值
Cursor：返回值，相當於結果集ResultSet
最後，他們同時返回一個Cursor物件，代表資料集的遊標，有點類似於JavaSE中的ResultSet。下面是Cursor物件的常用方法：
c.move(int offset); //以當前位置為參考,移動到指定行
c.moveToFirst(); //移動到第一行
c.moveToLast(); //移動到最後一行
c.moveToPosition(int position); //移動到指定行
c.moveToPrevious(); //移動到前一行
c.moveToNext(); //移動到下一行
c.isFirst(); //是否指向第一條
c.isLast(); //是否指向最後一條
c.isBeforeFirst(); //是否指向第一條之前
c.isAfterLast(); //是否指向最後一條之後
c.isNull(int columnIndex); //指定列是否為空(列基數為0)
c.isClosed(); //遊標是否已關閉
c.getCount(); //總資料項數
c.getPosition(); //返回當前遊標所指向的行數
c.getColumnIndex(String columnName);//返回某列名對應的列索引值
c.getString(int columnIndex); //返回當前行指定列的值實現程式碼
String[] params = {12345,123456};
Cursor cursor = db.query("user",columns,"ID=?",params,null,null,null);//查詢並獲得遊標
if(cursor.moveToFirst()){//判斷遊標是否為空
for(int i=0;i<cursor.getCount();i++){
cursor.move(i);//移動到指定記錄
String username = cursor.getString(cursor.getColumnIndex("username");
String password = cursor.getString(cursor.getColumnIndex("password"));
}
}通過rawQuery實現的帶引數查詢
Cursor result=db.rawQuery("SELECT ID, name, inventory FROM mytable");
//Cursor c = db.rawQuery("s name, inventory FROM mytable where ID=?",new Stirng[]{"123456"});
result.moveToFirst();
while (!result.isAfterLast()) {
int id=result.getInt(0);
String name=result.getString(1);
int inventory=result.getInt(2);
// do something useful with these
result.moveToNext();
}
result.close();在上面的程式碼示例中，已經用到了這幾個常用方法中的一些，關於更多的資訊，大家可以參考官方文件中的說明。
最後當我們完成了對資料庫的操作後，記得呼叫SQLiteDatabase的close()方法釋放資料庫連線，否則容易出現SQLiteException。
上面就是SQLite的基本應用，但在實際開發中，為了能夠更好的管理和維護資料庫，我們會封裝一個繼承自SQLiteOpenHelper類的資料庫操作類，然後以這個類為基礎，再封裝我們的業務邏輯方法。
這裡直接使用案例講解：下面是案例demo的介面
SQLiteOpenHelper類介紹
SQLiteOpenHelper是SQLiteDatabase的一個幫助類，用來管理資料庫的建立和版本的更新。一般是建立一個類繼承它，並實現它的onCreate和onUpgrade方法。
首先建立資料庫類
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class SqliteDBHelper extends SQLiteOpenHelper {
// 步驟1：設定常數參量
private static final String DATABASE_NAME = "diary_db";
private static final int VERSION = 1;
private static final String TABLE_NAME = "diary";
// 步驟2：過載構造方法
public SqliteDBHelper(Context context) {
super(context, DATABASE_NAME, null, VERSION);
}
/*
* 引數介紹：context 程式上下文環境 即：XXXActivity.this
* name 資料庫名字
* factory 接收資料，一般情況為null
* version 資料庫版本號
*/
public SqliteDBHelper(Context context, String name, CursorFactory factory,
int version) {
super(context, name, factory, version);
}
//資料庫第一次被建立時，onCreate()會被呼叫
@Override
public void onCreate(SQLiteDatabase db) {
// 步驟3：資料庫表的建立
String strSQL = "create table "
+ TABLE_NAME
+ "(tid integer primary key autoincrement,title varchar(20),weather varchar(10),context text,publish date)";
//步驟4：使用引數db,建立物件
db.execSQL(strSQL);
}
//資料庫版本變化時，會呼叫onUpgrade()
@Override
public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {
}
}正如上面所述，資料庫第一次建立時onCreate方法會被呼叫，我們可以執行建立表的語句，當系統發現版本變化之後，會呼叫onUpgrade方法，我們可以執行修改表結構等語句。
我們需要一個Dao，來封裝我們所有的業務方法，程式碼如下：
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import com.chinasoft.dbhelper.SqliteDBHelper;
public class DiaryDao {
private SqliteDBHelper sqliteDBHelper;
private SQLiteDatabase db;
// 重寫構造方法
public DiaryDao(Context context) {
this.sqliteDBHelper = new SqliteDBHelper(context);
db = sqliteDBHelper.getWritableDatabase();
}
// 讀操作
public String execQuery(final String strSQL) {
try {
System.out.println("strSQL>" + strSQL);
// Cursor相當於JDBC中的ResultSet
Cursor cursor = db.rawQuery(strSQL, null);
// 始終讓cursor指向資料庫表的第1行記錄
cursor.moveToFirst();
// 定義一個StringBuffer的物件，用於動態拼接字串
StringBuffer sb = new StringBuffer();
// 循環遊標，如果不是最後一項記錄
while (!cursor.isAfterLast()) {
sb.append(cursor.getInt(0) + "/" + cursor.getString(1) + "/"
+ cursor.getString(2) + "/" + cursor.getString(3) + "/"
+ cursor.getString(4)+"#");
//cursor遊標移動
cursor.moveToNext();
}
db.close();
return sb.deleteCharAt(sb.length()-1).toString();
} catch (RuntimeException e) {
e.printStackTrace();
return null;
}
}
// 寫操作
public boolean execOther(final String strSQL) {
db.beginTransaction(); //開始事務
try {
System.out.println("strSQL" + strSQL);
db.execSQL(strSQL);
db.setTransactionSuccessful(); //設定事務成功完成
db.close();
return true;
} catch (RuntimeException e) {
e.printStackTrace();
return false;
}finally {
db.endTransaction(); //結束事務
}
}
}我們在Dao構造方法中例項化sqliteDBHelper並獲取一個SQLiteDatabase物件，作為整個應用的資料庫例項；在增刪改資訊時，我們採用了事務處理，確保資料完整性；最後要注意釋放資料庫資源db.close()，這一個步驟在我們整個應用關閉時執行，這個環節容易被忘記，所以朋友們要注意。
我們獲取資料庫例項時使用了getWritableDatabase()方法，也許朋友們會有疑問，在getWritableDatabase()和getReadableDatabase()中，你為什麼選擇前者作為整個應用的資料庫例項呢？在這裡我想和大家著重分析一下這一點。
我們來看一下SQLiteOpenHelper中的getReadableDatabase()方法：
public synchronized SQLiteDatabase getReadableDatabase() {
if (mDatabase != null && mDatabase.isOpen()) {
// 如果發現mDatabase不為空並且已經開啟則直接返回
return mDatabase;
}
if (mIsInitializing) {
// 如果正在初始化則丟擲異常
throw new IllegalStateException("getReadableDatabase called recursively");
}
// 開始例項化資料庫mDatabase
try {
// 注意這裡是呼叫了getWritableDatabase()方法
return getWritableDatabase();
} catch (SQLiteException e) {
if (mName == null)
throw e; // Can't open a temp database read-only!
Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);
}
// 如果無法以可讀寫模式開啟資料庫 則以只讀方式開啟
SQLiteDatabase db = null;
try {
mIsInitializing = true;
String path = mContext.getDatabasePath(mName).getPath();// 獲取資料庫路徑
// 以只讀方式開啟資料庫
db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);
if (db.getVersion() != mNewVersion) {
throw new SQLiteException("Can't upgrade read-only database from version " + db.getVersion() + " to "
+ mNewVersion + ": " + path);
}
onOpen(db);
Log.w(TAG, "Opened " + mName + " in read-only mode");
mDatabase = db;// 為mDatabase指定新開啟的資料庫
return mDatabase;// 返回開啟的資料庫
} finally {
mIsInitializing = false;
if (db != null && db != mDatabase)
db.close();
}
}在getReadableDatabase()方法中，首先判斷是否已存在資料庫例項並且是開啟狀態，如果是，則直接返回該例項，否則試圖獲取一個可讀寫模式的資料庫例項，如果遇到磁碟空間已滿等情況獲取失敗的話，再以只讀模式開啟資料庫，獲取資料庫例項並返回，然後為mDatabase賦值為最新開啟的資料庫例項。既然有可能呼叫到getWritableDatabase()方法，我們就要看一下了：
public synchronized SQLiteDatabase getWritableDatabase() {
if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {
// 如果mDatabase不為空已開啟並且不是隻讀模式 則返回該例項
return mDatabase;
}
if (mIsInitializing) {
throw new IllegalStateException("getWritableDatabase called recursively");
}
// If we have a read-only database open, someone could be using it
// (though they shouldn't), which would cause a lock to be held on
// the file, and our attempts to open the database read-write would
// fail waiting for the file lock. To prevent that, we acquire the
// lock on the read-only database, which shuts out other users.
boolean success = false;
SQLiteDatabase db = null;
// 如果mDatabase不為空則加鎖 阻止其他的操作
if (mDatabase != null)
mDatabase.lock();
try {
mIsInitializing = true;
if (mName == null) {
db = SQLiteDatabase.create(null);
} else {
// 開啟或建立資料庫
db = mContext.openOrCreateDatabase(mName, 0, mFactory);
}
// 獲取資料庫版本(如果剛建立的資料庫,版本為0)
int version = db.getVersion();
// 比較版本(我們程式碼中的版本mNewVersion為1)
if (version != mNewVersion) {
db.beginTransaction();// 開始事務
try {
if (version == 0) {
// 執行我們的onCreate方法
onCreate(db);
} else {
// 如果我們應用升級了mNewVersion為2,而原版本為1則執行onUpgrade方法
onUpgrade(db, version, mNewVersion);
}
db.setVersion(mNewVersion);// 設定最新版本
db.setTransactionSuccessful();// 設定事務成功
} finally {
db.endTransaction();// 結束事務
}
}
onOpen(db);
success = true;
return db;// 返回可讀寫模式的資料庫例項
} finally {
mIsInitializing = false;
if (success) {
// 開啟成功
if (mDatabase != null) {
// 如果mDatabase有值則先關閉
try {
mDatabase.close();
} catch (Exception e) {
}
mDatabase.unlock();// 解鎖
}
mDatabase = db;// 賦值給mDatabase
} else {
// 開啟失敗的情況：解鎖、關閉
if (mDatabase != null)
mDatabase.unlock();
if (db != null)
db.close();
}
}
}大家可以看到，幾個關鍵步驟是，首先判斷mDatabase如果不為空已開啟並不是只讀模式則直接返回，否則如果mDatabase不為空則加鎖，然後開始開啟或建立資料庫，比較版本，根據版本號來呼叫相應的方法，為資料庫設定新版本號，最後釋放舊的不為空的mDatabase並解鎖，把新開啟的資料庫例項賦予mDatabase，並返回最新例項。
看完上面的過程之後，大家或許就清楚了許多，如果不是在遇到磁碟空間已滿等情況，getReadableDatabase()一般都會返回和getWritableDatabase()一樣的資料庫例項，所以我們在DBManager構造方法中使用getWritableDatabase()獲取整個應用所使用的資料庫例項是可行的。當然如果你真的擔心這種情況會發生，那麼你可以先用getWritableDatabase()獲取資料例項，如果遇到異常，再試圖用getReadableDatabase()獲取例項，當然這個時候你獲取的例項只能讀不能寫了
最後，讓我們看一下如何使用這些資料操作方法來顯示資料,介面核心邏輯程式碼:
public class SQLiteActivity extends Activity {
public DiaryDao diaryDao;
//因為getWritableDatabase內部呼叫了mContext.openOrCreateDatabase(mName, 0, mFactory);
//所以要確保context已初始化,我們可以把例項化Dao的步驟放在Activity的onCreate裡
@Override
protected void onCreate(Bundle savedInstanceState) {
diaryDao = new DiaryDao(SQLiteActivity.this);
initDatabase();
}
class ViewOcl implements View.OnClickListener {
@Override
public void onClick(View v) {
String strSQL;
boolean flag;
String message;
switch (v.getId()) {
case R.id.btnAdd:
String title = txtTitle.getText().toString().trim();
String weather = txtWeather.getText().toString().trim();;
String context = txtContext.getText().toString().trim();;
String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
.format(new Date());
// 動態元件SQL語句
strSQL = "insert into diary values(null,'" + title + "','"
+ weather + "','" + context + "','" + publish + "')";
flag = diaryDao.execOther(strSQL);
//返回資訊
message = flag?"新增成功":"新增失敗";
Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();
break;
case R.id.btnDelete:
strSQL = "delete from diary where tid = 1";
flag = diaryDao.execOther(strSQL);
//返回資訊
message = flag?"刪除成功":"刪除失敗";
Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();
break;
case R.id.btnQuery:
strSQL = "select * from diary order by publish desc";
String data = diaryDao.execQuery(strSQL);
Toast.makeText(getApplicationContext(), data, Toast.LENGTH_LONG).show();
break;
case R.id.btnUpdate:
strSQL = "update diary set title = '測試標題1-1' where tid = 1";
flag = diaryDao.execOther(strSQL);
//返回資訊
message = flag?"更新成功":"更新失敗";
Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();
break;
}
}
}
private void initDatabase() {
// 建立資料庫物件
SqliteDBHelper sqliteDBHelper = new SqliteDBHelper(SQLiteActivity.this);
sqliteDBHelper.getWritableDatabase();
System.out.println("資料庫建立成功");
}
}Android sqlite3資料庫管理工具
Android SDK的tools目錄下提供了一個sqlite3.exe工具，這是一個簡單的sqlite資料庫管理工具。開發者可以方便的使用其對sqlite資料庫進行命令列的操作。
程式執行生成的.db檔案一般位於”/data/data/專案名(包括所處包名)/databases/.db”，因此要對資料庫檔案進行操作需要先找到資料庫檔案：
1、進入shell 命令
adb shell
2、找到資料庫檔案
cd data/data
ls –列出所有專案
cd project_name –進入所需專案名
cd databases
ls –列出現寸的資料庫檔案
3、進入資料庫
sqlite3 test_db –進入所需資料庫
會出現類似如下字樣：
SQLite version 3.6.22
Enter “.help” for instructions
Enter SQL statements terminated with a “;”
sqlite>
至此，可對資料庫進行sql操作。
4、sqlite常用命令
.databases –產看當前資料庫
.tables –檢視當前資料庫中的表
.help –sqlite3幫助
.schema –各個表的生成語句