【android編程】第十一講-數據儲存

第十一講數據儲存

0. 學習指導

Android開發人員提供了多種持久化應用數據的方式，具體選擇哪種方式需要和我說問題具體分析。Android 提供了三種數據存儲技術分別是: SharedPreferences、 Files和SQLite數據庫，可以根據數據是否僅限於本程序使用，還是可以用於其他程序，以及保存數據所佔用的空間等。本講主要內容有:
1.使用SharedPreferences
2.SQLite數據庫編程

1.使用SharedPreferences

SharedPreferences類供開發人員保存和獲取基本數據類型的鍵值對。該類主要用於基本類型，例如booleans. floats、 ints、longs和strings. 在應用程序結束後，數據仍舊會保存。

完成向SharedPreferences類中增加值的步驟如下:
1.調用SharedPreferences類的edit()方法獲得SharedPreferences. Editor對象:
2.調用諸如putBoolean()、putString()等方 法增加值;
3.使用commit()方法提交新值。

SharedPreferences sp = getSharedPreferences("mySP", MODE_PRIVATE);
//getString()第二個參數爲缺省值，如果preference中不存在該key，將返回缺省值
String name = sharedPreferences.getString("name", "");

獲取SharedPreferences的兩種方式:

1 調用Context對象的getSharedPreferences()方法

2 調用Activity對象的getPreferences()方法

兩種方式的區別:

調用Context對象的getSharedPreferences()方法獲得的SharedPreferences對象可以被同一應用程序下的其他組件共享.

調用Activity對象的getPreferences()方法獲得的SharedPreferences對象只能在該Activity中使用.

SharedPreferences的四種操作模式:

Context.MODE_PRIVATE
Context.MODE_APPEND
Context.MODE_WORLD_READABLE
Context.MODE_WORLD_WRITEABLE

Context.MODE_PRIVATE：爲默認操作模式,代表該文件是私有數據,只能被應用本身訪問,在該模式下,寫入的內容會覆蓋原文件的內容
Context.MODE_APPEND：模式會檢查文件是否存在,存在就往文件追加內容,否則就創建新文件.
Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE用來控制其他應用是否有權限讀寫該文件.
MODE_WORLD_READABLE：表示當前文件可以被其他應用讀取.
MODE_WORLD_WRITEABLE：表示當前文件可以被其他應用寫入.

將數據保存至SharedPreferences:

SharedPreferences preferences=getSharedPreferences("user",Context.MODE_PRIVATE);
Editor editor=preferences.edit();
String name="xixi";
String age="22";
editor.putString("name", name);
editor.putString("age", age);
editor.commit();

從SharedPreferences獲取數據:

SharedPreferences preferences=getSharedPreferences("user", Context.MODE_PRIVATE);
String name=preferences.getString("name", "defaultname");
String age=preferences.getString("age", "0");

示例

在按下提交按鈕時，程序會將學號、姓名、性別信息保存了一個名爲mySP的文件中。按下提取按鈕時會在屏幕下部分的顯示已經保存的學號、姓名和性別信息。

