《第一行代码》读书手札

Android中，持久化存储，常见的一共有三种方法实现

（一.）利用文件存储

文件存储是Android存储中，最基本的一种存储方式。

就是利用Context类的方法，获取输入输出字节流对象，之后，就是java的文件操作。

特点：

不对存储的数据进行任何格式化的处理
所有的数据，都原封不动的保存在文件中。
基于以上两点，文件存储只适合存储简单的文本数据

假如，非要存储一些复杂数据，就需要自己定义一套格式，便于将数据解析出来。

简单说，就适合存储简单的数据文本，复杂的数据，请使用下面介绍的两种方法存储

a. 如何将数据存储到文件中

使用Context类的openFileOutput()方法，将数据存储到文本中，从名字也可

以看出来Output,将内存中的数据输出到硬盘中的，是用来保存数据的。

openFileOutput()方法

接受两个参数：

第一个参数：表示保存的文件的名字，这个名字中不能包含路径，因为所有的文件都是默认存

储到 /data/data/<包名>files/ 目录下。
第二个参数：表示文件的操作模式。目前只有两种模式了，其他模式由于安全性已经废弃了。

MODE_PRIVATE ：若文件已存在，则复写文件。

MODE_APPEND ：若文件已存在，则续写；文件不存在，就新建，再写文件。

返回值：

1. 返回一个FileOutputStream 对象，就是java中的字节流对象，下面操作跟

java的IO流一样。

注意返回的是字节流，当我们操作的是文本数据，想使用字符流，需要转换流转换一下。

b.利用FileOutputStream对象，将数据存储到文件中

