Android应用开发：数据存储和界面展现-1

亦凉 2022-09-27 09:17 126阅读 0赞

# **1. 相对布局RelativeLayout** #

特点：相对布局所有组件可以叠加在一起；各个组件的布局是独立的，互不影响；所有组件的默认位置都是在左上角（顶部、左部对齐）

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">android:layout_toRightOf</td> 
   <td align="left">在指定控件的右边</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_toLeftOf</td> 
   <td align="left">在指定控件的左边</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_above</td> 
   <td align="left">在指定控件的上边</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_below</td> 
   <td align="left">在指定控件的下边</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignBaseline</td> 
   <td align="left">跟指定控件水平对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignLeft</td> 
   <td align="left">跟指定控件左对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignRight</td> 
   <td align="left">跟指定控件右对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignTop</td> 
   <td align="left">跟指定控件顶部对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignBottom</td> 
   <td align="left">跟指定控件底部对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignParentLeft</td> 
   <td align="left">是否跟父元素左对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignParentTop</td> 
   <td align="left">是否跟父元素顶部对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignParentRight</td> 
   <td align="left">是否跟父元素右对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_alignParentBottom</td> 
   <td align="left">是否跟父元素底部对齐</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_centerVertical</td> 
   <td align="left">在父元素中垂直居中</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_centerHorizontal</td> 
   <td align="left">在父元素中水平居中</td> 
  </tr> 
  <tr> 
   <td align="left">android:layout_centerInParent</td> 
   <td align="left">在父元素中居中</td> 
  </tr> 
 </tbody> 
</table>

示例1：res\\layout\\activity\_main.xml

运行结果：

![img][]

示例2：res\\layout\\activity\_main.xml

运行结果：

![img][img 1]

示例3：res\\layout\\activity\_main.xml

运行结果：

![img][img 2]

练习：实现如下效果

![img][img 3]

代码：res\\layout\\activity\_main.xml

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" >
        <Button android:id="@+id/center" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="中间" android:layout_centerInParent="true"/>
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="上边" android:layout_above="@id/center" android:layout_alignLeft="@id/center" android:layout_alignRight="@id/center"/>
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="下边" android:layout_below="@id/center" android:layout_alignLeft="@id/center" android:layout_alignRight="@id/center"/>
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="左边" android:layout_toLeftOf="@id/center" android:layout_alignTop="@id/center" android:layout_alignBottom="@id/center" android:layout_alignParentLeft="true"/>
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="右边" android:layout_toRightOf="@id/center" android:layout_alignTop="@id/center" android:layout_alignBottom="@id/center" android:layout_alignParentRight="true"/>
            <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="左上" android:layout_toLeftOf="@id/center" android:layout_above="@id/center" android:layout_alignParentLeft="true"/>
            <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="左下" android:layout_toLeftOf="@id/center" android:layout_below="@id/center" android:layout_alignParentLeft="true"/>
            <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="右上" android:layout_toRightOf="@id/center" android:layout_above="@id/center" android:layout_alignParentRight="true"/>
            <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="右下" android:layout_toRightOf="@id/center" android:layout_below="@id/center" android:layout_alignParentRight="true"/>
    </RelativeLayout>

运行结果：

![img][img 4]

# **2. 帧布局FrameLayout** #

特点：帧布局和相对布局一样，组件可以重叠；所有组件的默认位置是在左上角（顶部、左部对齐）  
示例：res\\layout\\activity\_main.xml

运行结果：

![img][img 5]

练习：实现如下效果

![img][img 6]

代码：res\\layout\\activity\_main.xml

运行结果：

![img][img 7]

# **3. 表格布局TableLayout** #

示例：res\\layout\\activity\_main.xml

<TableLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity" >
        
        <TableRow>
            <TextView android:text="姓名："/>
            <EditText android:layout_weight="1" />
        </TableRow>
        <TableRow>
            <TextView android:text="年龄："/>
            <EditText android:layout_weight="1" />
        </TableRow>
    </TableLayout>*复制代码*   运行结果：

![img][img 8]

# **4. 绝对布局AbsoluteLayout** #

绝对布局是直接使用android:layout\_x，android:layout\_y定位控件的坐标，做不了屏幕适配，所以不常使用。某些没有必要做屏幕适配的开发可以用绝对布局，例如：电视屏幕固定，做机顶盒开发。

示例：res\\layout\\activity\_main.xml

<AbsoluteLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity" >
        <Button android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_x="109dp" android:layout_y="83dp" android:text="Button" />
    </AbsoluteLayout>*复制代码*   运行结果：

![img][img 9]

# **4. LogCat** #

Console只能显示Windows下运行的平台信息，例如：模拟器的运行状态（模拟器是运行在Windows平台上的程序）。但模拟器内的程序运行状态就不能显示在Console上了，因为这些程序不是运行到Windows上，这些信息会在LogCat中显示。

LogCat分为5个等级，依次为：error（错误）、warn（情报）、info（信息）、debug（调试）、verbose（冗余）

![img][img 10]

示例：为LogCat添加过滤器，便于筛选信息

src/cn.itcast.logcat/MainActivity.java

package cn.itcast.logcat;
    import android.os.Bundle;
    import android.app.Activity;
    import android.util.Log;
    import android.view.Menu;
    public class MainActivity extends Activity { 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            String tag = "黑马程序员";
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            System.out.println("云鹤，儿童节快乐");
            //tag表示标签，msg表示正文
            //下面这种写法是在日志需要长期保留时使用。
            Log.v(tag, "云鹤就业薪资13000");
            Log.d(tag, "云鹤就业薪资13000");
            Log.i(tag, "云鹤就业薪资13000");
            Log.w(tag, "云鹤就业薪资13000");
            Log.e(tag, "云鹤就业薪资13000");
       }
    }

运行结果：

![img][img 11]

第一步：点击加号

![img][img 12]

第二步：填入过滤器设置信息。

![img][img 13]

第三步：进行过滤。

![img][img 14]

# **5. 在内部存储中读写文件** #

Android内存

*  RAM：运行内存，相当于电脑内存。关机，数据就会丢失。
 *  ROM：内部存储空间，Android系统必须的存储空间，持久化保持数据，相当于电脑的硬盘。
 *  SD卡/USB存储器（内置在手机内）：外部存储空间，对于Android系统是可有可无的，相当于移动硬盘。
 *  内部存储路径：data/data/包名文件夹/，每个包名文件夹都是一个应用的专属空间。

![img][img 15]

示例：res\\layout\\activity\_main.xml

src/cn.itcast.rwinrom/MainActivity.java

package cn.itcast.rwinrom;
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStreamReader;
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.CheckBox;
    import android.widget.EditText;
    import android.widget.Toast;
    public class MainActivity extends Activity { 
        private EditText et_name;
        private EditText et_pass;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            et_name = (EditText) findViewById(R.id.et_name);
            et_pass = (EditText) findViewById(R.id.et_pass);
            readAccount();
        }
        public void login(View v){
                //获取用户输入的数据
                String name = et_name.getText().toString();
                String pass = et_pass.getText().toString();
                CheckBox cb = (CheckBox) findViewById(R.id.cb);
                if(cb.isChecked()){
                        File file = new File("data/data/cn.itcast.rwinrom/info.txt");
                        try{
                                FileOutputStream fos = new FileOutputStream(file);
                                fos.write((name + "##" + pass).getBytes());
                                fos.close();
                        }catch(Exception e){
                                e.printStackTrace();
                        }
                }
                //弹出吐司对话框
                //Activity是Context的子类
                //Toast.LENGTH_LONG表示显示5秒
                //Toast.LENGTH_SHORT表示显示3秒
                Toast.makeText(this, "登陆成功", Toast.LENGTH_LONG).show();
        }
        public void readAccount(){
                File file = new File("data/data/cn.itcast.rwinrom/info.txt");
                if(file.exists()){
                        try{
                                FileInputStream fis = new FileInputStream(file);
                                //把字节流转换成字符流
                                BufferedReader br = new BufferedReader(new InputStreamReader(fis));
                                String text = br.readLine();
                                String[] s = text.split("##");
                                et_name.setText(s[0]);
                                et_pass.setText(s[1]);
                                fis.close();
                        }catch(Exception e){
                                e.printStackTrace();
                        }
                }
        }
    }

运行结果：

1、在模拟器上运行应用程序，输入用户名、密码，勾上记住账号密码，点击登陆。可以看到弹出吐司，登陆成功。

![img][img 16]

2、在Android设备文件目录下，可以看到成功生成info.txt文件，点击右上角的“pull a file from the device”按钮，将info.txt提取出来，保存到桌面。

![img][img 17]

3、打开info.txt文件，可以看到成功存入数据。

![img][img 18]

4、重新运行应用程序，可以看到读取数据成功，用户名、密码成功显示。

![img][img 19]

PS：  
1、点击返回键，会摧毁当前Activity，重新点击应用图标，会重新创建Activity。  
2、点击HOME键，只会将Activity放到后台去，重新点击图标，只是重新提取出来。

所以，上面的应用程序，即使是第一次运行，输入用户名、密码，并且不勾选“记住账户密码”。如果此时点击HOME键，Activity消失。然后，再点击应用程序图标，竟然可以看到Activity显示出了用户名、密码！然而，这根本不是回显，Activity只是暂时放到后台，然后重新提取出来罢了。

3、在内部存储空间中读写不需要任何权限！

## **5.1 使用API获取内部存储空间的路径** ##

如果将上面应用程序的MainActivity类中的代码进行如下修改，可以看到后台报警告。原因是不能访问其他应用程序的专属空间，只能访问自己的。