mainActivity.java（省略佈局文件）

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
//保存按鈕onclick
    public void save(View view) {
        EditText et1 = (EditText)findViewById(R.id.et1);
        EditText et2 = (EditText)findViewById(R.id.et2);
        RadioButton sex1 = (RadioButton)findViewById(R.id.sex1);
        RadioButton sex2 = (RadioButton)findViewById(R.id.sex2);
        SharedPreferences sp = getSharedPreferences("mySP", MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();

        String number = et1.getText().toString();
        String name = et2.getText().toString();
        String sex ;
        if (sex1.isChecked()){
            sex = sex1.getText().toString();
        }
        else {
            sex = sex2.getText().toString();
        }
        editor.putString("number",number);
        editor.putString("name",name);
        editor.putString("sex",sex);
        editor.commit();
    }
//查看按鈕onclick
    public void geter(View view) {
        TextView text = (TextView)findViewById(R.id.text);
        SharedPreferences sp = getSharedPreferences("mySP", MODE_PRIVATE);
        String number = sp.getString("number","null");
        String name = sp.getString("name","null");
        String sex = sp.getString("sex","null");
        text.setText(number+";"+name+";"+sex);

    }

2.SQLite數據庫編程

對於更加複雜的數據結構，Android提 供了內置的SQLite數據庫來存儲數據。sQLite使用SQL命令提供了完整的關係型數據庫能力。每個使用SQLite的應用程序都有-一個該數據庫的實例，並且在默認情況下僅限當前應用使用。數據庫存儲在Android設置的/data/data/<package_ name>/databases文 件夾中。

使用SQLite數據庫的步驟如下:
1.創建數據庫;
2.打開數據庫;
3.創建表;
4.完成數據的增刪改查操作;
5.關閉數據庫。

SQLiteOpenHelper類 常用方法

/** 
  *  SQLiteOpenHelper類 創建數據庫
  */ 
 // 1. 創建 or 打開 可讀/寫的數據庫（通過 返回的SQLiteDatabase對象 進行操作）
 getWritableDatabase（）
 // 2. 創建 or 打開 可讀的數據庫（通過 返回的SQLiteDatabase對象 進行操作）
 getReadableDatabase（）
 // 3. 數據庫第1次創建時 則會調用，即 第1次調用 getWritableDatabase（） / getReadableDatabase（）時調用
 // 在繼承SQLiteOpenHelper類的子類中複寫
 onCreate(SQLiteDatabase db) 
 // 4. 數據庫升級時自動調用
 // 在繼承SQLiteOpenHelper類的子類中複寫
 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
 // 5. 關閉數據庫
 close（）
 /** 
  *  數據庫操作（增、刪、減、查）
  */ 
 // 1. 查詢數據
 (Cursor) query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit)  
 // 查詢指定的數據表返回一個帶遊標的數據集。
 // 各參數說明： 
 // table：表名稱 
 // colums：列名稱數組 
 // selection：條件子句，相當於where 
 // selectionArgs：條件語句的參數數組 
 // groupBy：分組 
 // having：分組條件 
 // orderBy：排序類 
 // limit：分頁查詢的限制 
 // Cursor：返回值，相當於結果集ResultSet 

 (Cursor) rawQuery(String sql, String[] selectionArgs) 
 //運行一個預置的SQL語句，返回帶遊標的數據集（與上面的語句最大的區別 = 防止SQL注入）

 // 2. 刪除數據行  
 (int) delete(String table,String whereClause,String[] whereArgs) 
 
 // 3. 添加數據行 
 (long) insert(String table,String nullColumnHack,ContentValues values) 
 
 // 4. 更新數據行 
(int) update(String table, ContentValues values, String whereClause, String[] whereArgs) 
 
 // 5. 執行一個SQL語句，可以是一個select or 其他sql語句 
 // 即 直接使用String類型傳入sql語句 & 執行
 (void) execSQL(String sql) 

使用步驟 = 自定義數據庫子類（繼承SQLiteOpenHelper類）、創建數據庫 & 操作數據庫（增、刪、查、改）

自定義數據庫子類（繼承 SQLiteOpenHelper 類）

/** 
  * 創建數據庫子類，繼承自SQLiteOpenHelper類
  * 需 複寫 onCreat（）、onUpgrade（）
  */ 
public class DatabaseHelper extends SQLiteOpenHelper {

    // 數據庫版本號
    private static Integer Version = 1;

    /** 
     * 構造函數
     * 在SQLiteOpenHelper的子類中，必須有該構造函數
     */ 
    public DatabaseHelper(Context context, String name, SQLiteDatabase.CursorFactory factory,
                          int version) {
        // 參數說明
        // context：上下文對象
        // name：數據庫名稱
        // param：一個可選的遊標工廠（通常是 Null） 
        // version：當前數據庫的版本，值必須是整數並且是遞增的狀態

        // 必須通過super調用父類的構造函數
        super(context, name, factory, version);
    }
    