获取到FileOutputStream对象，存储文件，跟Java中一样。笔者，自定义一个save（）方法，将数据存储到本地文件中。

    /**

     * 保存数据到文本中

     *

     * @param inputText 需要保存的文本

     */

    public void save(String inputText) {

        FileOutputStream out = null;

        BufferedWriter writer = null;

//      异常不能抛出去，因为活动的父类，没有抛出异常，作为子类也不能抛出异常

        try {

        //文件名中，不能包含路径

            out = openFileOutput("myData", Context.MODE_PRIVATE);

//           转换流

            writer = new BufferedWriter(new OutputStreamWriter(out));

//          将数据保存到本地

            writer.write(inputText);

//           刷新缓冲区

            writer.flush();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

//            关闭缓冲区

            try {

                if (out != null) {

                    out.close();

                }

                if (writer != null) {

                    writer.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

上述方法需要在活动的onDestory()中调用，在销毁活动的时候，将活动中的数

据，保存下来。

    在onDetory()方法中调用sava方法

    /**

     * 重写onDestory()方法

     * 在里面保存数据

     */

    @Override

    protected void onDestroy() {

        super.onDestroy();

        String txt = edt_in.getText().toString();

    //文件为空，就不再保存

        if (!txt.equals(""))

            save(txt);

    }

c.从文本中读取数据

Context还提供了一个openFileInput（）方法，返回一个FileInputStream对象，

接下来，就是跟java一样的操作。

    /**

     * 读取文件中的数据

     */

    public String load(){

//        Context的openFileInput（）方法，返回一个字节流对象

        FileInputStream inputStream = null ;

//        字符操作，使用带缓冲区的字符流

        BufferedReader reader = null ;

//       字符串缓冲区，为了防止数据过多的情况下，频繁的创建字符串

        StringBuffer content = new StringBuffer() ;

        try {

//            获取字节流对象。参数为 文件名

//            它会自动的去保存的时候的路径

//            /data/data/<包名>files/ 目录下寻找

            inputStream = openFileInput("myData") ;

//            将字节流转换为带缓冲区的字符流

            reader = new BufferedReader(new InputStreamReader(inputStream)) ;

//           做标记，只要line不为null，就一直读取

//           顺便临时保留每次读取的行内容

            String line = "" ;

//            每次读取一行内容

            while((line = reader.readLine())!=null){

//                将读取的内容，保存到字符串缓冲区中

                content.append(line) ;

            }

        }catch (IOException e){

            e.printStackTrace();

        }

        return content.toString() ;

    }

d.恢复数据

b中，在活动被销毁的时候，将瞬时数据保存到本地文件中，那么，再次打开活动的时候，怎么将数据恢

复到活动中呢？

恢复数据，很简单，活动在第一次被创建的时候，一定会调用onCreate（）方

法，我们就在这里，做恢复数据的工作。恢复之前，先做个判断，判读读取的数

据，是否为空串啥的。

 @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

//        获得控件对象

        edt_in = (EditText) findViewById(R.id.edt_in);

//        读取数据

        String input = load() ;

//          判断是否需要恢复数据

//          TextUtils.isEmpty(input)

//          会判断是否为空串或者为null

        if(!TextUtils.isEmpty(input)){

//           非空就恢复数据

            edt_in.setText(input);

//            人性化操作，将输入的光标移动到文本末尾

            edt_in.setSelection(input.length());

        }

（二.）利用 SharePreferences 存储

特点：

1. 使用键值对存取数据

2. 保留数据原有格式，存进去的是整形，取出来的还是整形，

    与利用文件存储不一样，利用文件存储，会将所有数据，都当做字符串保存

3. 数据的存储，都是存储到文件中，这里是存储到SharePreferences文件中，该

文件是xml格式。

想要将数据存储到SharePreferences文件中，首先需要获取

SharePreferences对象，其中，SharePreferences文件被保存在/data/data/

<包名>/shared_prefs/目录下

a.如何获取SharePreferences对象

1.Context类的getSharePreferences（）方法

该方法接收两个参数

第一个参数，是SharePreferences文件的名字，如果文件不存在，就会自动新建一个。SharePrefe

rences文件被保存在/data/data/<包名>/shared_prefs/目录下

第二个参数，代表操作模式，目前只剩下一个默认模式：MODE_PRIVATE，和直接传入0效果一样,表示

只有当前的应用程序，才可以对该SharePreferences文件进行读写。

2.Activity类的getPreferences（）方法

总体上跟Context的getSharePreferences（）方法很类似

该方法只接收一个参数

参数，代表操作模式，目前只剩下一个默认模式：MODE_PRIVATE，和直接传入0效果一样,表示只有

当前的应用程序，才可以对该SharePreferences文件进行读写。

该房啊会自动将当前活动的类名作为SharePreferences的文件名。

3.PreferenceManger类getDefaultSharedPreferences（）方法

该方法是一个静态方法

接收一个Context参数，可以将当前活动的对象传进去，活动是一个Context类型

会自动将当前应用程序的包名作为前缀，来命名SharePreferences文件

b.如何存储数据

调用SharePreferences类的edit（）方法，获得SharePreferences.Editor对象

将数据添加到SharePreferences.Editor对象中；

添加什么类型的数据就使用对应的方法：

添加字符串，putString（）

添加整形，putInt（）

SharePreferences.Editor对象的apply（）方法，提交数据。

获取 SharePreferences对象，并保存储数据：

 /**

     * 将数据存储到SharePreferences文件中

     */

    public void save() {

//        获取SharePreferences对象

        SharedPreferences preferences = getSharedPreferences("mySharePres", 0);

//        获取SharePreferences.Editor对象

        SharedPreferences.Editor editor = preferences.edit();

//        获取数据

        String str = edt_str.getText().toString();

        String str_num = edt_int.getText().toString();

//        只要有一个为空，就不保存

        if (TextUtils.isEmpty(str) || TextUtils.isEmpty(str_num)) {

            return;

        }

//        进行转换

        int num = Integer.parseInt(str_num);

//        保存数据,键值对

        editor.putInt("num",num) ;

        editor.putString("str",str) ;

//        提交数据

        editor.apply();

    }

c.如何恢复数据

获得SharePreferences

调用getXXX（）方法，获取对应的数据

该方法接收两个参数

第一个参是键值对的键；

第二个参数是默认值，就是没找到传入的键，就返回这个默认值

    /**

     * loading 方法

     */

    public void load(){

//        获取SharePres 对象

        SharedPreferences preferences = getSharedPreferences("mySharePres",0) ;

//        获取数据

        String str = preferences.getString("str","haha") ;

        int num = preferences.getInt("num",0) ;

//        设置数据

        edt_str.setText(str);

        edt_int.setText(num+"");

    }

可以使用SharedPreferences，做一个记住密码的功能

笔者做了一个demo，主要功能就是，用户输入用户名和密码以后，在点击登录按钮的时候，

先做个判断，判断是否选中记住密码，如果选中，则保存用户名和密码。

实质，无论是否选中记住密码，都会执行记住密码这一动作，唯一的差别，就是保存的密码，是密码还

是空串的区别。选中保存密码，就保存密码；没选中保存尼玛，就将密码保存为空串。

记住密码功能的完整代码：

/**

* 记住密码类

*/

public class Keep_name_paw extends AppCompatActivity implements View.OnClickListener {

    //        设置为全局变量，因为下面的多个方法中都会用到

//        获取SharePres对象

//        权限设置为append，

    SharedPreferences preferences ;

    //        获取Editor对象

    SharedPreferences.Editor editor ;

    EditText edt_name, edt_pass;

    CheckBox checkBox;

    Button btn;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_keep_name_paw);

        preferences = getSharedPreferences("keepNamepass", MODE_APPEND);

        editor = preferences.edit();

        edt_name = (EditText) findViewById(R.id.edt_name);

        edt_pass = (EditText) findViewById(R.id.edt_pass);

        btn = (Button) findViewById(R.id.button);

        checkBox = (CheckBox) findViewById(R.id.checkBox);

        btn.setOnClickListener(this);

            /*

            对名字输入进行监听，如果这个用户名，之前选过记住密码，

            就自动为其补全密码

            使用addTextChangedListener()监听器

            需要复写三个方法，我们这里只用到文字发现改变的逻辑，

            因此，另外两个方法，为空就好了

             */

        edt_name.addTextChangedListener(new TextWatcher() {

            @Override

            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

            @Override

            public void onTextChanged(CharSequence s, int start, int before, int count) {

//            去SharePres文件中查找

                String key = edt_name.getText().toString() ;

                String value = load(key) ;

//                设置密码框

                edt_pass.setText(value);

            }

            @Override

            public void afterTextChanged(Editable s) {}

        }) ;

    }

    @Override

    public void onClick(View v) {

        switch (v.getId()) {

            case R.id.button:

//               读取数据

                String key = edt_name.getText().toString();

                String value = edt_pass.getText().toString();

//                判断是否选中记住密码

                if (!checkBox.isChecked()) {

//                    如果没选中

//                    就将之前保存的数据，的值，用空白替代

//                    这里我们，不能调用editor.clear（）方法，

//                    这样整个SharePres文件就会被删除，其他用户的数据也被删除了

//                    就是用空白代替值value，进行保存

                    value = "";

                }

//               进行保存

                save(key, value);

                break;

        }

    }

    /**

     * 使用SharePreferences保存数据

     *

     * @param key   键

     * @param value 值

     */

    void save(String key, String value) {

//      保存数据

//      key就直接使用用户名，这样可以记住不同的账号和对应的密码

        editor.putString(key, value);

//        提交数据

        editor.apply();

    }

    /**

     * 加载数据

     */

    String load(String key) {

        String value = null;

//        读取数据,

//        第二个参数是默认值，如果没有对应的键，就返回默认值，这里是空串

        value = preferences.getString(key, "");

        return value;

    }

}

布局图片

Android持久化存储——（包含操作SQLite数据库）

<!--布局代码-->

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:id="@+id/activity_keep_name_paw"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">

    <LinearLayout

        android:layout_margin="10dp"

        android:orientation="horizontal"

        android:layout_width="match_parent"

        android:layout_height="wrap_content">

        <TextView

            android:text="账 号"

            android:textSize="25sp"

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:id="@+id/textView2" />

        <EditText

            android:layout_width="0dp"

            android:layout_height="wrap_content"

            android:maxLines="1"

            android:id="@+id/edt_name"

            android:layout_weight="1" />

    </LinearLayout>

    <LinearLayout

        android:layout_margin="10dp"

        android:orientation="horizontal"

        android:layout_width="match_parent"

        android:layout_height="wrap_content">

        <TextView

            android:text="密 码"

            android:textSize="25sp"

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:id="@+id/textView3" />

        <EditText

            android:layout_width="0dp"

            android:layout_height="wrap_content"

            android:maxLines="1"

            android:id="@+id/edt_pass"

            android:layout_weight="1" />

    </LinearLayout>

    <CheckBox

        android:text="记住密码"

        android:textColor="#abd123"

        android:textSize="20sp"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:id="@+id/checkBox" />

    <Button

        android:text="登 录"

        android:textSize="25sp"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:padding="15dp"

        android:layout_gravity="right"

        android:layout_margin="10dp"

        android:id="@+id/button" />

</LinearLayout>

（三）利用SQL数据库存储

在前面介绍的两种方法中，存储的数据都是一些简单的数据；假如，我们需要保存一些具有关系型的数

据，前面的2种方法，将不再好用；对于关系型数据，首选项应该是数据库存储。

巧了，Android系统是内嵌sql数据库的。

这里将介绍两种操作数据库的方式。

1、使用SQLiteOpenHelper帮助类

Android为了我们，可以方便的操控数据库，提供了这个帮助类。感谢Android给与我们方便

a、什么是 SQLiteOpenHelper 帮助类

特点：

1. 是一个抽象类，因此，我们需要自己创建一个帮助类去继承它；

2. 有两个抽象方法：

创建数据库 onCreate( )；

升级数据库 onUpgrade( ) ;

3. 有两个实例方法：

返回SQLiteDatabase对象。

getReadableDatabase( ) ;

getWriteableDatabase( ) ;

共同点：

这两个方法都可以创建或者打开一个现有的数据库（就是说，如果数据库已经存

在，就直接打开；不存在，就先新建一个数据库，再打开），并返回一个可对数

据库进行读写操作的对象。千万不要被字面意思骗了，以为Readable，就只能

进行读，不能对数据库进行写操作，两个方法，返回的对象，对数据库既可以进

行写操作，也可以进行读操作。

不同点：

在数据库可以写入的情况下

两个方法返回的对象，都可以对数据库进行读写操作。

在数据库不可写入的时候

getReadableDatabase( ) 方法，将以只读方式打开数据库；

getWriteableDatabase( )方法将抛出异常;

b、如何创建自己的帮助类

道理我都懂，怎么创建自己的数据库帮助类？

上面已经提到，需要我们重写一个帮组类，继承自SQLiteOpenHelper类。

要想继承一个类，首先需要明确人家的构造器是什么样的？

SQLiteOpenHelper类一共有两个构造器，这里我们选择参数个数少的那一个，一个有四个参数。

第一个参数 Context

当前调用SQLiteOpenHelper的Activity对象的context

第二个参数 String

数据库的名字；创建数据库的名字，就是依据它；要加上后缀.db

第三个参数 SQLiteDatabase.CursorFactory

在查询数据的时候，可以返回一个自定义的Cursor,这里写null即可

第四个参数 int

表示当前数据库的版本号，用于对数据库的升级

c、利用自己的数据库帮助类，创建数据库

创建的数据库文件，保存在/data/data/<包名>/databases/目录下

步骤：

1. 根据b中的构造器，创建自己数据库帮助类的实例

2. 再调用继承来的实例方法 getReadableDatabase( )、 getWriteableDatabase( )

3. 在调用继承来的实例方法，创建数据库时，我们复写的SQLiteOpenHelper类

的onCreate( ) 方法会被调用。通常在这里执行创建表的操作。

建立Book表的SQL语句：

很简单的sql语句

假如，你不太会sql语句，没关系，后面的LitePal操控数据库，将不需要写sql语句，完全是面向对象

的思想，在操控数据库。

create table Book (

    id integer primary key autoincrement ,

    author text,

    pages integer ,

    price real )

自定义的数据库帮助类

注意onCreate()方法

public class MySqliteOpenHelper extends SQLiteOpenHelper{

    String book_sql = "create table Book (\n" +

            "\t id integer primary key autoincrement ,\n" +

            "\t author text,\n" +

            "\t pages integer ,\n" +

            "\t price real,\n"

            "\t name text )" ;

    Context context ;

    public MySqliteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {

        super(context, name, factory, version);

        this.context = context ;

    }

    /**

     * 在调用实例方法的时候，如果数据库还未创建,这个方法就会被回调

     * 这个方法，仅在创建数据库的时候，得到调用

     * @param db

     */

    @Override

    public void onCreate(SQLiteDatabase db) {

        db.execSQL(book_sql);

        //这个Toast仅会弹出一次

        Toast.makeText(context,"数据库已创建",Toast.LENGTH_SHORT).show();

    }

    @Override

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

}

通过点击按钮创建数据库

在活动类中，对按钮设置监听器，在监听器里面创建数据库

public class Create_sql extends AppCompatActivity{

    private Button btn_createSql ;

    private MySqliteOpenHelper mySqliteOpenHelper ;

    @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.create_sql_layout);

//        创建自己的数据库帮助类

        mySqliteOpenHelper = new MySqliteOpenHelper(this,"myDatabase.db",null,1) ;

//        获取按钮控件

        btn_createSql = (Button) findViewById(R.id.btn_createSql);

//        设置监听器

        btn_createSql.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

//                获取可对数据库进行读写的对象

//                当我们第一次点击按钮的时候，会自动创建数据库

                mySqliteOpenHelper.getWritableDatabase() ;

            }

        });

    }

}