![img][img 20]

![img][img 21]

为了防止内部存储空间不小心写错，API提供了获取内部存储空间路径的方法。修改后，代码如下：

![img][img 22]

![img][img 23]

运行结果，如下：

![img][img 24]

getFilesDir方法所在的类为上下文包装类，ContextWrapper。

![img][img 25]

并且，Activity就是ContextWrapper的子类。

![img][img 26]

所谓的上下文就是一个应用环境全局信息的接口，也就是说，通过上下文的API可以拿到应用环境的全局信息，例如：包名、版本号、内部存储等信息。  
Toast.makeText(this,”登陆成功”,0).show();语句中的this就是上下文，表示吐司需要显示在哪个上下文中。  
Button bt = new Button(this);语句中的this也是上下文，表示该组件创建出来之后，显示在哪个上下文中。  
谷歌的API还提供了另一个方法获取内部存储空间路径：getCacheDir()，它返回的路径为data/data/cn.itcast.rwinrom/cache，得到的是缓存路径，也就是cache文件夹路径。修改后，代码如下：

![img][img 27]

运行结果，如下：

![img][img 28]

区别：

*  getFilesDir方法返回的路径中的files文件夹是持久化保存数据的。
 *  getCacheDir方法返回的路径中的Cache文件夹是保存缓存数据的。当设备内存可用存储空间比较少时，Cache中的文件可能会被系统删除。

# **6. 在外部存储中读写文件** #

SD卡路径为storage/sdcard（4.3版本），之所以还存在根目录sdcard（2.3版本之前）及mnt/sdcard（2.3版本~4.3版本），是因为早期版本的sd卡路径正是在根目录，后期移到了mnt/sdcard，为了与低版本兼容，所以现在他们还存在，其实只是快捷方式而已，指向的路径依然是storage/sdcard。

![img][img 29]

往SD卡中写数据需要权限。而从SD卡中读取数据在4.0版本以前是不需要权限，后来谷歌在Android系统中添加了保护SD卡的选项（如下图）。如果勾选了，那么在真机上是有效的（也就是说，模拟器上是无效的）。不过，一般情况下，不勾选。因为，很多应用程序并没有申请读取SD卡的权限，一旦勾上，很多应用程序将无法读取SD卡。因此，为了向下兼容，一般不勾。

![img][img 30]

示例：将上面“在内部存储中读取文件”中示例的MainActivity类中代码做一下修改，如下。

![img][img 31]

![img][img 32]

为读写SD卡添加权限（读SD卡权限可加可不加）：

![img][img 33]

![img][img 34]

运行结果：

![img][img 35]

![img][img 36]

## **6.1 检测SD卡状态** ##

很多手机厂商都修改了SD卡路径，因此，很多手机SD卡的路径不是storage/sdcard。但是，sdcard的快捷方式基本上都是存在的，并且指向真实的SD卡路径。因此，访问SD卡路径，可以通过获取SD卡快捷方式的方法。当然，也可以调用API中提供的相应方法获取SD卡路径：Environment.getExternalStorageDirectory()

外部存储空间对于手机来说并不一定是必须的。所以，在使用前，一定要做确认手机的SD卡是否存在。可以通过Environment.getExternalStorageState()确定SD卡的状态，此方法的常见返回值说明如下：

*  MEDIA\_REMOVED：sd卡被拔出
 *  MEDIA\_UNMOUNTED：sd卡未挂载（4.0版本以前，手机可以通过点击settings–>Storage–>Storage settings–>Unmounted SD card，使SD卡未挂载）
 *  MEDIA\_- CHECKING：sd卡正在准备
 *  MEDIA\_MOUNTED：sd卡已挂载，当前可用
 *  MEDIA\_READ\_ONLY：sd卡挂载可用，但是只读

示例：将上面“在内部存储中读取文件”中示例的MainActivity类中代码做一下修改，如下

![img][img 37]

运行结果：由于在4.0版本之前才有手动使SD卡未挂载的功能，这里使用2.3.3版本测试。首先，Unmounted SD card，观察效果，可以看到提示：sd不可用。

![img][img 38]

![img][img 39]

然后，mounted SD card，观察效果，成功保存用户名、密码信息。

![img][img 40]

![img][img 41]

当有多个模拟器运行时，想要观察某一个模拟器的文件目录，只需要在Devices选项卡中点击那个模拟器，即可在File Explorer选项卡中看到那个模拟器的文件目录。

![img][img 42]

## **6.2 获取SD卡剩余容量** ##

当用户做下载等操作时，SD卡的空间可能不足，所以需要提前获取SD卡剩余容量，给予用户提示信息。在Android系统中，可以查看SD卡剩余容量，点击Setting–>Storage

![img][img 43]

sdk文件夹中的sources文件夹中的源码是Android jar包的源码，Android系统源码则不同，一定要区分开。如下图。

![img][img 44]

其中，packages/apps路径为Android系统级应用程序所在的目录，可以看到settings应用程序。

![img][img 45]

# **7. 查看settings应用程序的源码** #

## **7.1 导入settings应用程序到eclipse中** ##

点击File–>New–>Other….

![img][img 46]

点击Android下的Android Project from Existing Code–>Next

![img][img 47]

点击Root Directory右侧的Browse…按钮，找到settings应用程序所在的目录，点击确定

![img][img 48]

下图中的tests为测试settings的应用程序，不勾

![img][img 49]

导入成功

![img][img 50]

之所以会报错，是因为普通应用开发是无法访问系统级API的（settings工程导入eclipse就成为了一个普通应用开发项目）

## **7.2 查找实现查看SD卡剩余空间的源码** ##

通过搜索关键字“Available space”开始查找

![img][img 51]

通过eclipse的“File Search”在整个工作空间中搜索“Available space”

![img][img 52]

![img][img 53]

查找到以后，双击

![img][img 54]

![img][img 55]

再搜索“memory\_available”

![img][img 56]

![img][img 57]

再搜索“memory\_sd\_avail”

![img][img 58]

![img][img 59]

再在本文件内搜索“MEMORY\_SD\_AVAIL”

![img][img 60]

再在本文件内搜索“mSdAvail”，可以看到，已经查找到了该段代码

![img][img 61]

## **7.3 解析源码** ##

所有存储设备都会被划分成若干个区块，存储设备的总容量 = 每个区块大小 \* 区块总数量

![img][img 62]

其中的formatSize函数实际上就是将得出的字节数，转换成MB、GB、TB及PB显示给用户

![img][img 63]

示例：我们自己写程序获取SD卡剩余容量

res\\layout\\activity\_main.xml

src/cn.itcast.getsdavail/MainActivity.java

package cn.itcast.getsdavail;
    import java.io.File;
    import android.os.Build;
    import android.os.Bundle;
    import android.os.Environment;
    import android.os.StatFs;
    import android.app.Activity;
    import android.text.format.Formatter;
    import android.view.Menu;
    import android.widget.TextView;
    public class MainActivity extends Activity { 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            File path = Environment.getExternalStorageDirectory();
            StatFs stat = new StatFs(path.getPath());
            long blockSize;
            long availableBlocks;
            //下面的很多方法已经过时了，因为getBlockSize等方法的返回值都是int类型，如果设备较大，返回的blockSize数值可能超过int类型的范围，导致溢出。
            //改为使用最新的getBlockSizeLong等方法返回为long类型数据即可。由于，只有4.3以上版本的API才支持这些方法。因此，最好做一下判断。

运行结果：

![img][img 64]

# **8. 文件访问权限** #

Android的文件访问权限是从Linux继承来的

![img][img 65]

drwxrwxrwx:

第一个字母：如果是d，表示文件夹；如果是-，表示文件；如果是l，表示快捷方式。  
三组rwx（r（read），w（write），x（exeute，执行））表示三种不同用户的权限。  
在Android中，每个应用，都是一个独立的用户。也就是说，创建一个应用，就是创建了一个新的用户。删除一个应用，就是删除了一个用户。  
第一组rwx：描述文件拥有者（owner）对文件的权限。例如，上图中的data/cn.itcast.rwinrom/cache/info.txt文件的创建者就是拥有者，也就是cn.itcast.rwinrom应用程序。  
第二组rwx：描述与文件拥有者同一用户组（grouper）的用户对文件的权限。默认情况，各个应用程序彼此是独立的用户。可以手动设置同组用户，不过只有系统应用为了方便才会设置同组用户，我们不用管。  
第三组rwx：描述其他用户（other）对文件的权限。其他应用程序就可以称为某一个应用程序的其他用户。

实验：其他应用程序读取当前应用程序的文件。

res\\layout\\activity\_main.xml

src/cn.itcast.permission/MainActivity.java

package cn.itcast.permission;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    public class MainActivity extends Activity { 
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                    super.onCreate(savedInstanceState);
                    setContentView(R.layout.activity_main);
            }
        public void click1(View v){
                //Android中提供的openFileOutput方法可以直接获取FileOutputStream，文件会被写在内部文件空间中（data/data/报名文件夹/files/）
                try {
                            //MODE_PRIVATE表示拥有者和同组用户可以读写，其他用户无法访问
                            FileOutputStream fos = openFileOutput("info1.txt", MODE_PRIVATE);
                            fos.write("haha".getBytes());
                    } catch (Exception e) {
                            e.printStackTrace();
                    }
        }
        public void click2(View v){
                try {
                            //MODE_WORLD_READABLE表示任何用户都对其可读，MODE_WORLD_WRITEABLE表示任何用户都对其可写
                            FileOutputStream fos = openFileOutput("info2.txt", MODE_WORLD_READABLE|MODE_WORLD_WRITEABLE);
                            fos.write("hehe,你来读我啊".getBytes());
                    } catch (Exception e) {
                            e.printStackTrace();
                    }        
        }
    }