    /** 
     * 複寫onCreate（）
     * 調用時刻：當數據庫第1次創建時調用
     * 作用：創建數據庫 表 & 初始化數據
     * SQLite數據庫創建支持的數據類型： 整型數據、字符串類型、日期類型、二進制
     */ 
    @Override
    public void onCreate(SQLiteDatabase db) {
              // 創建數據庫1張表
              // 通過execSQL（）執行SQL語句（此處創建了1個名爲person的表）
              String sql = "create table person(id integer primary key autoincrement,name varchar(64),address varchar(64))"; 
              db.execSQL(sql); 

              // 注：數據庫實際上是沒被創建 / 打開的（因該方法還沒調用）
              // 直到getWritableDatabase() / getReadableDatabase() 第一次被調用時纔會進行創建 / 打開 
    }
    /** 
     * 複寫onUpgrade（）
     * 調用時刻：當數據庫升級時則自動調用（即 數據庫版本 發生變化時）
     * 作用：更新數據庫表結構
     * 注：創建SQLiteOpenHelper子類對象時,必須傳入一個version參數，該參數 = 當前數據庫版本, 若該版本高於之前版本, 就調用onUpgrade()
     */ 

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 參數說明： 
        // db ： 數據庫 
        // oldVersion ： 舊版本數據庫 
        // newVersion ： 新版本數據庫 

        // 使用 SQL的ALTER語句
        String sql = "alter table person add sex varchar(8)";  
        db.execSQL(sql);  
    }
}

創建數據庫：getWritableDatabase（）、getReadableDatabase（）

// 步驟1：創建DatabaseHelper對象
 // 注：此時還未創建數據庫
 SQLiteOpenHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,"test_carson");

// 步驟2：真正創建 / 打開數據庫
 SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase(); // 創建 or 打開 可讀/寫的數據庫
 SQLiteDatabase sqliteDatabase = dbHelper.getReadableDatabase(); // 創建 or 打開 可讀的數據庫

注：當需操作數據庫時，都必須先創建數據庫對象 & 創建 / 打開數據庫。

1. 對於操作 = “增、刪、改（更新）”，需獲得 可"讀 / 寫"的權限：getWritableDatabase()
2. 對於操作 = “查詢”，需獲得 可"讀 "的權限getReadableDatabase()

操作數據庫（增、刪、查、改）