思考：

这里有个问题，既然，我们把创建表的语句，写在onCreate()方法中，但是这个方法仅仅在创建数据

库的时候，会被调用一次。那么我们在以后，还想创建新的表怎么办呢？

答案：

刚刚有一个方法onUpgrade（），我们一直没用，从名字也可以看出，这个方法是升级数据库的。

既然，后续我们需要新增表，说明我们的数据库，需要升级，那么我们，就在这个升级数据库的方法

里，写上我们的逻辑。onUpgrade（）方法，当程序发现，数据库版本号不一样的时候，就会调用

这个方法。因此，当我们需要升级数据库的时候，在创建数据库帮助类实例的时候，传入的版本号，

比之前大，就好了。

升级数据库（并不会将原有的数据库删除）

在库里面新增一张表,如果是对原有的表进行更新，需要先将原有的表删除，再新建。否则，程序会报错

因为，并不会将原有的数据库删除，因此，onCreate（）方法，不会得到回调。

只会显式的回调onUpgrade（）方法，但是我们可以在onUpgrade（）方法中显式的调用这个方法。

sql语句

create table Category (

    id integer primary key autoincrement,

    category_name text,

    category_code integer )

onUpgrade（）方法

简单的写上新建表语句

  @Override

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

        db.execSQL(Category_sql);

    }

