【android编程】第十一讲-数据储存

第十一讲数据储存 文章目录第十一讲数据储存0. 学习指导1.使用SharedPreferences示例2.sqlite数据库编程SQLiteOpenHelper类 常用方法自定义数据库子类（继承 SQLiteOpenHelper 类）创建数据库：getWritableDatabase（）、getReadableDatabase（）操作数据库（增、删、查、改）示例题目记录 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//databases文 件夹中。

使用SQLite数据库的步骤如下:
1.创建数据库;
2.打开数据库;
3.创建表;
4.完成数据的增删改查操作;
5.关闭数据库。

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 类）

 
public class DatabaseHelper extends SQLiteOpenHelper {
    // 数据库版本号
    private static Integer Version = 1;
     
    public DatabaseHelper(Context context, String name, SQLiteDatabase.CursorFactory factory,
                          int version) {
        // 参数说明
        // context：上下文对象
        // name：数据库名称
        // param：一个可选的游标工厂（通常是 Null） 
        // version：当前数据库的版本，值必须是整数并且是递增的状态
        // 必须通过super调用父类的构造函数
        super(context, name, factory, version);
    }
     
    @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() 第一次被调用时才会进行创建 / 打开 
    }
     
    @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 打开 可读的数据库

注：当需操作数据库时，都必须先创建数据库对象 & 创建 / 打开数据库。

对于操作 = “增、删、改（更新）”，需获得 可"读 / 写"的权限：

getWritableDatabase()

对于操作 = “查询”，需获得 可"读 "的权限

getReadableDatabase()

操作数据库（增、删、查、改）

 
      // a. 创建DatabaseHelper对象
      // 注：一定要传入最新的数据库版本号
      SQLiteOpenHelper dbHelper = new DatabaseHelper(SQLiteActivity.this,"test_carson"，2);
      // b.创建 or 打开 可读/写的数据库
      SQLiteDatabase sqliteDatabase = dbHelper.getWritableDatabase();
   
        // 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) ；
   
        // 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);
  
        // 删除 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);
  
        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);
  
        // 方法说明
        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);
  
        sqliteDatabase.close();  
  
        // 删除 名为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;

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();
            }
        }
    }
}

题目记录 SharedPreferences数据存取方式是： A.直接存取指定的数据类型 B.键值对1.00/1.00 C.文本 D.数值 SharedPreferences存储的数据类型是 A.只用于文本 B.可以使用泛型 C.主要用于基本数据类型1.00/1.00 D.只用于数值 可以通过下列哪个方法打开SharePreferences: A.editSharedPreferences()0.00/ B.openSharedPerferences() 000 **C.getSharedPreferences()**1.00 D.attachSharedPreferences() 向SharedPreferences类中增加值的第一步是： A.获得SharedPreferences.Input对象 B.获得SharedPreferences.Inflator对象 C.获得SharedPreerences.Editor对象1.00/1.00 D.获得SharedPreferences.adpter对象 向SharedPreferences中添加数据可以使用 A.Print方法 B.putXXX方法1.00/1.00 C.writeXXX方法 D.write方法 下列对SQLite的描述哪一个是正确的 A.是一种Android专用的，使用键值对的数据存储系统 B.是Android的一种特殊的数据文件000 C.是Android内置的数据库系统 D.是一种基于Java的数据库0.00/1.00 SQLite A.只是一个简单的类数据库的数据文件系统 B.提供了完整的关系型数据库能力 C.是一种使用键值对的数据库系统 D.数据库存储在应用程序文件下0.00/1.00 SQLite的SQLiteOpenHelper类主要用于 A.对数据库的字段进行操作 B.创建数据库 C.操作数据库0.00/1.00 D.对数据库的记录进行操作 SQLiteDatabase的功能是 A.操作字段 B.创建数据库 C.操作数据库 D.操作记录0.00/ Cursor对象 A.主要用于向数据库中写入信息 B.是一个数据列集合 C.是一个数据行集合1.00/1.00 D.是一个使用键值对方式的数据容器 SharePreferences保存的数据在程序结束后： A.数据会不存在 B.数据仍会保存1.00/1.00 C.别的应用程序不能对其存取 D.数据存在，但会丢失访问的路径 SharedPreferences添加数据后需要 A.不需要进行任何操作 B.用commit()方法提交1.00/1.00 C.用close()方法结束 D.用Flush()方法刷新 Android系统 A.只能用Android系统提供的方法操作SQLite数据库 B.只提供了execSQL方法来使用SQL命令操作SQLite数据库 C.不能直接操作数据库 D.可以使用SQL或Android提供方法操作SQLite数据库1.00/1.00
作者：江山点墨