/** 
  * 1. 創建 & 打開數據庫
  */ 

      // a. 創建DatabaseHelper對象
      // 注：一定要傳入最新的數據庫版本號
      SQLiteOpenHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,"test_carson"，2);
      // b.創建 or 打開 可讀/寫的數據庫
      SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase();

  /** 
    *  操作1：插入數據 = insert()
    */ 
        // a. 創建ContentValues對象
        ContentValues values = new ContentValues();

        // b. 向該對象中插入鍵值對
        values.put("id", 1);
        values.put("name", "carson");
            //其中，key = 列名，value = 插入的值
            //注：ContentValues內部實現 = HashMap，區別在於：ContenValues Key只能是String類型，Value可存儲基本類型數據 & String類型

        // c. 插入數據到數據庫當中：insert()
        sqliteDatabase.insert("user", null, values);
                // 參數1：要操作的表名稱
                // 參數2：SQl不允許一個空列，若ContentValues是空，那麼這一列被明確的指明爲NULL值
                // 參數3：ContentValues對象
        // 注：也可採用SQL語句插入
        String sql = "insert into user (id,name) values (1,'carson')";
        db.execSQL(sql) ；
            
  /** 
    *  操作2：修改數據 = update（）
    */ 
        // a. 創建一個ContentValues對象
        ContentValues values = new ContentValues();
        values.put("name", "zhangsan");

        // b. 調用update方法修改數據庫：將id=1 修改成 name = zhangsan
        sqliteDatabase.update("user", values, "id=?", new String[] { "1" });
            // 參數1：表名(String)
            // 參數2：需修改的ContentValues對象
            // 參數3：WHERE表達式（String），需數據更新的行； 若該參數爲 null, 就會修改所有行；？號是佔位符
            // 參數4：WHERE選擇語句的參數(String[]), 逐個替換 WHERE表達式中 的“？”佔位符;

            // 注：調用完upgrate（）後，則會回調 數據庫子類的onUpgrade()

        // 注：也可採用SQL語句修改
        String sql = "update [user] set name = 'zhangsan' where id="1";
        db.execSQL(sql);

  /** 
    *  操作3：刪除數據 = delete()
    */
        // 刪除 id = 1的數據
        sqliteDatabase.delete("user", "id=?", new String[]{"1"});
            // 參數1：表名(String)
            // 參數2：WHERE表達式（String），需刪除數據的行； 若該參數爲 null, 就會刪除所有行；？號是佔位符
            // 參數3：WHERE選擇語句的參數(String[]), 逐個替換 WHERE表達式中 的“？”佔位符;

        // 注：也可採用SQL語句修改
        String sql = "delete from user where id="1"；
        db.execSQL(sql);

  /** 
    *  操作4：查詢數據1 = rawQuery() 
    *  直接調用 SELECT 語句
    */
        Cursor c = db.rawQuery("select * from user where id=?",new Stirng[]{"1"}); 
        // 返回值一個 cursor 對象

        // 通過遊標的方法可迭代查詢結果
        if(cursor.moveToFirst()) { 
           String password = c.getString(c.getColumnIndex("password")); 
         }
        
        //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);   //返回當前行指定列的值 
        
        // 通過遊標遍歷1個名爲user的表
        Cursor result=db.rawQuery("SELECT _id, username, password FROM user");  
         result.moveToFirst();  
         while (!result.isAfterLast()) {  
            int id=result.getInt(0);  
            String name=result.getString(1);  
            String password =result.getString(2);  
            // do something useful with these  
            result.moveToNext();  
          }  
         result.close();


     // 若查詢是動態的，使用該方法會複雜。此時使用 query() 會方便很多
     // 注：無法使用SQL語句，即db.execSQL(sql);

  /** 
    *  操作4：查詢數據2 = query() 
    *  直接調用 SELECT 語句
    */
        // 方法說明
        db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy);  
        db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);  
        db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit); 

        // 參數說明
        // table：要操作的表
        // columns：查詢的列所有名稱集
        // selection：WHERE之後的條件語句，可以使用佔位符
        // groupBy：指定分組的列名
        // having指定分組條件，配合groupBy使用
        // orderBy指定排序的列名
        // limit指定分頁參數
        // distinct可以指定“true”或“false”表示要不要過濾重複值

        // 所有方法將返回一個Cursor對象，代表數據集的遊標 

        // 具體使用
         Cursor cursor = sqliteDatabase.query("user", new String[] { "id","name" }, "id=?", new String[] { "1" }, null, null, null);
            // 參數1：（String）表名
            // 參數2：（String[]）要查詢的列名
            // 參數3：（String）查詢條件
            // 參數4：（String[]）查詢條件的參數
            // 參數5：（String）對查詢的結果進行分組
            // 參數6：（String）對分組的結果進行限制
            // 參數7：（String）對查詢的結果進行排序
            
        // 注：無法使用SQL語句，即db.execSQL(sql);
  /** 
    *  操作5：關閉數據庫 = close()
    *  注：完成數據庫操作後，記得調用close（）關閉數據庫，從而釋放數據庫的連接
    */
        sqliteDatabase.close();  

  /** 
    *  操作6：刪除數據庫 = deleteDatabase（）
    */
        // 刪除 名爲person的數據庫  
        deleteDatabase("test.db");

注:
除了“查詢”，所有的數據庫操作都可使用 SQL 語句，即使用下列方法代替：

db.executeSQL(String sql);  
db.executeSQL(String sql, Object[] bindArgs);
// sql語句中使用佔位符，參數2 = 實際的參數集  

使用建議：都使用SQL語句，因爲：SQL語句 通用 & 簡單
原生的方法insert()、delete()等方法具備多個參數，使用複雜

此部分參考鏈接：https://blog.csdn.net/carson_ho/article/details/53241633

示例

按下“保存”按鈕時，首先判斷所有的必要信息是不是都已經填寫好，如發現有缺項則提示用戶不能保存數據；如果數據完整則將該學生的信息，存入student數據庫的basedata表中。保存三個以上軟件工程專業的學生，和三個以上其它專業的學生。然後依據選擇的專業，按下按鈕進行查詢並將查詢結果按圖中所示的“查詢結果”下方的TextView全部顯示。（可用\n進行換行回車）。

（省略佈局文件）

PersonSQLiteOpenHelper.java

public class PersonSQLiteOpenHelper extends SQLiteOpenHelper {
    public PersonSQLiteOpenHelper(Context context){
        super(context,"student.db",null,1);//上下文，數據庫，遊標，版本號
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        StringBuffer sql = new StringBuffer();
        sql.append("create table basedata(");
        sql.append("id integer primary key autoincrement,");
        sql.append("number varchar(20),");
        sql.append("name varchar(20),");
        sql.append("sex varchar(10),");
        sql.append("study varchar(20))");
        db.execSQL(sql.toString());    //執行
    }

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

    }
}