改变数据库的版本号

//        创建自己的数据库帮助类，将版本号从1变为2 。

        mySqliteOpenHelper = new MySqliteOpenHelper(this,"myDatabase.db",null,2) ;

总结：

我们可以看出来，我们只需要管理，创建数据库 onCreate( )；升级数据库

onUpgrade( ) ;这两个方法。而对于getReadableDatabase( ) 、

getWriteableDatabase( ) ;这两个方法，我们只需要用数据库帮助类实例去调

用即可。当我们调用的时候，如果没有数据库，它们就会回调onCreate（）方

法，创建数据库；如果发现数据库版本号发现变化，就会回调onUpgrade( )方

法；否则，就简单的返回一个可对数据库进行读写的对象- - -SQLiteDatabase。

onUpgrade( )中的逻辑：

如果不是只新建一张表，而是需要要在原有表上新添加一列呢？

这里需要注意，是否需要保存原有数据，如果不需要保存，直接删除，再新建

表；如果，需要保存原有数据，则将原来的表名，更名为一张临时表，再新建一

张表，这张表中有我们需要的新列，表名字跟原来的表一样。再将临时表中的数

据复制过来，最后，删除临时表。

在Android里，我们并不需要对sql语句如何熟悉！但是，我们却同样可以完成CRUD动作。这都要