创建新的名为“其他用户”的应用程序，代码如下：

![img][img 66]

res\\layout\\activity\_main.xml

src/cn.itcast.other/MainActivity.java

package cn.itcast.other;
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Toast;
    public class MainActivity extends Activity { 
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                    super.onCreate(savedInstanceState);
                    setContentView(R.layout.activity_main);
            }
            public void click(View v){
                    File file = new File("data/data/cn.itcast.permission/files","info2.txt");
                    try {
                            FileInputStream fis = new FileInputStream(file);
                            BufferedReader br = new BufferedReader(new InputStreamReader(fis));
                            Toast.makeText(this,br.readLine(),Toast.LENGTH_LONG).show();
                    } catch (Exception e) {
                            e.printStackTrace();
                    }
            }
    }

运行结果：

点击按钮一、按钮二，生成文件info1.txt、info2.txt

![img][img 67]

可以看到info1.txt为拥有者和同一用户组具备读写权限，info2.txt则为任何用户都具备读写权限。

![img][img 68]

运行“其他用户”应用程序，点击按钮，可以看到读取info2.txt文件成功。

![img][img 69]

![img][img 70]

# **9. SharedPreferences** #

在真实开发中，类似于账号及密码保存功能等持久化保存比较零散、简单数据的情况使用SharedPerferences比较方便，它是以键值对的方式将数据存储进xml文件中。

示例：修改保存用户登录名，密码的案例，用SharedPreferences保存数据的方式实现。  
src/cn.itcast.sharedpreference/MainActivity.java

package cn.itcast.sharedpreference;
    import android.app.Activity;
    import android.content.SharedPreferences;
    import android.content.SharedPreferences.Editor;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.CheckBox;
    import android.widget.EditText;
    import android.widget.Toast;
    public class MainActivity extends Activity { 
        private EditText et_name;
        private EditText et_pass;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            et_name = (EditText) findViewById(R.id.et_name);
            et_pass = (EditText) findViewById(R.id.et_pass);
            readAccount();
        }
        public void login(View v){
                String name = et_name.getText().toString();
                String pass = et_pass.getText().toString();
                CheckBox cb = (CheckBox) findViewById(R.id.cb);
                if(cb.isChecked()){
                        //SharedPreferences是接口，通过getSharedPreferences方法获取对象，第一个参数为文件名，第二个参数控制访问权限。
                        //在路径为data/data/包名文件夹/shared_prefs目录下保存生成的xml文件。
                        SharedPreferences sp = getSharedPreferences("info", MODE_PRIVATE);
                        //获取编辑器
                        Editor ed = sp.edit();
                        ed.putString("name", name);
                        ed.putString("pass", pass);
                        //提交
                        ed.commit();
                }
                Toast.makeText(this, "登陆成功", Toast.LENGTH_LONG).show();
        }
        public void readAccount(){
                SharedPreferences sp = getSharedPreferences("info", MODE_PRIVATE);
                //第二个参数表示如果没有对应第一个参数的value值返回的默认值，这里设置为空字符串。
                String name = sp.getString("name", "");
                String pass = sp.getString("pass", "");
                et_name.setText(name);
                et_pass.setText(pass);
        }
    }

运行结果：

![img][img 71]

可以看到，数据成功保存到xml文件中。

![img][img 72]

![img][img 73]

回显成功。

![img][img 74]

# **10. 生成xml文件** #

虽然SharedPreferences可以实现保存数据到xml中，但是，对于类似于用户保存短信等Android应用程序来说还是不行的。例如，保存短信功能，需要保存内容、发送时间、接收人号码、短信类型（发送、接收）等等多种类型数据，尤其是数据组织结构比较复杂时，使用SharedPreferences会相当的麻烦。