PersonDao.java

package com.example.bean.myapplication330v2;

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

/**
 * Created by Bean on 2020/3/30.
 */

public class PersonDao {
    private PersonSQLiteOpenHelper helper;

    public PersonDao(Context context){
        helper = new PersonSQLiteOpenHelper(context);
    }
    public long add(String number,String name,String sex,String study){
        SQLiteDatabase db = helper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("number",number);
        values.put("name",name);
        values.put("sex",sex);
        values.put("study",study);
        long id = db.insert("basedata",null,values);
        db.close();
        return id;
    }
    public String find (String study){
        SQLiteDatabase db = helper.getReadableDatabase();
        Cursor cursor = db.query("basedata",null,"study=?",new String[]{study},null,null,null);
        String lists = "";

        while (cursor.moveToNext()) {
            String number = cursor.getString(cursor.getColumnIndex("number"));
            String name = cursor.getString(cursor.getColumnIndex("name"));
            String sex = cursor.getString(cursor.getColumnIndex("sex"));
            //輸出查詢結果
            System.out.println("查詢到的數據是:"+"number: "+number+"  "+"name: "+name);
            String list = "學號："+number+"；姓名："+name+"；專業："+study+"\n";
            lists=lists+list;
        }
        cursor.close();
        return  lists;
    }
    public int update(String number,String name,String sex,String study){
        SQLiteDatabase db = helper.getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("number",number);
        values.put("name",name);
        values.put("sex",sex);
        values.put("study",study);
        int count = db.update("basedata",values,"number=?",new String[]{number});
        db.close();
        return count;
    }

    public int delete(String number){
        SQLiteDatabase db = helper.getWritableDatabase();
        int count = db.delete("basedata","number=?",new String[]{number});
        db.close();
        return count;
    }
}

MainActivity.java

package com.example.bean.myapplication330v2;

import android.support.annotation.BoolRes;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    private String item;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Spinner spinner = (Spinner)findViewById(R.id.spinner);
        //String items[] = findViewById(R.spingarr.spingarr);final String items[] = {"軟件工程","車輛工程","電子信息"};
        final String items[] = getResources().getStringArray(R.array.spingarr);
        spinner.setOnItemSelectedListener(new Spinner.OnItemSelectedListener(){

            @Override
            public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
                item = items[position];
            }

            @Override
            public void onNothingSelected(AdapterView<?> parent) {
                item =items[0];;
            }
        });
    }

    public void save(View view) {
        EditText et1 = (EditText)findViewById(R.id.et1);
        EditText et2 = (EditText)findViewById(R.id.et2);
        //RadioGroup sex = (RadioGroup)findViewById(R.id.et3);
        RadioButton sex1 = (RadioButton)findViewById(R.id.sex1);
        RadioButton sex2 = (RadioButton)findViewById(R.id.sex2);
        boolean Flag = true;

        String number = et1.getText().toString();
        String name = et2.getText().toString();
        String sex = null;

        if (number.isEmpty()||name.isEmpty() ){
            Flag = false;
        }
        if (sex1.isChecked()){
            sex = sex1.getText().toString();
        }
        else if(sex2.isChecked()){
            sex = sex2.getText().toString();
        }
        else {
            Flag = false;
        }
        if (!Flag){
            Toast.makeText(this,"信息輸入不完整",Toast.LENGTH_SHORT).show();
        }
        else {
            PersonDao student = new PersonDao(this);
            long id = student.add(number,name,sex,item);
            Toast.makeText(this,name + " 插入成功，id爲 "+id,Toast.LENGTH_SHORT).show();
        }
    }

    public void search(View view) {
        TextView text = (TextView)findViewById(R.id.text);
        String study = item;
        PersonDao student = new PersonDao(this);
        String items = student.find(study);
        text.setText("查詢結果\n"+items);
    }
    //根據學號查找並修改，學號不能變，否則找不到
    public void change(View view) {
        EditText et1 = (EditText)findViewById(R.id.et1);
        EditText et2 = (EditText)findViewById(R.id.et2);
        //RadioGroup sex = (RadioGroup)findViewById(R.id.et3);
        RadioButton sex1 = (RadioButton)findViewById(R.id.sex1);
        RadioButton sex2 = (RadioButton)findViewById(R.id.sex2);
        boolean Flag = true;
        String number = et1.getText().toString();
        String name = et2.getText().toString();
        String sex = null;

        if (number.isEmpty()||name.isEmpty() ){
            Flag = false;
        }

        if (sex1.isChecked()){
            sex = sex1.getText().toString();
        }
        else if(sex2.isChecked()){
            sex = sex2.getText().toString();
        }
        else {
            Flag = false;
        }

        if (!Flag){
            Toast.makeText(this,"信息輸入不完整",Toast.LENGTH_SHORT).show();
        }
        else {
            PersonDao student = new PersonDao(this);
            int count = student.update(number,name,sex,item);
            if (count>0){
                Toast.makeText(this,name + "修改成功 ",Toast.LENGTH_SHORT).show();
            }
            else {
                Toast.makeText(this,"學號未找到",Toast.LENGTH_SHORT).show();
            }
        }
    }
    //根據學號查詢刪除
    public void delete(View view) {
        EditText et1 = (EditText)findViewById(R.id.et1);
        String number = et1.getText().toString();
        if(number.isEmpty()){
            Toast.makeText(this, "請輸入學號 ",Toast.LENGTH_SHORT).show();
        }
        else {
            PersonDao student = new PersonDao(this);
            int count = student.delete(number);
            if (count>0){
                Toast.makeText(this,number + "刪除成功 ",Toast.LENGTH_SHORT).show();
            }
            else {
                Toast.makeText(this,"學號未找到",Toast.LENGTH_SHORT).show();
            }
        }
    }
}