归功于数据库帮助类实例方法返回的SQLiteDatabase对象。

CRUD- — -添加数据

方法： SQLiteDatabase对象的 insert( )

 接受三个参数；

第一个参数是表名

想往哪张表里面添加数据，就写哪张表的名字

第二个参数是默认值，这里我们写null，即可

用于，我们没指定添加数据的情况下，给那些可为空的列，自动赋值为null

第三个参数是 ContentValues对象

该对象，提供了一系列put( )方法重载，利用put方法将数据保存到ContentValues对象中，

put( )方法接受两个参数

第一个参数是表中的列名；

第二个参数是列名对应的数据；

一个ContentValues对象，只能保存一条数据，在有多条数据的时候，每次装完一条数据的时候，需要

clear()一下。

添加数据的代码：

这里仅给出关键代码，就是在按钮监听器中执行这一段添加数据的逻辑代码。

btn_insert.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

//                添加数据，首先需要获取SQLiteDatabase对象

                SQLiteDatabase sqLiteDatabase = mySqliteOpenHelper.getReadableDatabase() ;

//                再创建ContentValues对象，保存数据

                ContentValues contentValues = new ContentValues() ;

//                添加数据

//                描述第一条数据

                contentValues.put("name","第一行代码");

                contentValues.put("price","59");

                contentValues.put("pages","570");

                contentValues.put("author","郭霖");