示例：通过xml方式保存短信。  
res\\layout\\activity\_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".MainActivity" >
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="生成xml文件" 
            android:onClick="click"
            />
    </RelativeLayout>
    src/cn.itcast.createxml/Sms.java
    ```java
    package cn.itcast.createxml;
    public class Sms { 
            private String body;
            private String address;
            private long date;
            private int type;
            public String getBody() {
                    return body;
            }
            public void setBody(String body) {
                    this.body = body;
            }
            public String getAddress() {
                    return address;
            }
            public void setAddress(String address) {
                    this.address = address;
            }
            public long getDate() {
                    return date;
            }
            public void setDate(long date) {
                    this.date = date;
            }
            public int getType() {
                    return type;
            }
            public void setType(int type) {
                    this.type = type;
            }
            public Sms(String body, String address, long date, int type) {
                    super();
                    this.body = body;
                    this.address = address;
                    this.date = date;
                    this.type = type;
            }
    }

src/cn.itcast.createxml/MainActivity.java

package cn.itcast.createxml;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.util.ArrayList;
    import java.util.List;
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    public class MainActivity extends Activity { 
            List<Sms> smsList;
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                    super.onCreate(savedInstanceState);
                    setContentView(R.layout.activity_main);
                    smsList = new ArrayList<Sms>();
                    for(int i = 0; i < 10; i++){
                            Sms sms = new Sms("云鹤" + i + "号","138" + i + i,System.currentTimeMillis(),1);
                            smsList.add(sms);
                    }
            }
            public void click(View v){
                    StringBuffer sb = new StringBuffer();
                    sb.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
                    sb.append("<smss>");
                    for(Sms sms : smsList){
                            sb.append("<sms>");
                            sb.append("<body>");
                            sb.append(sms.getBody());
                            sb.append("</body>");
                            sb.append("<address>");
                            sb.append(sms.getAddress());
                            sb.append("</address>");
                            sb.append("<date>");
                            sb.append(sms.getDate());
                            sb.append("</date>");
                            sb.append("<type>");
                            sb.append(sms.getType());
                            sb.append("</type>");
                            sb.append("</sms>");
                    }
                    //备份数据的应用一般都存在外部存储空间中。因为，一旦应用程序被删，内部存储空间内的该应用程序就会被清除，而外部存储空间不会被清掉。
                    File file = new File("sdcard/sms.xml");
                    try {
                            FileOutputStream fos = new FileOutputStream(file);
                            fos.write(sb.toString().getBytes());
                            fos.close();
                    } catch (Exception e) {
                            e.printStackTrace();
                    }
            }
    }

运行结果：

![img][img 75]

点击“生成xml文件”按钮，可以看到成功生成了sms.xml文件。

![img][img 76]

![img][img 77]

# **11. xml序列化器** #

上面拼接字符串的方法过于麻烦，Android中有一个xml序列化器可以帮助我们解决这个问题。  
示例：将上面示例中拼接字符串的方式修改为通过xml序列化器生成xml文件。

src/cn.itcast.createxml/MainActivity.java

package cn.itcast.createxml;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.util.ArrayList;
    import java.util.List;
    import org.xmlpull.v1.XmlSerializer;
    import android.app.Activity;
    import android.os.Bundle;
    import android.util.Xml;
    import android.view.View;
    public class MainActivity extends Activity { 
            List<Sms> smsList;
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                    super.onCreate(savedInstanceState);
                    setContentView(R.layout.activity_main);
                    smsList = new ArrayList<Sms>();
                    for(int i = 0; i < 10; i++){
                            Sms sms = new Sms("云鹤" + i + "号","138" + i + i,System.currentTimeMillis(),1);
                            smsList.add(sms);
                    }
            }
            public void click(View v){
                    //获取xml序列化器
                    XmlSerializer xs = Xml.newSerializer();
                    try{
                            //初始化，指定生成的xml文件路径和文件名
                            File file = new File("sdcard/sms2.xml");
                            FileOutputStream fos = new FileOutputStream(file);
                            //编码：xml文件使用什么编码生成
                            xs.setOutput(fos,"utf-8");
                            //开始生成xml文件
                            //生成头结点
                            //两个参数分别用来定义XML文件的头部<?xml version="1.0" encoding="utf-8" standalone="yes"?>中encoding和standalone的值
                            xs.startDocument("utf-8", true);
                            //开始节点，第一个参数为名称空间，用不到，设置为null。
                            xs.startTag(null, "smss");
                            for(Sms sms : smsList){
                                    xs.startTag(null, "sms");
                                    xs.startTag(null, "body");
                                    xs.text(sms.getBody());
                                    xs.endTag(null, "body");
                                    xs.startTag(null, "address");
                                    xs.text(sms.getAddress());
                                    xs.endTag(null, "address");
                                    xs.startTag(null, "date");
                                    xs.text(sms.getDate() + "");
                                    xs.endTag(null, "date");
                                    xs.startTag(null, "type");
                                    xs.text(sms.getType() + "");
                                    xs.endTag(null, "type");
                                    xs.endTag(null, "sms");
                            }
                            //结束节点
                            xs.endTag(null, "smss");
                            //告知序列化器xml文件生成完毕
                            xs.endDocument();
                    }catch(Exception e){
                            e.printStackTrace();
                    }
            }
    }

运行结果：可以看到，生成xml文件成功。

![img][img 78]

![img][img 79]

PS：使用xml序列化器生成xml文件还有一个好处，那就是会自动对特殊字符进行转义。

示例：对上面示例中加上如下代码，其中“<”及“>”都是特殊字符

![img][img 80]

运行结果：可以看到成功生成xml文件，但是其中的特殊字符已经转义了。

![img][img 81]

![img][img 82]

--------------------

> 下一章 [Android应用开发：数据存储和界面展现-2][Android_-2]

# 常见布局 #

## 相对布局 ##

### RelativeLayout ###

*  组件默认左对齐、顶部对齐
 *  设置组件在指定组件的右边

android:layout_toRightOf="@id/tv1"

*  设置在指定组件的下边

android:layout_below="@id/tv1"

*  设置右对齐父元素

android:layout_alignParentRight="true"

*  设置与指定组件右对齐

android:layout_alignRight="@id/tv1"

## 线性布局 ##

### LinearLayout ###

*  指定各个节点的排列方向

android:orientation="horizontal"

*  设置右对齐

android:layout_gravity="right"

*  当竖直布局时，只能左右对齐和水平居中，顶部底部对齐竖直居中无效
 *  当水平布局时，只能顶部底部对齐和竖直居中
 *  使用match\_parent时注意不要把其他组件顶出去
 *  线性布局非常重要的一个属性：权重

android:layout_weight="1"

*  权重设置的是按比例分配剩余的空间

## 帧布局 ##

### FrameLayout ###

*  默认组件都是左对齐和顶部对齐，每个组件相当于一个div
 *  可以更改对齐方式

android:layout_gravity="bottom"

*  不能相对于其他组件布局

## 表格布局 ##

### TableLayout ###

*  每个节点是一行，它的每个子节点是一列
 *  表格布局中的节点可以不设置宽高，因为设置了也无效
    
     *  根节点的子节点宽为匹配父元素，高为包裹内容
     *  节点的子节点宽为包裹内容，高为包裹内容
     *  以上默认属性无法修改
 *  根节点中可以设置以下属性，表示让第1列拉伸填满屏幕宽度的剩余空间

android:stretchColumns="1"

## 绝对布局 ##

### AbsoluteLayout ###

*  直接指定组件的x、y坐标

android:layout_x="144dp"
    android:layout_y="154dp"

# logcat #

*  日志信息总共分为5个等级  
    
    
     *  verbose 冗余，最低等级
     *  debug 调试信息
     *  info 正常信息
     *  warn 警告
     *  error 错误
 *  定义过滤器方便查看
 *  System.out.print输出的日志级别是info，tag是System.out
 *  Android提供的日志输出api，打印出来的是error级别的信息

Log.v(TAG, "加油吧，童鞋们");
    Log.d(TAG, "加油吧，童鞋们");
    Log.i(TAG, "加油吧，童鞋们");
    Log.w(TAG, "加油吧，童鞋们");
    Log.e(TAG, "加油吧，童鞋们");

# 文件读写操作 #

*  Ram内存：运行内存，相当于电脑的内存
 *  Rom内存：内部存储空间，相当于电脑的硬盘
 *  sd卡：外部存储空间，相当于电脑的移动硬盘

## 在内部存储空间中读写文件 ##

小案例：用户输入账号密码，勾选“记住账号密码”，点击登录按钮，登录的同时持久化保存账号和密码

## 1. 定义布局 ##

## 2. 完成按钮的点击事件 ##

*  弹土司提示用户登录成功

Toast.makeText(this, "登录成功", Toast.LENGTH_SHORT).show();

## 3. 拿到用户输入的数据 ##

*  判断用户是否勾选保存账号密码

CheckBox cb = (CheckBox) findViewById(R.id.cb);
    if(cb.isChecked()){
    
    }

## 4. 开启io流把文件写入内部存储 ##

*  直接开启文件输出流写数据

//持久化保存数据
    File file = new File("data/data/com.itheima.rwinrom/info.txt");
    FileOutputStream fos = new FileOutputStream(file);
    fos.write((name + "##" + pass).getBytes());
    fos.close();

*  读取数据前先检测文件是否存在

if(file.exists())

*  读取保存的数据，也是直接开文件输入流读取

File file = new File("data/data/com.itheima.rwinrom/info.txt");
    FileInputStream fis = new FileInputStream(file);
    //把字节流转换成字符流
    BufferedReader br = new BufferedReader(new InputStreamReader(fis));
    String text = br.readLine();
    String[] s = text.split("##");

*  读取到数据之后，回显至输入框

et_name.setText(s[0]);
    et_pass.setText(s[1]);

*  应用只能在自己的包名目录下创建文件，不能到别人家去创建

### 直接复制项目 ###

*  需要改动的地方：  
    
    
     *  项目名字
     *  应用包名
     *  R文件重新导包

### 使用路径api读写文件 ###

*  getFilesDir()得到的file对象的路径是data/data/com.itheima.rwinrom2/files  
    
    
     *  存放在这个路径下的文件，只要你不删，它就一直在
 *  getCacheDir()得到的file对象的路径是data/data/com.itheima.rwinrom2/cache
    
     *  存放在这个路径下的文件，当内存不足时，有可能被删除
 *  系统管理应用界面的清除缓存，会清除cache文件夹下的东西，清除数据，会清除整个包名目录下的东西
 *  getCacheDir()：获取缓存文件夹

# 在外部存储读写数据 #

## sd卡的路径 ##

*  sdcard：2.3之前的sd卡路径
 *  mnt/sdcard：4.3之前的sd卡路径
 *  storage/sdcard：4.3之后的sd卡路径
 *  最简单的打开sd卡的方式

File file = new File("sdcard/info.txt");

*  写sd卡需要权限

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

*  读sd卡，在4.0之前不需要权限，4.0之后可以设置为需要

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

*  使用api获得sd卡的真实路径，部分手机品牌会更改sd卡的路径

Environment.getExternalStorageDirectory()

*  判断sd卡是否准备就绪

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))
    //MEDIA_UNKNOWN:不能识别sd卡
    //MEDIA_REMOVED:没有sd卡
    //MEDIA_UNMOUNTED:sd卡存在但是没有挂载
    //MEDIA_CHECKING:sd卡正在准备
    //MEDIA_MOUNTED：sd卡已经挂载，可用

# 查看源代码查找获取sd卡剩余容量的代码 #

*  导入Settings项目
 *  查找“可用空间”得到

*  查找”memory\_available”，得到

*  查找”memory\_sd\_avail”，得到

//这个字符串就是sd卡剩余容量
    formatSize(availableBlocks * blockSize) + readOnly
    //这两个参数相乘，得到sd卡以字节为单位的剩余容量
    availableBlocks * blockSize

*  存储设备会被分为若干个区块，每个区块有固定的大小
 *  区块大小 \* 区块数量 等于 存储设备的总大小

# Linux文件的访问权限 #

*  在Android中，每一个应用是一个独立的用户
 *  drwxrwxrwx
 *  第1位：d表示文件夹，-表示文件
 *  第2-4位：rwx，表示这个文件的拥有者用户（owner）对该文件的权限  
    
    
     *  r：读
     *  w：写
     *  x：执行
 *  第5-7位：rwx，表示跟文件拥有者用户同组的用户（grouper）对该文件的权限
 *  第8-10位：rwx，表示其他用户组的用户（other）对该文件的权限

--------------------

# openFileOutput的四种模式 #

*  MODE\_PRIVATE：-rw-rw—-
 *  MODE\_APPEND:-rw-rw—-
 *  MODE\_WORLD\_WRITEABLE:-rw-rw–w-
 *  MODE\_WORLD\_READABLE:-rw-rw-r–

FileOutputStream fos = openFileOutput(name,mode);

--------------------

# SharedPreference #

> 用SharedPreference存储账号密码

*  往SharedPreference里写数据

//拿到一个SharedPreference对象
    SharedPreferences sp = getSharedPreferences("config", MODE_PRIVATE);
    //拿到编辑器
    Editor ed = sp.edit();
    //写数据
    ed.putBoolean("name", name);
    ed.commit();

*  从SharedPreference里取数据

SharedPreferences sp = getSharedPreferences("config", MODE_PRIVATE);
    //从SharedPreference里取数据
    String name = sp.getBoolean("name", "");

--------------------

# 生成XML文件备份短信 #

*  创建几个虚拟的短信对象，存在list中
 *  备份数据通常都是备份至sd卡

### 使用StringBuffer拼接字符串 ###

*  把整个xml文件所有节点append到sb对象里

sb.append("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>");
    //添加smss的开始节点
    sb.append("<smss>");

*  把sb写到输出流中

fos.write(sb.toString().getBytes());

### 使用XMl序列化器生成xml文件 ###

*  得到xml序列化器对象

XmlSerializer xs = Xml.newSerializer();

*  给序列化器设置输出流

File file = new File(Environment.getExternalStorageDirectory(), "backupsms.xml");
    FileOutputStream fos = new FileOutputStream(file);
    //给序列化器指定好输出流
    xs.setOutput(fos, "utf-8");

*  开始生成xml文件

xs.startDocument("utf-8", true);
    xs.startTag(null, "smss");

package com.itheima.createxml.domain;
    
    public class Message { 
    
        private String body;
        private String date;
        private String address;
        private String type;
        public String getBody() {
            return body;
        }
        public void setBody(String body) {
            this.body = body;
        }
        public String getDate() {
            return date;
        }
        public void setDate(String date) {
            this.date = date;
        }
        public String getAddress() {
            return address;
        }
        public void setAddress(String address) {
            this.address = address;
        }
        public String getType() {
            return type;
        }
        public void setType(String type) {
            this.type = type;
        }
        public Message(String body, String date, String address, String type) {
            super();
            this.body = body;
            this.date = date;
            this.address = address;
            this.type = type;
        }
    
    
    }

package com.itheima.xmlserializer;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import org.xmlpull.v1.XmlSerializer;
    
    import com.itheima.createxml.domain.Message;
    
    import android.os.Bundle;
    import android.app.Activity;
    import android.util.Xml;
    import android.view.Menu;
    import android.view.View;
    
    public class MainActivity extends Activity { 
    
        List<Message> smsList;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 虚拟10条短信
            smsList = new ArrayList<Message>();
            for (int i = 0; i < 10; i++) {
                Message sms = new Message("小志好棒" + i, System.currentTimeMillis()
                        + "", "138" + i + i, "1");
                smsList.add(sms);
            }
        }
    
        public void click(View v){
            //使用xml序列化器生成xml文件
            //1.拿到序列化器对象
            XmlSerializer xs = Xml.newSerializer();
            //2.初始化
            File file = new File("sdcard/sms2.xml");
            try {
                FileOutputStream fos = new FileOutputStream(file);
                //enconding:指定用什么编码生成xml文件
                xs.setOutput(fos, "utf-8");
    
                //3.开始生成xml文件
                //enconding:指定头结点中的enconding属性的值
                xs.startDocument("utf-8", true);
    
                xs.startTag(null, "message");
    
                for (Message sms : smsList) {
                    xs.startTag(null, "sms");
    
                    xs.startTag(null, "body");
                    xs.text(sms.getBody() + "<body>");
                    xs.endTag(null, "body");
    
                    xs.startTag(null, "date");
                    xs.text(sms.getDate());
                    xs.endTag(null, "date");
    
                    xs.startTag(null, "type");
                    xs.text(sms.getType());
                    xs.endTag(null, "type");
    
                    xs.startTag(null, "address");
                    xs.text(sms.getAddress());
                    xs.endTag(null, "address");
    
                    xs.endTag(null, "sms");
                }
    
                xs.endTag(null, "message");
    
                //告诉序列化器，文件生成完毕
                xs.endDocument();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }

--------------------

# pull解析xml文件 #

*  先自己写一个xml文件，存一些天气信息

## 拿到xml文件 ##

InputStream is = getClassLoader().getResourceAsStream("weather.xml");

## 拿到pull解析器 ##

XmlPullParser xp = Xml.newPullParser();

## 开始解析 ##

*  拿到指针所在当前节点的事件类型

int type = xp.getEventType();

*  事件类型主要有五种
    
     *  START\_DOCUMENT：xml头的事件类型
     *  END\_DOCUMENT：xml尾的事件类型
     *  START\_TAG：开始节点的事件类型
     *  END\_TAG：结束节点的事件类型
     *  TEXT：文本节点的事件类型
 *  如果获取到的事件类型不是END\_DOCUMENT，就说明解析还没有完成，如果是，解析完成，while循环结束
    
        while(type != XmlPullParser.END_DOCUMENT)
 *  当我们解析到不同节点时，需要进行不同的操作，所以判断一下当前节点的name  
    
    
     *  当解析到weather的开始节点时，new出list
     *  当解析到city的开始节点时，创建city对象，创建对象是为了更方便的保存即将解析到的文本
     *  当解析到name开始节点时，获取下一个节点的文本内容，temp、pm也是一样

case XmlPullParser.START_TAG:
    //获取当前节点的名字
        if("weather".equals(xp.getName())){
            citys = new ArrayList<City>();
        }
        else if("city".equals(xp.getName())){
            city = new City();
        }
        else if("name".equals(xp.getName())){
            //获取当前节点的下一个节点的文本
            String name = xp.nextText();
            city.setName(name);
        }
        else if("temp".equals(xp.getName())){
            String temp = xp.nextText();
            city.setTemp(temp);
        }
        else if("pm".equals(xp.getName())){
            String pm = xp.nextText();
            city.setPm(pm);
        }
        break;

*  当解析到city的结束节点时，说明city的三个子节点已经全部解析完了，把city对象添加至list

case XmlPullParser.END_TAG:
        if("city".equals(xp.getName())){
                citys.add(city);
        }

package com.itheima.pullparser;
    
    import java.io.InputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    import org.xmlpull.v1.XmlPullParser;
    import org.xmlpull.v1.XmlPullParserException;
    
    import com.itheima.pullparser.domain.City;
    
    import android.os.Bundle;
    import android.app.Activity;
    import android.util.Xml;
    import android.view.Menu;
    import android.view.View;
    
    public class MainActivity extends Activity { 
    
        List<City> cityList;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
        public void click(View v){
            //获取到src文件夹下的资源文件
            InputStream is = getClassLoader().getResourceAsStream("weather.xml");
    
            //拿到pull解析器对象
            XmlPullParser xp = Xml.newPullParser();
            //初始化
            try {
                xp.setInput(is, "gbk");
    
                //获取当前节点的事件类型，通过事件类型的判断，我们可以知道当前节点是什么节点，从而确定我们应该做什么操作
                int type = xp.getEventType();
                City city = null;
                while(type != XmlPullParser.END_DOCUMENT){
                    //根据节点的类型，要做不同的操作
                    switch (type) {
                    case XmlPullParser.START_TAG:
                        // 获取当前节点的名字
                        if("weather".equals(xp.getName())){
                            //创建city集合对象，用于存放city的javabean
                            cityList = new ArrayList<City>();
                        }
                        else if("city".equals(xp.getName())){
                            //创建city的javabean对象
                            city = new City();
                        }
                        else if("name".equals(xp.getName())){
                            // 获取当前节点的下一个节点的文本
                            String name = xp.nextText();
                            city.setName(name);
                        }
                        else if("temp".equals(xp.getName())){
                            // 获取当前节点的下一个节点的文本
                            String temp = xp.nextText();
                            city.setTemp(temp);
                        }
                        else if("pm".equals(xp.getName())){
                            // 获取当前节点的下一个节点的文本
                            String pm = xp.nextText();
                            city.setPm(pm);
                        }
                        break;
                    case XmlPullParser.END_TAG:
                        if("city".equals(xp.getName())){
                            //把city的javabean放入集合中
                            cityList.add(city);
                        }
                        break;
    
                    }
    
                    //把指针移动到下一个节点，并返回该节点的事件类型
                    type = xp.next();
                }
    
                for (City c : cityList) {
                    System.out.println(c.toString());
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }

# 常见布局 #

### 线性布局 ###

*  有一个布局方向，水平或者竖直
 *  在竖直布局下，左对齐、右对齐，水平居中生效
 *  在水平布局下，顶部对齐、底部对齐、竖直居中生效
 *  权重：按比例分配屏幕的剩余宽度或者高度

### 相对布局 ###

*  组件默认位置都是左上角，组件之间可以重叠
 *  可以相对于父元素上下左右对齐，相对于父元素，水平居中、竖直居中、水平竖直同时居中
 *  可以相对于其他组件上下左右对齐
 *  可以布局于其他组件的上方、下方、左边、右边

### 帧布局 ###

*  组件默认位置都是左上角，组件之间可以重叠
 *  可以设置上下左右对齐，水平竖直居中，设置方式与线性布局一样

### 表格布局 ###

*  每有一个TableRow子节点表示一行，该子节点的每一个子节点都表示一列
 *  TableLayout的一级子节点默认宽都是匹配父元素
 *  TableRow的子节点默认宽高都是包裹内容

--------------------

# Logcat #

### 等级 ###

*  verbose：冗余，最低等级
 *  debug：调试
 *  info：正常等级的信息
 *  warn：警告
 *  error：错误

--------------------

# Android的存储 #

### 内部存储空间 ###

*  RAM内存：运行内存，相当于电脑的内存
 *  ROM内存：存储内存，相当于电脑的硬盘

### 外部存储空间 ###

*  SD卡：相当于电脑的移动硬盘
    
     *  2.2之前，sd卡路径：sdcard
     *  4.3之前，sd卡路径：mnt/sdcard
     *  4.3开始，sd卡路径：storage/sdcard
 *  所有存储设备，都会被划分成若干个区块，每个区块有固定的大小
 *  存储设备的总大小 = 区块大小 \* 区块数量

--------------------

# 文件访问权限 #

*  指的是谁能访问这个文件
 *  在Android中，每一个应用，都是一个独立的用户
 *  使用10个字母表示
 *  drwxrwxrwx
 *  第一个字母：  
    
    
     *  d：表示文件夹
     *  \-：表示文件
 *  第一组rwx：表示的是文件拥有者（owner）对文件的权限  
    
    
     *  r：read，读
     *  w：write
     *  x：execute
 *  第二组rwx：表示的是跟文件拥有者属于同一用户组的用户（grouper）对文件的权限
 *  第三组rwx：表示的其他用户（other）对文件的权限

--------------------

# SharedPreference #

*  非常适合用来保存零散的简单的数据

# 测试 #

*  黑盒测试  
    
    
     *  测试逻辑业务
 *  白盒测试
    
     *  测试逻辑方法
 *  根据测试粒度
    
     *  方法测试：function test
     *  单元测试：unit test
     *  集成测试：integration test
     *  系统测试：system test
 *  根据测试暴力程度
    
     *  冒烟测试：smoke test
     *  压力测试：pressure test

--------------------

# 单元测试junit #

*  定义一个类继承AndroidTestCase，在类中定义方法，即可测试该方法
 *  在指定指令集时，targetPackage指定你要测试的应用的包名

*  定义使用的类库

<uses-library android:name="android.test.runner"></uses-library>

*  断言的作用，assertEquals(期待值，实际值)，检测运行结果和预期是否一致
 *  如果应用出现异常，会抛给测试框架

--------------------

# SQLite数据库 #

*  轻量级关系型数据库
 *  创建数据库需要使用的api：SQLiteOpenHelper  
    
    
     *  必须定义一个构造方法：

//name：数据库文件的名字
    //factory：游标工厂
    //version：数据库版本
    public MyOpenHelper(Context context, String name, CursorFactory factory, int version){}

* 数据库被创建时会调用：onCreate方法
    * 数据库升级时会调用：onUpgrade方法

## 创建数据库 ##

//创建OpenHelper对象
    MyOpenHelper oh = new MyOpenHelper(getContext(), "person.db", null, 1);
    //获得数据库对象,如果数据库不存在，先创建数据库，后获得，如果存在，则直接获得
    SQLiteDatabase db = oh.getWritableDatabase();

*  getWritableDatabase()：打开可读写的数据库
 *  getReadableDatabase()：在磁盘空间不足时打开只读数据库，否则打开可读写数据库
 *  在创建数据库时创建表

public void onCreate(SQLiteDatabase db) {
            db.execSQL("create table person (_id integer primary key autoincrement, name char(10), phone char(20), money integer(20))");
        }

--------------------

# 数据库的增删改查 #

## SQL语句 ##

*  insert into person (name, phone, money) values (‘张三’, ‘159874611’, 2000);
 *  delete from person where name = ‘李四’ and \_id = 4;
 *  update person set money = 6000 where name = ‘李四’;
 *  select name, phone from person where name = ‘张三’;

### 执行SQL语句实现增删改查 ###

//插入
    db.execSQL("insert into person (name, phone, money) values (?, ?, ?);", new Object[]{
       "张三", 15987461, 75000});
    //查找
    Cursor cs = db.rawQuery("select _id, name, money from person where name = ?;", new String[]{
       "张三"});
    * 测试方法执行前会调用此方法

protected void setUp() throws Exception {
        super.setUp();
        // 获取虚拟上下文对象
        oh = new MyOpenHelper(getContext(), "people.db", null, 1);
    }

//测试方法执行完毕之后，此方法调用
    @Override
    protected void tearDown() throws Exception {
        // TODO Auto-generated method stub
        super.tearDown();
        db.close();
    }

查询

public void select(){
        Cursor cursor = db.rawQuery("select name, salary from person", null);
        while(cursor.moveToNext()){
        //通过列索引获取列的值
        String name = cursor.getString(cursor.getColumnIndex("name"));
                String salary = cursor.getString(1);
                System.out.println(name + ";" + salary);
        }
    }

### 使用api实现增删改查 ###

*  插入

//以键值对的形式保存要存入数据库的数据
    ContentValues cv = new ContentValues();
    cv.put("name", "刘能");
    cv.put("phone", 1651646);
    cv.put("money", 3500);
    //返回值是改行的主键，如果出错返回-1
    long i = db.insert("person", null, cv);

*  删除

//返回值是删除的行数
    int i = db.delete("person", "_id = ? and name = ?", new String[]{
       "1", "张三"});

*  修改

ContentValues cv = new ContentValues();
    cv.put("money", 25000);
    int i = db.update("person", cv, "name = ?", new String[]{
       "赵四"});

*  查询

//arg1:要查询的字段
    //arg2：查询条件
    //arg3:填充查询条件的占位符
    Cursor cs = db.query("person", new String[]{
       "name", "money"}, "name = ?", new String[]{
       "张三"}, null, null, null);
    while(cs.moveToNext()){
        // 获取指定列的索引值
        String name = cs.getString(cs.getColumnIndex("name"));
        String money = cs.getString(cs.getColumnIndex("money"));
        System.out.println(name + ";" + money);
    }

### 事务 ###

*  保证多条SQL语句要么同时成功，要么同时失败
 *  最常见案例：银行转账
 *  事务api

public void transaction(){
        try{
            //开启事务
            db.beginTransaction();
            ContentValues values = new ContentValues();
            values.put("salary", 12000);
            db.update("person", values, "name = ?", new String[]{
       "小志"});
    
            values.clear();
            values.put("salary", 16000);
            db.update("person", values, "name = ?", new String[]{
       "小志的儿子"});
    
            int i = 3/0;
            //设置 事务执行成功
            db.setTransactionSuccessful();
        }
        finally{
            //关闭事务，同时提交，如果已经设置事务执行成功，那么sql语句就生效了，反之，sql语句回滚
            db.endTransaction();
        }
    }

--------------------

# 把数据库的数据显示至屏幕 #

1.  任意插入一些数据  
    
    
     *  定义业务bean：Person.java
     *  读取数据库的所有数据

Cursor cs = db.query("person", null, null, null, null, null, null);
    while(cs.moveToNext()){
        String name = cs.getString(cs.getColumnIndex("name"));
        String phone = cs.getString(cs.getColumnIndex("phone"));
        String money = cs.getString(cs.getColumnIndex("money"));
        //把读到的数据封装至Person对象
        Person p = new Person(name, phone, money);
        //把person对象保存至集合中
        people.add(p);
    }

*  把集合中的数据显示至屏幕

LinearLayout ll = (LinearLayout) findViewById(R.id.ll);
    for(Person p : people){
         //创建TextView，每条数据用一个文本框显示
         TextView tv = new TextView(this);
         tv.setText(p.toString());
         //把文本框设置为ll的子节点
         ll.addView(tv);
    }

*  分页查询

Cursor cs = db.query(“person”, null, null, null, null, null, null, “0, 10”);

--------------------

# ListView #

*  就是用来显示一行一行的条目的
 *  MVC结构  
    
    
     *  M：model模型层，要显示的数据 ————people集合
     *  V：view视图层，用户看到的界面 ————ListView
     *  c：control控制层，操作数据如何显示 ————adapter对象
 *  每一个条目都是一个View对象
 *  点击监听：lv.setOnItemClickListener();

### BaseAdapter ###

*  必须实现的两个方法
    
     *  第一个
        
            //系统调用此方法，用来获知模型层有多少条数据
            @Override
            public int getCount() {
                return people.size();
            }
     *  第二个

//系统调用此方法，获取要显示至ListView的View对象
    //position:是return的View对象所对应的数据在集合中的位置
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        System.out.println("getView方法调用" + position);
        TextView tv = new TextView(MainActivity.this);
        //拿到集合中的元素
        Person p = people.get(position);
        tv.setText(p.toString());
    
        //把TextView的对象返回出去，它会变成ListView的条目
        return tv;
    }

*  屏幕上能显示多少个条目，getView方法就会被调用多少次，屏幕向下滑动时，getView会继续被调用，创建更多的View对象显示至屏幕

### 条目的缓存 ###

*  当条目划出屏幕时，系统会把该条目缓存至内存，当该条目再次进入屏幕，系统在重新调用getView时会把缓存的条目作为convertView参数传入，但是传入的条目不一定是之前被缓存的该条目，即系统有可能在调用getView方法获取第一个条目时，传入任意一个条目的缓存

### 布局填充 ###

*  View.inflate(context , resourceid , viewgroup)
 *  LayoutInflater.from()布局填充器
 *  LayoutInflater inflater2 = (LayoutInflater) getSystemService(LAYOUT\_INFLATER\_SERVICE);
 *  ViewGroup

### ListView的优化 ###

public class MainActivity extends Activity { 
    
        List<Person> personList;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            personList = new ArrayList<Person>();
            //把数据库的数据查询出来
            MyOpenHelper oh = new MyOpenHelper(this);
            SQLiteDatabase db =  oh.getWritableDatabase();
            Cursor cursor = db.query("person", null, null, null, null, null, null, null);
            while(cursor.moveToNext()){
                String _id = cursor.getString(0);
                String name = cursor.getString(1);
                String salary = cursor.getString(2);
                String phone = cursor.getString(3);
    
                Person p = new Person(_id, name, phone, salary);
                personList.add(p);
            }
    
            ListView lv = (ListView) findViewById(R.id.lv);
            lv.setAdapter(new MyAdapter());
        }
    
        class MyAdapter extends BaseAdapter{
    
            //系统调用，用来获知集合中有多少条元素
            @Override
            public int getCount() {
                return personList.size();
            }
    
            //由系统调用，获取一个View对象，作为ListView的条目
            //position:本次getView方法调用所返回的View对象，在listView中是处于第几个条目，那么position的值就是多少
            @Override
            public View getView(int position, View convertView, ViewGroup parent) {
                Person p = personList.get(position);
    
    // TextView tv = new TextView(MainActivity.this);
                System.out.println("getView调用：" + position + ";" + convertView);
    // tv.setText(p.toString());
    // tv.setTextSize(18);
    
                View v = null;
                //判断条目是否有缓存，ListView优化
                if(convertView == null){
                    //把布局文件填充成一个View对象
                    v = View.inflate(MainActivity.this, R.layout.item_listview, null);
                }
                else{
                    v = convertView;
                }
    
    
                //获取布局填充器对象
    // LayoutInflater inflater = LayoutInflater.from(MainActivity.this);
    // 使用布局填充器填充布局文件
    // View v2 = inflater.inflate(R.layout.item_listview, null);
    
    // LayoutInflater inflater2 = (LayoutInflater) getSystemService(LAYOUT_INFLATER_SERVICE);
    // View v3 = inflater2.inflate(R.layout.item_listview, null);
    
                //通过资源id查找组件,注意调用的是View对象的findViewById
                TextView tv_name = (TextView) v.findViewById(R.id.tv_name);
                tv_name.setText(p.getName());
                TextView tv_phone = (TextView) v.findViewById(R.id.tv_phone);
                tv_phone.setText(p.getPhone());
                TextView tv_salary = (TextView) v.findViewById(R.id.tv_salary);
                tv_salary.setText(p.getSalary());
                return v;
            }
    
            @Override
            public Object getItem(int position) {
                return null;
            }
    
            @Override
            public long getItemId(int position) {
                return 0;
            }
    
        }
    }

## ArrayAdapter、SimpleAdapter ##

public class MainActivity extends Activity { 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            String[] objects = new String[]{
                    "小志",
                    "小志的儿子",
                    "萌萌"
            };
    
            ListView lv = (ListView) findViewById(R.id.lv);
    // lv.setAdapter(new ArrayAdapter<String>(this, R.layout.item_listview, R.id.tv_name, objects));
    
            //集合中每个元素都包含ListView条目需要的所有数据,该案例中每个条目需要一个字符串和一个整型,所以使用一个map来封装这两种数据
            List<Map<String, Object>> data = new ArrayList<Map<String,Object>>();
    
            Map<String, Object> map1 = new HashMap<String, Object>();
            map1.put("photo", R.drawable.photo1);
            map1.put("name", "小志的儿子");
            data.add(map1);
    
            Map<String, Object> map2 = new HashMap<String, Object>();
            map2.put("photo", R.drawable.photo2);
            map2.put("name", "小志");
            data.add(map2);
    
            Map<String, Object> map3 = new HashMap<String, Object>();
            map3.put("photo", R.drawable.photo3);
            map3.put("name", "赵帅哥");
            data.add(map3);
    
            lv.setAdapter(new SimpleAdapter(this, data, R.layout.item_listview,
                    new String[]{
       "photo", "name"}, new int[]{R.id.iv_photo, R.id.tv_name}));
        }
    }

*  图片：R.drawable.name
 *  控件：R.id.name
 *  布局：R.layout.name

--------------------

# 对话框 #

![20151021212943123][]

### 确定取消对话框 ###

*  创建对话框构建器对象，类似工厂模式

AlertDialog.Builder builder = new Builder(this);

*  设置标题和正文

builder.setTitle("警告");
    builder.setMessage("若练此功，必先自宫");

*  设置确定和取消按钮

builder.setPositiveButton("现在自宫", new OnClickListener() {
    
        @Override
        public void onClick(DialogInterface dialog, int which) {
            // TODO Auto-generated method stub
            Toast.makeText(MainActivity.this, "恭喜你自宫成功，现在程序退出", 0).show();
        }
    });
    
    builder.setNegativeButton("下次再说", new OnClickListener() {
    
        @Override
        public void onClick(DialogInterface dialog, int which) {
            // TODO Auto-generated method stub
            Toast.makeText(MainActivity.this, "若不自宫，一定不成功", 0).show();
        }
    });

*  使用构建器创建出对话框对象

AlertDialog ad = builder.create();
    ad.show();

## 单选对话框 ##

![20151021214655698][]

AlertDialog.Builder builder = new Builder(this);
    builder.setTitle("选择你的性别");
    // 定义单选选项
    final String[] items = new String[]{
            "男", "女", "其他"
    };
    //-1表示没有默认选择
    //点击侦听的导包要注意别导错
    builder.setSingleChoiceItems(items, -1, new OnClickListener() {
    
        //which表示点击的是哪一个选项
        @Override
        public void onClick(DialogInterface dialog, int which) {
            Toast.makeText(MainActivity.this, "您选择了" + items[which], 0).show();
            //对话框消失
            dialog.dismiss();
        }
    });
    
    builder.show();

### 多选对话框 ###

![这里写图片描述][20151022074118392]

AlertDialog.Builder builder = new Builder(this);
            builder.setTitle("请选择你认为最帅的人");
    // 定义多选的选项，因为可以多选，所以需要一个boolean数组来记录哪些选项被选了
    
    final String[] items = new String[]{
            "赵帅哥",
            "赵师哥",
            "赵老师",
            "侃哥"
    };
    //true表示对应位置的选项被选了
    final boolean[] checkedItems = new boolean[]{
            true,
            false,
            false,
            false,
    };
    builder.setMultiChoiceItems(items, checkedItems, new OnMultiChoiceClickListener() {
    
        //点击某个选项，如果该选项之前没被选择，那么此时isChecked的值为true
        @Override
        public void onClick(DialogInterface dialog, int which, boolean isChecked) {
            checkedItems[which] = isChecked;
        }
    });
    
    builder.setPositiveButton("确定", new OnClickListener() {
    
        @Override
        public void onClick(DialogInterface dialog, int which) {
            StringBuffer sb = new StringBuffer();
            for(int i = 0;i < items.length; i++){
                sb.append(checkedItems[i] ? items[i] + " " : "");
            }
            Toast.makeText(MainActivity.this, sb.toString(), 0).show();
        }
    });
    builder.show();

# 常见布局 #

## 线性布局 ##

## 相对布局 ##

## 帧布局 ##

*  组件默认位置都是左上角，组件之间可以重叠
 *  可以设置上下左右对齐，水平竖直居中，设置方式与线性布局一样

## 表格布局 ##

--------------------

# Logcat #

### 等级 ###

*  verbose：冗余，最低等级
 *  debug：调试
 *  info：正常等级的信息
 *  warn：警告
 *  error：错误

--------------------

# Android的存储 #

### 内部存储空间 ###

*  RAM内存：运行内存，相当于电脑的内存
 *  ROM内存：存储内存，相当于电脑的硬盘

### 外部存储空间 ###

--------------------

# 文件访问权限 #

--------------------

# SharedPreference #

*  非常适合用来保存零散的简单的数据

# 案例1：SharedPreference #

public class MainActivity extends Activity { 
    
        private EditText et_name;
        private EditText et_pass;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            et_name = (EditText) findViewById(R.id.et_name);
            et_pass = (EditText) findViewById(R.id.et_pass);
    
            readAccount();
    
        }
    
        public void readAccount(){
            SharedPreferences sp = getSharedPreferences("info", MODE_PRIVATE);
            String name = sp.getString("name", "");
            String pass = sp.getString("pass", "");
    
            et_name.setText(name);
            et_pass.setText(pass);
        }
    
        public void login(View v){
    
            String name = et_name.getText().toString();
            String pass = et_pass.getText().toString();
    
            CheckBox cb = (CheckBox) findViewById(R.id.cb);
            //判断选框是否被勾选
            if(cb.isChecked()){
                //使用sharedPreference来保存用户名和密码
                //路径在data/data/com.itheima.sharedpreference/share_
                SharedPreferences sp = getSharedPreferences("info", MODE_PRIVATE);
                //拿到sp的编辑器
                Editor ed = sp.edit();
                ed.putString("name", name);
                ed.putString("pass", pass);
                //提交
                ed.commit();
            }
    
            //创建并显示吐司对话框
            Toast.makeText(this, "登录成功", 0).show();
        }
    
    }

# 案例2：生成XML文件 #

public class MainActivity extends Activity { 
    
        List<Message> smsList;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            //虚拟10条短信
            smsList = new ArrayList<Message>();
            for(int i = 0; i < 10; i++){
                Message sms = new Message("小志好棒" + i, System.currentTimeMillis() + "", "138"+i+i, "1");
                smsList.add(sms);
            }
        }
    
        public void click(View v){
            //在内存中把xml备份短信的格式拼接出来
            StringBuffer sb = new StringBuffer();
            sb.append("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>");
            sb.append("<messages>");
            for (Message sms : smsList) {
                sb.append("<sms>");
    
                sb.append("<body>");
                sb.append(sms.getBody());
                sb.append("</body>");
    
                sb.append("<date>");
                sb.append(sms.getDate());
                sb.append("</date>");
    
                sb.append("<type>");
                sb.append(sms.getType());
                sb.append("</type>");
    
                sb.append("<address>");
                sb.append(sms.getAddress());
                sb.append("</address>");
    
                sb.append("</sms>");
            }
            sb.append("</messages>");
    
            File file = new File("sdcard/sms.xml");
            try {
                FileOutputStream fos = new FileOutputStream(file);
                fos.write(sb.toString().getBytes());
                fos.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }

# 案例3：XML序列化器 #

public class MainActivity extends Activity { 
    
        List<Message> smsList;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 虚拟10条短信
            smsList = new ArrayList<Message>();
            for (int i = 0; i < 10; i++) {
                Message sms = new Message("小志好棒" + i, System.currentTimeMillis()
                        + "", "138" + i + i, "1");
                smsList.add(sms);
            }
        }
    
        public void click(View v){
            //使用xml序列化器生成xml文件
            //1.拿到序列化器对象
            XmlSerializer xs = Xml.newSerializer();
            //2.初始化
            File file = new File("sdcard/sms2.xml");
            try {
                FileOutputStream fos = new FileOutputStream(file);
                //enconding:指定用什么编码生成xml文件
                xs.setOutput(fos, "utf-8");
    
                //3.开始生成xml文件
                //enconding:指定头结点中的enconding属性的值
                xs.startDocument("utf-8", true);
    
                xs.startTag(null, "message");
    
                for (Message sms : smsList) {
                    xs.startTag(null, "sms");
    
                    xs.startTag(null, "body");
                    xs.text(sms.getBody() + "<body>");
                    xs.endTag(null, "body");
    
                    xs.startTag(null, "date");
                    xs.text(sms.getDate());
                    xs.endTag(null, "date");
    
                    xs.startTag(null, "type");
                    xs.text(sms.getType());
                    xs.endTag(null, "type");
    
                    xs.startTag(null, "address");
                    xs.text(sms.getAddress());
                    xs.endTag(null, "address");
    
                    xs.endTag(null, "sms");
                }
    
                xs.endTag(null, "message");
    
                //告诉序列化器，文件生成完毕
                xs.endDocument();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }

# 案例4：PULL解析 #

public class MainActivity extends Activity { 
    
        List<Message> smsList;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 虚拟10条短信
            smsList = new ArrayList<Message>();
            for (int i = 0; i < 10; i++) {
                Message sms = new Message("小志好棒" + i, System.currentTimeMillis()
                        + "", "138" + i + i, "1");
                smsList.add(sms);
            }
        }
    
        public void click(View v){
            //使用xml序列化器生成xml文件
            //1.拿到序列化器对象
            XmlSerializer xs = Xml.newSerializer();
            //2.初始化
            File file = new File("sdcard/sms2.xml");
            try {
                FileOutputStream fos = new FileOutputStream(file);
                //enconding:指定用什么编码生成xml文件
                xs.setOutput(fos, "utf-8");
    
                //3.开始生成xml文件
                //enconding:指定头结点中的enconding属性的值
                xs.startDocument("utf-8", true);
    
                xs.startTag(null, "message");
    
                for (Message sms : smsList) {
                    xs.startTag(null, "sms");
    
                    xs.startTag(null, "body");
                    xs.text(sms.getBody() + "<body>");
                    xs.endTag(null, "body");
    
                    xs.startTag(null, "date");
                    xs.text(sms.getDate());
                    xs.endTag(null, "date");
    
                    xs.startTag(null, "type");
                    xs.text(sms.getType());
                    xs.endTag(null, "type");
    
                    xs.startTag(null, "address");
                    xs.text(sms.getAddress());
                    xs.endTag(null, "address");
    
                    xs.endTag(null, "sms");
                }
    
                xs.endTag(null, "message");
    
                //告诉序列化器，文件生成完毕
                xs.endDocument();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }

[img]: /images/20220708/d60f11933ce2400cbeb2f775dd18533d.png
[img 1]: /images/20220708/24f5e61be1ca499e8d5726481c038447.png
[img 2]: /images/20220708/b983996b554b4c7d8eb34bc15242fde1.png
[img 3]: /images/20220708/48711e41be3f49799718da55963f325e.png
[img 4]: /images/20220708/1be80dfa9aaf4056b43a7a4ec4c70f21.png
[img 5]: /images/20220708/514629d7d69d4789b25bb522edabb3c5.png
[img 6]: /images/20220708/80fe9781b12b4b7f8aa44164706265a9.png
[img 7]: /images/20220708/e7e05a1e350b415dbb41895c755cb9e4.png
[img 8]: /images/20220708/c724754edfc3487f96fad1337aaf0a5e.png
[img 9]: /images/20220708/49d9856dee0e42e4adf736327984fde5.png
[img 10]: /images/20220708/63bba61266c84225a0ea2046e28bd22c.png
[img 11]: /images/20220708/be17685f631f4c38801bb81621e4c5b9.png
[img 12]: /images/20220708/1bbd7be5b4b24ffe95276e651be0ef2c.png
[img 13]: /images/20220708/aba74924ca3d4474a1c988bf92e61b44.png
[img 14]: /images/20220708/f6684a1cf35941c3bc2394256dfa3cbf.png
[img 15]: /images/20220708/e70b42a682a04a519564c4951ca62750.png
[img 16]: /images/20220708/8ca61bcbdc1b455cb89560f4d421b46b.png
[img 17]: /images/20220708/491b693c752a4bf48c4c35a288e1b421.png
[img 18]: /images/20220708/e2102e8ceb9647d3aa573f49dacbb8d1.png
[img 19]: /images/20220708/9598f1ff464e45d89966a34beb5618de.png
[img 20]: /images/20220708/d3366341b2524429ab451eba428603b0.png
[img 21]: /images/20220708/a0c1df83fc9f4fd989be8a3fe47d3330.png
[img 22]: /images/20220708/9652266a118c42b088ce04252ad22e51.png
[img 23]: /images/20220708/6205a6eeddba4b3cb4fa33897eb0e284.png
[img 24]: /images/20220708/d3ad699e0ad144f196054c9f6cf80d2f.png
[img 25]: /images/20220708/e6e6bb95cdbd44e5a1ff8848781f91c9.png
[img 26]: /images/20220708/42ee7ff7d56f4e128e088977e6b64e5d.png
[img 27]: /images/20220708/cc5904330ba94c108d34300ce2d05437.png
[img 28]: /images/20220708/54764fbca2144e198fd4cffe48900c91.png
[img 29]: /images/20220708/ee19e64d1ded4ac3a8d0f5d9bf50e3f5.png
[img 30]: /images/20220708/5551e6d41d6f463287fb2271d3009259.png
[img 31]: /images/20220708/d57495fa093d42fea8b7f8f76f955f9f.png
[img 32]: /images/20220708/537c7d174d3a4e8b956f30f514bbb6a5.png
[img 33]: /images/20220708/51ec6a49523e40e1b63d9db5fd6527ef.png
[img 34]: /images/20220708/0f73d0f82c6b45f49537613fa2fa70e6.png
[img 35]: /images/20220708/8c8a754261ad4324a3ac224db820f85e.png
[img 36]: /images/20220708/1b0a4f0e4fd342c2970afdbacd5e3faf.png
[img 37]: /images/20220708/75330090235f461e93b4d34203f8ab56.png
[img 38]: /images/20220708/7c4ec5306e2e4b149b9a97df9e6c6dc3.png
[img 39]: /images/20220708/d2fb2671fe604c46bd14d1c31282321c.png
[img 40]: /images/20220708/58858b0adc1c49efa9b5b0aae7ac36ca.png
[img 41]: /images/20220708/753f8428cd054c159571fc22dafab605.png
[img 42]: /images/20220708/d3bc43484fc44703901a0cd28a8b62d4.png
[img 43]: /images/20220708/ec0900b905114d20897e366ee01415dc.png
[img 44]: /images/20220708/8f35be77da69444fa8029b56207d6da8.png
[img 45]: /images/20220708/623e40b0781143edb0f9e0f88b451427.png
[img 46]: /images/20220708/4c4c4b1cfc18454ab3388b0dc2e7639f.png
[img 47]: /images/20220708/bba60627d5cb448fa387c39dedf12f1c.png
[img 48]: /images/20220708/a6331bc7261647da979789b5efba4f02.png
[img 49]: /images/20220708/573d948bc0e44e4395bccc87b3acd346.png
[img 50]: /images/20220708/dd833251ba904b6997a8f0c643fb4fe1.png
[img 51]: /images/20220708/fd9f3c4b5c4f407d938c6541dcdcdfe8.png
[img 52]: /images/20220708/a2b2b1c779e349708d047c53496b44b7.png
[img 53]: /images/20220708/77bf5bcab01d4ed38ce32e5b0bd47114.png
[img 54]: /images/20220708/b193a59404fc48e9ac620e6374751d64.png
[img 55]: /images/20220708/3988475a25b24166804d81222c24a0fe.png
[img 56]: /images/20220708/75aef02bee7a4b25bc45ccfd76e6f02b.png
[img 57]: /images/20220708/8657295fd2074795b1bf6d3431fcde93.png
[img 58]: /images/20220708/b0d2a28f5dd345458815a6fe5f2fcfd2.png
[img 59]: /images/20220708/60c7f12d652646b1b8b443d9a964fca0.png
[img 60]: /images/20220708/ce39b38e6f05468e895c6fc2f1653706.png
[img 61]: /images/20220708/c53fb7024cd24ea68ee9eda1fd2bc011.png
[img 62]: /images/20220708/27ab551454a14b6788f1691b7b61d1ed.png
[img 63]: /images/20220708/dc1081c361a6420d83b82f0e212b20b1.png
[img 64]: /images/20220708/ddec20b511f54d2392f52651cac07abd.png
[img 65]: /images/20220708/65b78d3a572f447d96898716ba436d18.png
[img 66]: /images/20220708/c7d38ff32f5c4b24a10baf1735332a76.png
[img 67]: /images/20220708/52b80a2dcd4545d287cbef5a6cb78c0b.png
[img 68]: /images/20220708/e856727b209546279c0c6d1cba2ed20f.png
[img 69]: /images/20220708/f785bde550fa4253af8740c8b225b0ca.png
[img 70]: /images/20220708/5dc2e6e77b6847d0b88be5aeb761c17f.png
[img 71]: /images/20220708/3e5c787b60d341339e19e0f2264a3fc7.png
[img 72]: /images/20220708/47eed2c8c0ad4b1f80b61c8350a8d1f5.png
[img 73]: /images/20220708/0169729c73674af996f4118f1e7c3c65.png
[img 74]: /images/20220708/3792bf278be0452a9cb00debf1df31dc.png
[img 75]: /images/20220708/3643269d143d41de872dd873cd2b0fcc.png
[img 76]: /images/20220708/7072280373384dd38cd849116f7da206.png
[img 77]: /images/20220708/14201942341e44c29a5f4b0a36d4b151.png
[img 78]: /images/20220708/ff8ee4982f8b412b8ec323ebbf60d334.png
[img 79]: /images/20220708/c132fd41463b405ebf608dc194221f63.png
[img 80]: /images/20220708/375cfbf8a4dc4623a670983f0a4dfbae.png
[img 81]: /images/20220708/90dcb44bbbb44a7fa3a1451d67f862e3.png
[img 82]: /images/20220708/6b0d1caf99274dc7a1345ffcc1f9b4cf.png
[Android_-2]: http://blog.csdn.net/axi295309066/article/details/60875376
[20151021212943123]: /images/20220708/4ef73b7c5d8a481b8034bdaf09da3bf4.png
[20151021214655698]: /images/20220708/fb68a0a4ef3e4d859069f7ef5334d658.png
[20151022074118392]: /images/20220708/68429d88abcd4f29bb1c8a90c48032a7.png