題目記錄

1. SharedPreferences數據存取方式是：

• A.直接存取指定的數據類型
• B.鍵值對1.00/1.00
• C.文本
• D.數值

2. SharedPreferences存儲的數據類型是

• A.只用於文本
• B.可以使用泛型
• C.主要用於基本數據類型1.00/1.00
• D.只用於數值

3. 可以通過下列哪個方法打開SharePreferences:

• A.editSharedPreferences()0.00/
• B.openSharedPerferences() 000
• C.getSharedPreferences()1.00
• D.attachSharedPreferences()

4. 向SharedPreferences類中增加值的第一步是：

• A.獲得SharedPreferences.Input對象
• B.獲得SharedPreferences.Inflator對象
• C.獲得SharedPreerences.Editor對象1.00/1.00
• D.獲得SharedPreferences.adpter對象

5. 向SharedPreferences中添加數據可以使用

• A.Print方法
• B.putXXX方法1.00/1.00
• C.writeXXX方法
• D.write方法

6. 下列對SQLite的描述哪一個是正確的

• A.是一種Android專用的，使用鍵值對的數據存儲系統
• B.是Android的一種特殊的數據文件000
• C.是Android內置的數據庫系統
• D.是一種基於Java的數據庫0.00/1.00

7. SQLite

• A.只是一個簡單的類數據庫的數據文件系統
• B.提供了完整的關係型數據庫能力
• C.是一種使用鍵值對的數據庫系統
• D.數據庫存儲在應用程序文件下0.00/1.00

8. SQLite的SQLiteOpenHelper類主要用於

• A.對數據庫的字段進行操作
• B.創建數據庫
• C.操作數據庫0.00/1.00
• D.對數據庫的記錄進行操作

9. SQLiteDatabase的功能是

• A.操作字段
• B.創建數據庫
• C.操作數據庫
• D.操作記錄0.00/

10. Cursor對象

• A.主要用於向數據庫中寫入信息
• B.是一個數據列集合
• C.是一個數據行集合1.00/1.00
• D.是一個使用鍵值對方式的數據容器

11. SharePreferences保存的數據在程序結束後：

• A.數據會不存在
• B.數據仍會保存1.00/1.00
• C.別的應用程序不能對其存取
• D.數據存在，但會丟失訪問的路徑

12. SharedPreferences添加數據後需要

• A.不需要進行任何操作
• B.用commit()方法提交1.00/1.00
• C.用close()方法結束
• D.用Flush()方法刷新

13. Android系統

• A.只能用Android系統提供的方法操作SQLite數據庫
• B.只提供了execSQL方法來使用SQL命令操作SQLite數據庫
• C.不能直接操作數據庫
• D.可以使用SQL或Android提供方法操作SQLite數據庫1.00/1.00