//                添加第一条数据

                sqLiteDatabase.insert("Book",null,contentValues) ;

//                清除第一条数据，再添加第二条数据

                contentValues.clear();

//                描述第二条数据

                contentValues.put("name","肥嘟嘟左卫门");

                contentValues.put("price","46");

                contentValues.put("author","野原新之助");

                contentValues.put("pages","2");

//                添加第二条数据

                sqLiteDatabase.insert("Book",null,contentValues) ;

            }

        });

查看数据库：

笔者刚刚一共点击了3次按钮，因此，生成6条数据；

Android持久化存储——（包含操作SQLite数据库）

CRUD- — -更新数据

方法： SQLiteDatabase对象的 update( )

 接受四个参数；

第一个参数是表名

想往哪张表里面更新数据，就写哪张表的名字

第二个参数是 ContentValues对象

经过上面学习，我们已经知道，这个对象，就像是一个容器，保存，我们的数据；因此，这里，我们将

要更新的数据也放在这里面

第三、四个参数

用于约束更细某一行或者某几行中的数据，如不指定，默认更新所有行。

第三个参数是字符串，相当于where部分，这里写上你想跟新的字段，一般写上？占位符

第四个参数，是一个字符串数组，指明前面的？是谁。

更新数据代码：

//                更新数据，还是需要获取SQLiteDatabase对象

                SQLiteDatabase sqLiteDatabase = mySqliteOpenHelper.getReadableDatabase() ;

//                再创建ContentValues对象，保存数据

                ContentValues contentValues = new ContentValues() ;

//                写上要更新的数据

                contentValues.put("price",50);

//                将name是第一行代码 的数据的price更新为50

                sqLiteDatabase.update("Book",contentValues,"name = ? ",new String[]{"第一行代码"}) ;

//      清除之前contentValues的数据，否则下次更新，会将之前的数据也更新进来

                contentValues.clear();

                contentValues.put("pages",10);

//              将所有pages是130的，都更新为10

                sqLiteDatabase.update("Book",contentValues,"pages = ? ",new String[]{"130"}) ;

更新以后数据截图

笔者刚刚又点了2次添加数据按钮，因此数据多了4条

并且笔者，特意contentValues.clear();把这行注释了，

因此，我们可以发现之前pages=130的，不但pages被更新为10，就连price也被更新为50了

因此，验证了，笔者之前说的话：如果，没有清除之前contentValues的数据，下次更新，会将之前的

数据也更新进来

Android持久化存储——（包含操作SQLite数据库）

## CRUD- — -删除数据

----------

方法： SQLiteDatabase对象的 update( )

 接受四个参数；

第一个参数是表名

想删除哪张表的数据，就写哪张表的名字

第二、三个参数

同样是用来删除哪一行的数据，不指定的话，就删除所有行。

删除第一行代码的数据

肥嘟嘟左卫门，是小新的书诶！不能删除。。委屈一下郭神

                SQLiteDatabase sqLiteDatabase = mySqliteOpenHelper.getReadableDatabase() ;

//            删除第一行代码数据的数据

                sqLiteDatabase.delete("Book","name=?",new String[]{"第一行代码"}) ;

效果图：

可以看到，仅剩下小新的书了。

Android持久化存储——（包含操作SQLite数据库）

## CRUD- — -查询数据

最重要的一种操作。

方法： SQLiteDatabase对象的 query( )

这个方法的重载非常复杂，最短的一个方法重载，也需要7个参数。

我们，重点看7个参数的重载方法。

但是，并不是每次查询都需要，写满7个参数。大多数情况下，只需要传入少数几个参数，就可以完成查

询操作。

参数：

1. table - - - - 指定查询的表名；

2. columns - - - - 指定查询的列名；

3. selection - - - - 指定where的约束条件

4. selectionArgs - - - - 为where中的占位符提供具体的值

5.groupBy - - - - 指定需要group by 的列

6. having - - - - 对group by 的结果进行进一步的约束

7.orderBy - - - - 指定查询结果的排序方式

返回值：

方法返回一个Cursor对象，查询到的所有数据都将从这个对象中取出。

获取 Cursor对象中的数据

1. moveToFirst（）先判断 Cursor对象中是否有数据，将数据的指针移到第一

行，有数据，就返回真，没数据就返回假；

2.moveToNext（）将数据指针移动到下一行，同样返回真（有数据）、假

（没有数据）；跟迭代器用法类似。

3.获取一行中某个字段的值：使用Cursor对象的getColumnIndex(列名);获取该列

在表中的索引，再调用Cursor对象的getXXX(索引）方法，即可获取到该列的数

据。

4.最后需要关闭Curson对象

代码：

//                查询数据

                SQLiteDatabase sqLiteDatabase = mySqliteOpenHelper.getReadableDatabase() ;

//      写入的参数，代表将整张表数据都查询出来

                Cursor cursor = sqLiteDatabase.query("Book",null,null,null,null,null,null);

//           将数据指针移动第一行

     if(cursor.moveToFirst()){

       do{

          int id = cursor.getInt(cursor.getColumnIndex("id")) ;

          int pages = cursor.getInt(cursor.getColumnIndex("pages")) ;

          String name = cursor.getString(cursor.getColumnIndex("name")) ;

          String  author = cursor.getString(cursor.getColumnIndex("author")) ;

          float price = cursor.getFloat(cursor.getColumnIndex("price")) ;

          Log.d("sql_query", id+" "+pages+" "+name+" "+author+" "+price);

         }while(cursor.moveToNext()) ;

      }

//     还需要关闭Cursor

       cursor.close();

查询图：

Android持久化存储——（包含操作SQLite数据库）

查询Book表中，id和name列的数据，其中id必须大于3

  Cursor cursor = sqLiteDatabase.query("Book",new String[]{"id","name"},"id>?",new String[]{"3"},null,null,null);

查询图

Android持久化存储——（包含操作SQLite数据库）

Android持久化存储——（包含操作SQLite数据库）

Android中，持久化存储，常见的一共有三种方法实现

（一.）利用文件存储

特点：

a. 如何将数据存储到文件中

使用Context类的openFileOutput()方法，将数据存储到文本中，从名字也可

以看出来Output,将内存中的数据输出到硬盘中的，是用来保存数据的。

openFileOutput()方法

接受两个参数：

返回值：

1. 返回一个FileOutputStream 对象，就是java中的字节流对象，下面操作跟

java的IO流一样。

b.利用FileOutputStream对象，将数据存储到文件中

上述方法需要在活动的onDestory()中调用，在销毁活动的时候，将活动中的数

据，保存下来。

c.从文本中读取数据

Context还提供了一个openFileInput（）方法，返回一个FileInputStream对象，

接下来，就是跟java一样的操作。

d.恢复数据

恢复数据，很简单，活动在第一次被创建的时候，一定会调用onCreate（）方

法，我们就在这里，做恢复数据的工作。恢复之前，先做个判断，判读读取的数

据，是否为空串啥的。

（二.）利用 SharePreferences 存储

特点：

1. 使用键值对存取数据

2. 保留数据原有格式，存进去的是整形，取出来的还是整形，

3. 数据的存储，都是存储到文件中，这里是存储到SharePreferences文件中，该

文件是xml格式。

想要将数据存储到SharePreferences文件中，首先需要获取

SharePreferences对象，其中，SharePreferences文件被保存在/data/data/

<包名>/shared_prefs/目录下

a.如何获取SharePreferences对象

1.Context类的getSharePreferences（）方法

2.Activity类的getPreferences（）方法

3.PreferenceManger类getDefaultSharedPreferences（） 方法

b.如何存储数据

获取 SharePreferences对象，并保存储数据：

c.如何恢复数据

可以使用SharedPreferences，做一个记住密码的功能

记住密码功能的完整代码：

布局图片

（三）利用SQL数据库存储

1、使用SQLiteOpenHelper帮助类

a、什么是 SQLiteOpenHelper 帮助类

特点：

1. 是一个抽象类，因此，我们需要自己创建一个帮助类去继承它；

2. 有两个抽象方法：

创建数据库 onCreate( )；

升级数据库 onUpgrade( ) ;

3. 有两个实例方法：

返回SQLiteDatabase对象。

getReadableDatabase( ) ;

getWriteableDatabase( ) ;

共同点：

这两个方法都可以创建或者打开一个现有的数据库（就是说，如果数据库已经存

在，就直接打开；不存在，就先新建一个数据库，再打开），并返回一个可对数

据库进行读写操作的对象。千万不要被字面意思骗了，以为Readable，就只能

进行读，不能对数据库进行写操作，两个方法，返回的对象，对数据库既可以进

行写操作，也可以进行读操作。

不同点：

在数据库可以写入的情况下

两个方法返回的对象，都可以对数据库进行读写操作。

在数据库不可写入的时候

getReadableDatabase( ) 方法，将以只读方式打开数据库；

getWriteableDatabase( )方法将抛出异常;

b、如何创建自己的帮助类

第一个参数 Context

第二个参数 String

第三个参数 SQLiteDatabase.CursorFactory

第四个参数 int

c、利用自己的数据库帮助类，创建数据库

步骤：

1. 根据b中的构造器，创建自己数据库帮助类的实例

2. 再调用继承来的实例方法 getReadableDatabase( )、 getWriteableDatabase( )

3. 在调用继承来的实例方法，创建数据库时，我们复写的SQLiteOpenHelper类

的onCreate( ) 方法会被调用。通常在这里执行创建表的操作。

建立Book表的SQL语句：

自定义的数据库帮助类

通过点击按钮创建数据库

思考：

3.PreferenceManger类getDefaultSharedPreferences（）方法

第一个参数是表名

第二个参数是默认值，这里我们写null，即可

添加数据的代码：

第一个参数是表名

第一个参数是表名

1. moveToFirst（）先判断 Cursor对象中是否有数据，将数据的指针移到第一

2.moveToNext（）将数据指针移动到下一行，同样返回真（有数据）、假

3.获取一行中某个字段的值：使用Cursor对象的getColumnIndex(列名);获取该列