《第一行代码》阅读记录—数据存储和网络编程

一.Android数据的存储方式

Android提供以下几种存储方式：

1 使用SharedPreferences存储数据
2 文件存储数据
3 SQLite数据库存储数据
4 使用ContentProvider存储数据
5 网络存储数据

Android系统中数据基本都是私有的，一般存放在“data/data/程序包名”目录下。如果要实现数据共享，正确的方式是使用ContentProvider。

(一)SharedPreference

SharedPreference是一种轻型的数据存储方式，实际上是基于XML文件存储的“key-value”键值对数据。通常用来存储程序的一些配置信息。其存储在“data/data/程序包名/shared_prefs“目录下。
SharedPreference本身只能获取数据，不支持存储和修改。存储和修改要通过Editor对象来实现。

修改和存储数据

• 根据Context的getSharedPrerences(key, [模式])方法获取SharedPreference对象；
• 利用SharedPreference的editor()方法获取Editor对象；
• 通过Editor的putXXX()方法，将键值对存储数据；

例子：
设置单例里面的数值，然后再将数值写入到SharedPreference里

 private String setCityName(String _cityName){
        City.getCity().setCityName(_cityName);

        Context ctx =MainActivity.this;
        SharedPreferences sp =ctx.getSharedPreferences("CITY", MODE_PRIVATE);
        Editor editor=sp.edit();
        editor.putString("CityName", City.getCity().getCityName());
        editor.commit();

        return City.getCity().getCityName();
    }

获取数据

• 同样根据Context对象获取SharedPreference对象；
• 直接使用SharedPreference的getXXX(key)方法获取数据。

从单例里面找，如果不存在则在SharedPreferences里面读取

 private String getCityName(){
        String cityName = City.getCity().getCityName();
        if(cityName==null ||cityName==""){
            Context ctx =MainActivity.this;
            SharedPreferences sp =ctx.getSharedPreferences("CITY", MODE_PRIVATE);
            City.getCity().setCityName(sp.getString("CityName", "广州"));
        }
        return City.getCity().getCityName();
    }

注意

• getSharedPrerences(key, [模式])方法中，第一个参数其实对应到XML的文件名，相同key的数据会保存到同一个文件下。
• 使用SharedPreference的getXXX(key)方法获取数据的时候，如果key不存在的活，不会出现报错，会返回none。建议使用getXXX()的时候指定默认值。

（二）SQLite

SQLite是一个轻量级关系型数据库，既然是关系型数据库，那操作起来其实跟mysql、sql server差不多的。
需要注意的一点是，SQLite只有NULL、INTEGER、REAL（浮点数）、TEXT（字符串）和BLOB（大数据）五种类型，不存在BOOLEAN和DATE类型。

特点：
面向资源有限的设备，
没有服务器进程,
所有数据存放在同一文件中跨平台，
可自由复制。

SQLite 内部结构：

下面会详细讲解如果创建数据库，添加数据和查询数据库。 创建数据库 Android 不自动提供数据库。在 Android 应用程序中使用 SQLite，必须自己创建数据库，然后创建表、索引，填充数据。

创建数据库
通过openOrCreateDatabase(String path, SQLiteDatabase.CursorFactory factory)方法创建，如果库已创建，则打开数据库。

SQLiteDatabase db =this.openOrCreateDatabase("test_db.db", Context.MODE_PRIVATE, null);

创建表
SQLiteDatabase没有提供创建表的方法，所以要靠execSQL()方法来实现。看名字也知道execSQL()用于直接执行sql的。

String sql="create table t_user (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL,password TEXT NOT NULL)";
db.execSQL(sql);

增加
使用SQLiteDatabase的insert(String table, String nullColumnHack, ContentValues values)方法插入数据。ContentValues 类，类似于java中的Map，以键值对的方式保存数据。

ContentValues values=new ContentValues();
values.put("name", "liangjh");
values.put("password", "123456");
db.insert("t_user", "id", values);

删除
删除数据就比较直接了。使用SQLiteDatabase的delete(String table, String whereClause, String[] whereArgs)实现。如果不想把参数写在whereArgs里面，可以直接把条件写在whereClause里面。

// 方式1 直接将条件写入到条件里面（个人觉得容易被注入，但其实数据都在客户端，没啥安全性可言）
db.delete("t_user", "id=1", null);
// 方式2 条件分开写，感觉比较安全
db.delete("t_user", "name=? and password =?", new String[]{"weiyg","112233"});

查询
查询有2个方法，query()和rawQuery()两个方法，区别在于query()是将sql里面的各参数提取出query()对应的参数中。可参考下面例子。

// 使用rawQuery
// Cursor c = db.rawQuery("select * from t_user", null);
// db.rawQuery("select * from t_user where id=1", null);
// db.rawQuery("select * from t_user where id=?", new String[]{"1"});

// 使用query()
Cursor c = db.query("t_user", new String[]{"id","name"}, "name=?", new String[]{"weiyg"}, null, null, null);
c.moveToFirst();
while(!c.isAfterLast()){
    String msg="";
    for(int i=0,j=c.getColumnCount();i"--"+c.getString(i);
    }
    Log.v("SQLite", "data:"+msg);
    c.moveToNext();
}

修改
使用SQLiteDatabase的update(String table, ContentValues values, String whereClause, String[] whereArgs)可以修改数据。whereClause和whereArgs用于设置其条件。ContentValues对象为数据。

ContentValues values=new ContentValues();
values.put("password", "111111");
// 方式1 条件写在字符串内
db.update("t_user", values, "id=1", null);
// 方式2 条件和字符串分开
db.update("t_user", values, "name=? or password=?",new String[]{"weiyg","123456"});

其它
无论何时，打开的数据库，记得关闭。

db.close()

另外使用beginTransaction()和endTransaction()可以设置事务。

（三）File

关于文件存储，Activity提供了openFileOutput()方法可以用于把数据输出到文件中，具体的实现过程与在J2SE环境中保存数据到文件中是一样的。
文件可用来存放大量数据，如文本、图片、音频等。
默认位置：/data/data/<包>/files/...。

public void save() 
{ 

       try { 
           FileOutputStream outStream=this.openFileOutput("a.txt",Context.MODE_WORLD_READABLE); 
           outStream.write(text.getText().toString().getBytes()); 
           outStream.close(); 
           Toast.makeText(MyActivity.this,"Saved",Toast.LENGTH_LONG).show(); 
       } catch (FileNotFoundException e) { 
           return; 
       } 
       catch (IOException e){ 
           return ; 
       } 

}

openFileOutput()方法的第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。

创建的文件保存在/data/data//files目录，如： /data/data/cn.itcast.action/files/itcast.txt ，通过点击Android Studio菜单“Tools”-“Android”-“Android Device Monitor，在项目中打开/data/data//files目录就可以看到该文件。

openFileOutput()方法的第二参数用于指定操作模式，有四种模式，分别为：

Context.MODE_PRIVATE = 0

Context.MODE_APPEND = 32768

Context.MODE_WORLD_READABLE = 1

Context.MODE_WORLD_WRITEABLE = 2

Context.MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容，如果想把新写入的内容追加到原文件中。可以使用Context.MODE_APPEND

Context.MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。

Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE用来控制其他应用是否有权限读写该文件。

MODE_WORLD_READABLE：表示当前文件可以被其他应用读取；

MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。

如果希望文件被其他应用读和写，可以传入： openFileOutput(“itcast.txt”, Context.MODE_WORLD_READABLE + Context.MODE_WORLD_WRITEABLE); android有一套自己的安全模型，当应用程序(.apk)在安装时系统就会分配给他一个userid，当该应用要去访问其他资源比如文件的时候，就需要userid匹配。默认情况下，任何应用创建的文件，sharedpreferences，数据库都应该是私有的（位于/data/data//files），其他程序无法访问。

除非在创建时指定了Context.MODE_WORLD_READABLE或者Context.MODE_WORLD_WRITEABLE ，只有这样其他程序才能正确访问。

public void load() 
{ 
    try { 
        FileInputStream inStream=this.openFileInput("a.txt"); 
        ByteArrayOutputStream stream=new ByteArrayOutputStream(); 
        byte[] buffer=new byte[1024]; 
        int length=-1; 

    while((length=inStream.read(buffer))!=-1)   { 
            stream.write(buffer,0,length); 
        } 

        stream.close(); 
        inStream.close(); 
        text.setText(stream.toString()); 
        Toast.makeText(MyActivity.this,"Loaded",Toast.LENGTH_LONG).show(); 
    } catch (FileNotFoundException e) { 
        e.printStackTrace(); 
    } 
    catch (IOException e){ 
        return ; 
    } 

}

对于私有文件只能被创建该文件的应用访问，如果希望文件能被其他应用读和写，可以在创建文件时，指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。

Activity还提供了getCacheDir()和getFilesDir()方法： getCacheDir()方法用于获取/data/data//cache目录 getFilesDir()方法用于获取/data/data//files目录。

把文件存入SDCard：

使用Activity的openFileOutput()方法保存文件，文件是存放在手机空间上，一般手机的存储空间不是很大，存放些小文件还行，如果要存放像视频这样的大文件，是不可行的。对于像视频这样的大文件，我们可以把它存放在SDCard。

SDCard是干什么的？你可以把它看作是移动硬盘或U盘。 在模拟器中使用SDCard，你需要先创建一张SDCard卡（当然不是真的SDCard，只是镜像文件）。
在AndroidManifest.xml中加入访问SDCard的权限如下:

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

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

要往SDCard存放文件，程序必须先判断手机是否装有SDCard，并且可以进行读写。
注意：访问SDCard必须在AndroidManifest.xml中加入访问SDCard的权限。

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){  
    File sdCardDir = Environment.getExternalStorageDirectory();//获取SDCard目录          

    File saveFile = new File(sdCardDir, “a.txt”); 
        FileOutputStream outStream = new FileOutputStream(saveFile); 
        outStream.write("test".getBytes()); 
        outStream.close(); 

}

Environment.getExternalStorageState()方法用于获取SDCard的状态，如果手机装有SDCard，并且可以进行读写，那么方法返回的状态等于Environment.MEDIA_MOUNTED。

Environment.getExternalStorageDirectory()方法用于获取SDCard的目录，当然要获取SDCard的目录，你也可以这样写：

File sdCardDir = new File("/sdcard"); //获取SDCard目录  

    File saveFile = new File(sdCardDir, "itcast.txt");  

    //上面两句代码可以合成一句：  

    File saveFile = new File("/sdcard/a.txt");  

    FileOutputStream outStream = new FileOutputStream(saveFile);  

    outStream.write("test".getBytes());  

    outStream.close();

（四）ContentProvider

Android这个系统和其他的操作系统还不太一样，我们需要记住的是，数据在Android当中是私有的，当然这些数据包括文件数据和数据库数据以及一些其他类型的数据。那这个时候有读者就会提出问题，难道两个程序之间就没有办法对于数据进行交换？Android这么优秀的系统不会让这种情况发生的。解决这个问题主要靠ContentProvider。一个Content Provider类实现了一组标准的方法接口，从而能够让其他的应用保存或读取此Content Provider的各种数据类型。也就是说，一个程序可以通过实现一个Content Provider的抽象接口将自己的数据暴露出去。外界根本看不到，也不用看到这个应用暴露的数据在应用当中是如何存储的，或者是用数据库存储还是用文件存储，还是通过网上获得，这些一切都不重要，重要的是外界可以通过这一套标准及统一的接口和程序里的数据打交道，可以读取程序的数据，也可以删除程序的数据，当然，中间也会涉及一些权限的问题。

一个程序可以通过实现一个ContentProvider的抽象接口将自己的数据完全暴露出去，而且ContentProviders是以类似数据库中表的方式将数据暴露，也就是说ContentProvider就像一个“数据库”。那么外界获取其提供的数据，也就应该与从数据库中获取数据的操作基本一样，只不过是采用URI来表示外界需要访问的“数据库”。

Content Provider提供了一种多应用间数据共享的方式，比如：联系人信息可以被多个应用程序访问。

Content Provider是个实现了一组用于提供其他应用程序存取数据的标准方法的类。 应用程序可以在Content Provider中执行如下操作: 查询数据 修改数据 添加数据 删除数据

标准的Content Provider: Android提供了一些已经在系统中实现的标准Content Provider，比如联系人信息，图片库等等，你可以用这些Content Provider来访问设备上存储的联系人信息，图片等等。

ContentProvider相对于其它的方式比较复杂，当然其功能相对于其它的方式也是革命性的改变。它能够实现跨应用之间的数据操作。利用ContentResolver对象的delete、update、insert、query等方法去操ContentProvider的对象，让ContentProvider对象的方法去对数据操作。实现方式为：

• 在A程序中定义一个ContentProvider，重载其增删查改等方法；
• 在A程序中的AndroidManifest.xml中注册ContentProvider；
• 在B程序中通过ContentResolver和Uri来获取ContentProvider的数据，同样利用Resolver的增删查改方法来获得和处理数据。

在A程序定义一个Provider

新建一个类，继承ContentProvider，并重载其delete()、insert()、query()、update()、getType()、onCreate()方法。譬如下面的例子，重载其onCreate和query方法。

public class MyProvider extends ContentProvider {

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public String getType(Uri uri) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public boolean onCreate() {
        // 新建个数据库并插入一条数据
        SQLiteDatabase db=this.getContext().openOrCreateDatabase("test_db2.db", Context.MODE_PRIVATE, null);
        db.execSQL("CREATE TABLE t_user (id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT NOT NULL)");
        ContentValues values=new ContentValues();
        values.put("name", "liangjh2");
        db.insert("t_user", "id", values);
        db.close();
        return false;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        // 获取数据
        SQLiteDatabase db=this.getContext().openOrCreateDatabase("test_db2.db", Context.MODE_PRIVATE, null);
        Cursor c = db.query("t_user", null, null, null, null, null, null);
        db.close();
        return c;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection,
            String[] selectionArgs) {
        // TODO Auto-generated method stub
        return 0;
    }

}

注册ContentProvider

在AndroidManifest.xml中声明ContentProvider，authorities属性定义了ContentProvider的Uri标识。关于Uri标识属另一个范畴，自行查询。provider标识要放在里面。如果遇到了”Permission Denial: opening provide...“的错误，可以试试在节点加“android:exported="true"”。

...>
    ...
    ".MyProvider" android:authorities="com.example.androidtestdemo" android:exported="true"/>

在B程序获取数据

用Context获取到当前的ContentResolver，根据Uri地址和ContentResolver的query方法获取A程序的数据。Uri地址和A程序中AndroidManifest.xml定义的autorities要一致。当然，同类可以进行其它的操作。

Context ctx=MainActivity.this;
ContentResolver resolver =ctx.getContentResolver();
Uri uri=Uri.parse("content://com.example.androidtestdemo");
Cursor c = resolver.query(uri, null, null, null, null);
c.moveToFirst();
while(!c.isAfterLast()){
    for(int i=0,j=c.getColumnCount();i
        Log.v("Android2",""+c.getString(i));
    }
    c.moveToNext();
}

(五)网络存储

前面介绍的几种存储都是将数据存储在本地设备上，除此之外，还有一种存储（获取）数据的方式，通过网络来实现数据的存储和获取。

我们可以调用WebService返回的数据或是解析HTTP协议实现网络数据交互。

具体需要熟悉java.net.，Android.net.这两个包的内容，在这就不赘述了，请大家参阅相关文档。

下面是一个通过地区名称查询该地区的天气预报，以POST发送的方式发送请求到webservicex.net站点，访问WebService.webservicex.net站点上提供查询天气预报的服务。

package com.android.weather;  

import java.util.ArrayList; 
import java.util.List; 

import org.apache.http.HttpResponse; 
import org.apache.http.NameValuePair; 
import org.apache.http.client.entity.UrlEncodedFormEntity; 
import org.apache.http.client.methods.HttpPost; 
import org.apache.http.impl.client.DefaultHttpClient; 
import org.apache.http.message.BasicNameValuePair; 
import org.apache.http.protocol.HTTP; 
import org.apache.http.util.EntityUtils; 

import android.app.Activity; 
import android.os.Bundle; 

public class MyAndroidWeatherActivity extends Activity { 
    //定义需要获取的内容来源地址 
    private static final String SERVER_URL =  
        "http://www.webservicex.net/WeatherForecast.asmx/GetWeatherByPlaceName";  

    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.main); 

        HttpPost request = new HttpPost(SERVER_URL); //根据内容来源地址创建一个Http请求 
        // 添加一个变量  
        List params = new ArrayList();  
        // 设置一个地区名称 
        params.add(new BasicNameValuePair("PlaceName", "NewYork"));  //添加必须的参数 

        try {  
            //设置参数的编码 
            request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));  
            //发送请求并获取反馈 
            HttpResponse httpResponse = new DefaultHttpClient().execute(request); 

            // 解析返回的内容 
            if(httpResponse.getStatusLine().getStatusCode() != 404){  
               String result = EntityUtils.toString(httpResponse.getEntity());  
               System.out.println(result); 
            } 
        } catch (Exception e) { 
            e.printStackTrace(); 
       }  
    }

别忘记了在配置文件中设置访问网络权限：

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

二.Android的网络编程

(一)HTTP协议原理

Http(Hypertext Transfer Protocol)超文本传输协议，是一个基于请求/响应模式的无状态的协议，Http1.1版给出了持续连接的机制，客户端建立连接之后，可以发送多次请求，当不会再发送时再关闭连接。

Android使用Java，对于Http协议的基本功能有两种实现方案：

　　1.使用JDK的java.net包下的HttpURLConnection.
　　2.使用Apache的HttpClient。
Android SDK中集成了Apache的HttpClient模块，也即说Android上两种方法都能用。

　　关于二者的比较：
　　
　　1.HttpClient的功能比较全，更加强大；而HttpURLConnection的功能较简单和原始，但是性能更好。

使用 HttpURLConnection

首先需要获取到 HttpURLConnection 的实例，一般只需 new 出一个 URL 对象，并传入目标的网络地址，然后调用一下 openConnection()方法即可，如下所示：

URL url = new URL("http://www.baidu.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();

得到了 HttpURLConnection 的实例之后，我们可以设置一下 HTTP 请求所使用的方法。常用的方法主要有两个，GET 和 POST。GET 表示希望从服务器那里获取数据，而 POST 则表示希望提交数据给服务器。写法如下：

connection.setRequestMethod("GET");

接下来就可以进行一些自由的定制了，比如设置连接超时、读取超时的毫秒数，以及服务器希望得到的一些消息头等。这部分内容根据自己的实际情况进行编写，示例写法如下：

connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);

之后再调用 getInputStream()方法就可以获取到服务器返回的输入流了， 剩下的任务就是对输入流进行读取，如下所示：

InputStream in = connection.getInputStream();

最后可以调用 disconnect()方法将这个 HTTP 连接关闭掉，如下所示：

connection.disconnect();

下面就让我们通过一个具体的例子来真正体验一下 HttpURLConnection 的用法。新建一个 NetworkTest 项目，首先修改 activity_main.xml 中的代码，如下所示：

"http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
android:id="@+id/send_request"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Send Request" />
android:layout_width="match_parent"
android:layout_height="match_parent" >
android:id="@+id/response"
android:layout_width="match_parent"
android:layout_height="wrap_content" />

接着修改 MainActivity 中的代码，如下所示：

public class MainActivity extends Activity implements OnClickListener {
public static final int SHOW_RESPONSE = 0;
private Button sendRequest;
private TextView responseText;
private Handler handler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case SHOW_RESPONSE:
String response = (String) msg.obj;
// 在这里进行UI操作，将结果显示到界面上
responseText.setText(response);
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
sendRequest = (Button) findViewById(R.id.send_request);
responseText = (TextView) findViewById(R.id.response_text);
sendRequest.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.send_request) {
sendRequestWithHttpURLConnection();
}
}
private void sendRequestWithHttpURLConnection() {
// 开启线程来发起网络请求
new Thread(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
try {
URL url = new URL("http://www.baidu.com");
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setConnectTimeout(8000);
connection.setReadTimeout(8000);
InputStream in = connection.getInputStream();
// 下面对获取到的输入流进行读取
BufferedReader reader = new BufferedReader(new
InputStreamReader(in));
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
response.append(line);
}
Message message = new Message();
message.what = SHOW_RESPONSE;
// 将服务器返回的结果存放到Message中
message.obj = response.toString();
handler.sendMessage(message);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
connection.disconnect();
}
}
}
}).start();
}
}

可以看到，我们在 Send Request 按钮的点击事件里调用了 sendRequestWithHttpURLConnection()方法， 在这个方法中先是开启了一个子线程， 然后在子线程里使用 HttpURLConnection发出一条 HTTP 请求，请求的目标地址就是百度的首页。接着利用 BufferedReader 对服务器返回的流进行读取，并将结果存放到了一个 Message 对象中。这里为什么要使用 Message 对象呢？当然是因为子线程中无法对 UI 进行操作了。我们希望可以将服务器返回的内容显示到界面上， 所以就创建了一个 Message 对象， 并使用 Handler 将它发送出去。 之后又在 Handler的 handleMessage()方法中对这条 Message 进行处理，最终取出结果并设置到 TextView 上。完整的一套流程就是这样，不过在开始运行之前，仍然别忘了要声明一下网络权限。修改 AndroidManifest.xml 中的代码，如下所示：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.networktest"
android:versionCode="1"
android:versionName="1.0" >
……
<uses-permission android:name="android.permission.INTERNET" />
……
manifest>

那么如果是想要提交数据给服务器应该怎么办呢？其实也不复杂，只需要将 HTTP 请求的方法改成 POST，并在获取输入流之前把要提交的数据写出即可。注意每条数据都要以键值对的形式存在，数据与数据之间用&符号隔开，比如说我们想要向服务器提交用户名和密码，就可以这样写：

connection.setRequestMethod("POST");
DataOutputStream out = new DataOutputStream(connection.getOutputStream());
out.writeBytes("username=admin&password=123456");

使用 HttpClient

首先你需要知道，HttpClient 是一个接口，因此无法创建它的实例，通常情况下都会创建一个 DefaultHttpClient 的实例，如下所示：

HttpClient httpClient = new DefaultHttpClient();

接下来如果想要发起一条 GET 请求，就可以创建一个 HttpGet 对象，并传入目标的网络地址，然后调用 HttpClient 的 execute()方法即可：

HttpGet httpGet = new HttpGet("http://www.baidu.com");
httpClient.execute(httpGet);

如果是发起一条 POST 请求会比 GET 稍微复杂一点，我们需要创建一个 HttpPost 对象，并传入目标的网络地址，如下所示：

HttpPost httpPost = new HttpPost("http://www.baidu.com");

然后通过一个 NameValuePair 集合来存放待提交的参数，并将这个参数集合传入到一个UrlEncodedFormEntity 中，然后调用 HttpPost 的 setEntity()方法将构建好的 UrlEncodedFormEntity传入，如下所示：

List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("username", "admin"));
params.add(new BasicNameValuePair("password", "123456"));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, "utf-8");
httpPost.setEntity(entity);

接下来的操作就和 HttpGet 一样了，调用 HttpClient 的 execute()方法，并将 HttpPost 对象传入即可：

httpClient.execute(httpPost);

执行 execute()方法之后会返回一个 HttpResponse 对象， 服务器所返回的所有信息就会包含在这里面。通常情况下我们都会先取出服务器返回的状态码，如果等于 200响应都成功了，如下所示：

if (httpResponse.getStatusLine().getStatusCode() == 200) {
// 请求和响应都成功了
}

接下来在这个 if 判断的内部取出服务返回的具体内容，可以调用 getEntity()方法获取到一个 HttpEntity 实例， 然后再用 EntityUtils.toString()这个静态方法将 HttpEntity 转换成字符串
即可，如下所示：

HttpEntity entity = httpResponse.getEntity();
String response = EntityUtils.toString(entity);

注意如果服务器返回的数据是带有中文的，直接调用 EntityUtils.toString()方法进行转换会有乱码的情况出现，这个时候只需要在转换的时候将字符集指定成 utf-8 就可以了，如下所示：

String response = EntityUtils.toString(entity, "utf-8");

好了，基本的用法就是如此，接下来就让我们把 NetworkTest 这个项目改用 HttpClient的方式再实现一遍吧。由于布局部分完全不用改动，所以现在直接修改 MainActivity 中的代码，如下所示：

public class MainActivity extends Activity implements OnClickListener {
……
@Override
public void onClick(View v) {
if (v.getId() == R.id.send_request) {
sendRequestWithHttpClient();
}
}
private void sendRequestWithHttpClient() {
new Thread(new Runnable() {
@Override
public void run() {
try {
HttpClient httpClient = new DefaultHttpClient();
HttpGet httpGet = new HttpGet("http://www.baidu.com");
HttpResponse httpResponse = httpClient.execute(httpGet);
if (httpResponse.getStatusLine().getStatusCode() == 200) {
// 请求和响应都成功了
HttpEntity entity = httpResponse.getEntity();
String response = EntityUtils.toString(entity,
"utf-8");
Message message = new Message();
message.what = SHOW_RESPONSE;
// 将服务器返回的结果存放到Message中
message.obj = response.toString();
handler.sendMessage(message);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
……
}

这里我们并没有做太多的改动，只是添加了一个 sendRequestWithHttpClient()方法，并在Send Request 按钮的点击事件里去调用这个方法。在这个方法中同样还是先开启了一个子线程，然后在子线程里使用 HttpClient 发出一条 HTTP 请求，请求的目标地址还是百度的首页，HttpClient 的用法也正如前面所介绍的一样。然后为了能让结果在界面上显示出来，这里仍然是将服务器返回的数据存放到了 Message 对象中，并用 Handler 将 Message 发送出去。仅仅只是改了这么多代码，现在我们可以重新运行一下程序了。点击 Send Request 按钮后，你会看到和上一小节中同样的运行结果，由此证明，使用 HttpClient 来发送 HTTP 请求的功能也已经成功实现了。

(二)XML

XML在各种开发中都广泛应用，Android也不例外。作为承载数据的一个重要角色，如何读写XML成为Android开发中一项重要的技能。在Android中，常见的XML解析器分别为DOM解析器、SAX解析器和PULL解析器。

第一种方式：DOM解析器：

DOM是基于树形结构的的节点或信息片段的集合，允许开发人员使用DOM API遍历XML树、检索所需数据。分析该结构通常需要加载整个文档和构造树形结构，然后才可以检索和更新节点信息。

Android完全支持DOM 解析。利用DOM中的对象，可以对XML文档进行读取、搜索、修改、添加和删除等操作。

DOM的工作原理：使用DOM对XML文件进行操作时，首先要解析文件，将文件分为独立的元素、属性和注释等，然后以节点树的形式在内存中对XML文件进行表示，就可以通过节点树访问文档的内容，并根据需要修改文档——这就是DOM的工作原理。

DOM实现时首先为XML文档的解析定义一组接口，解析器读入整个文档，然后构造一个驻留内存的树结构，这样代码就可以使用DOM接口来操作整个树结构。

由于DOM在内存中以树形结构存放，因此检索和更新效率会更高。但是对于特别大的文档，解析和加载整个文档将会很耗资源。 当然，如果XML文件的内容比较小，采用DOM是可行的。

常用的DoM接口和类：

Document：该接口定义分析并创建DOM文档的一系列方法，它是文档树的根，是操作DOM的基础。

Element：该接口继承Node接口，提供了获取、修改XML元素名字和属性的方法。

Node：该接口提供处理并获取节点和子节点值的方法。

NodeList：提供获得节点个数和当前节点的方法。这样就可以迭代地访问各个节点。

DOMParser：该类是Apache的Xerces中的DOM解析器类，可直接解析XML文件。

下面是DOM的解析流程：

第二种方式：SAX解析器：

SAX(Simple API for XML)解析器是一种基于事件的解析器，事件驱动的流式解析方式是，从文件的开始顺序解析到文档的结束，不可暂停或倒退。它的核心是事件处理模式，

主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后，调用事件处理器相应的处理方法，一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候，

还要传递给事件处理器相应事件的状态信息，这样事件处理器才能够根据提供的事件信息来决定自己的行为。

SAX解析器的优点是解析速度快，占用内存少。非常适合在Android移动设备中使用。

SAX的工作原理：SAX的工作原理简单地说就是对文档进行顺序扫描，

当扫描到文档(document)开始与结束、元素(element)开始与结束、文档(document)结束等地方时通知事件处理函数，由事件处理函数做相应动作，然后继续同样的扫描，直至文档结束。

在SAX接口中，事件源是org.xml.sax包中的XMLReader，它通过parser()方法来解析XML文档，并产生事件。

事件处理器是org.xml.sax包中ContentHander、DTDHander、ErrorHandler，以及EntityResolver这4个接口。XMLReader通过相应事件处理器注册方法setXXXX()来完成的与ContentHander、DTDHander、ErrorHandler，以及EntityResolver这4个接口的连接。

常用的SAX接口和类：
Attrbutes：用于得到属性的个数、名字和值。

ContentHandler：定义与文档本身关联的事件(例如，开始和结束标记)。大多数应用程序都注册这些事件。

DTDHandler：定义与DTD关联的事件。它没有定义足够的事件来完整地报告DTD。如果需要对DTD进行语法分析，请使用可选的DeclHandler。

DeclHandler是SAX的扩展。不是所有的语法分析器都支持它。

EntityResolver：定义与装入实体关联的事件。只有少数几个应用程序注册这些事件。

ErrorHandler：定义错误事件。许多应用程序注册这些事件以便用它们自己的方式报错。

DefaultHandler：它提供了这些接LI的缺省实现。在大多数情况下，为应用程序扩展DefaultHandler并覆盖相关的方法要比直接实现一个接口更容易。

下面是SAX的解析流程：

第三种方式：PULL解析器：

Android并未提供对Java StAX API的支持。但是，Android附带了一个pull解析器，其工作方式类似于SAX。它允许用户的应用程序代码从解析器中获取事件，这与SAX解析器自动将事件推入处理程序相反。

PULL解析器的运行方式和SAX类似，都是基于事件的模式。不同的是，在PULL解析过程中返回的是数字，且我们需要自己获取产生的事件然后做相应的操作，而不像SAX那样由处理器触发一种事件的方法，执行我们的代码。

读取到xml的声明返回 START_DOCUMENT;

读取到xml的结束返回 END_DOCUMENT ;

读取到xml的开始标签返回 START_TAG

读取到xml的结束标签返回 END_TAG

读取到xml的文本返回 TEXT

PULL解析器小巧轻便，解析速度快，简单易用，非常适合在Android移动设备中使用，Android系统内部在解析各种XML时也是用PULL解析器，Android官方推荐开发者们使用Pull解析技术。Pull解析技术是第三方开发的开源技术，它同样可以应用于JavaSE开发。

PULL 的工作原理：XML pull提供了开始元素和结束元素。当某个元素开始时，我们可以调用parser．nextText从XML文档中提取所有字符数据。当解释到一个文档结束时，自动生成EndDocument事件。

常用的XML pull的接口和类：

XmlPullParser：XML pull解析器是一个在XMLPULL VlAP1中提供了定义解析功能的接口。

XmlSerializer：它是一个接口，定义了XML信息集的序列。

XmlPullParserFactory：这个类用于在XMPULL V1 API中创建XML Pull解析器。

XmlPullParserException：抛出单一的XML pull解析器相关的错误。

PULL的解析流程如下：

[附加]第四种方式： Android.util.Xml类

在Android API中，另外提供了Android．util．Xml类，同样可以解析XML文件，使用方法类似SAX，也都需编写Handler来处理XML的解析，但是在使用上却比SAX来得简单 ，如下所示：
以android.util.XML实现XML解析,

MyHandler myHandler = new MyHandler0；
android.util.Xm1.parse(ur1．openC0nnection()．getlnputStream0，Xm1.Encoding.UTF-8，myHandler)；

采用DOM解析时具体处理步骤是：

1 首先利用DocumentBuilderFactory创建一个DocumentBuilderFactory实例
2 然后利用DocumentBuilderFactory创建DocumentBuilder
3 然后加载XML文档（Document）,
4 然后获取文档的根结点(Element)，
5 然后获取根结点中所有子节点的列表（NodeList），
6 然后使用再获取子节点列表中的需要读取的结点。

采用SAX解析时具体处理步骤是：

1 创建SAXParserFactory对象
2 根据SAXParserFactory.newSAXParser()方法返回一个SAXParser解析器
3 根据SAXParser解析器获取事件源对象XMLReader
4 实例化一个DefaultHandler对象
5 连接事件源对象XMLReader到事件处理类DefaultHandler中
6 调用XMLReader的parse方法从输入源中获取到的xml数据
7 通过DefaultHandler返回我们需要的数据集合。

采用PULL解析基本处理方式：

当PULL解析器导航到文档开始标签时就开始实例化list集合用来存贮数据对象。导航到元素开始标签时回判断元素标签类型，如果是river标签，则需要实例化River对象了，

如果是其他类型，则取得该标签内容并赋予River对象。当然它也会导航到文本标签，不过在这里，我们可以不用。

根据以上的解释，我们可以得出以下处理xml文档逻辑：

1：当导航到XmlPullParser.START_DOCUMENT，可以不做处理，当然你可以实例化集合对象等等。
2：当导航到XmlPullParser.START_TAG，则判断是否是river标签，如果是，则实例化river对象，并调用getAttributeValue方法获取标签中属性值。
3：当导航到其他标签，比如Introduction时候，则判断river对象是否为空，如不为空，则取出Introduction中的内容，nextText方法来获取文本节点内容
4：当然啦，它一定会导航到XmlPullParser.END_TAG的，有开始就要有结束嘛。在这里我们就需要判读是否是river结束标签，如果是，则把river对象存进list集合中了，并设置river对象为null.

几种解析技术的比较与总结：

对于Android的移动设备而言，因为设备的资源比较宝贵，内存是有限的，所以我们需要选择适合的技术来解析XML，这样有利于提高访问的速度。

1 DOM在处理XML文件时，将XML文件解析成树状结构并放入内存中进行处理。当XML文件较小时，我们可以选DOM，因为它简单、直观。

2 SAX则是以事件作为解析XML文件的模式，它将XML文件转化成一系列的事件，由不同的事件处理器来决定如何处理。XML文件较大时，选择SAX技术是比较合理的。虽然代码量有些大，但是它不需要将所有的XML文件加载到内存中。这样对于有限的Android内存更有效，而且Android提供了一种传统的SAX使用方法以及一个便捷的SAX包装器。 使用Android．util．Xml类，从示例中可以看出，会比使用 SAX来得简单。

3 XML pull解析并未像SAX解析那样监听元素的结束，而是在开始处完成了大部分处理。这有利于提早读取XML文件，可以极大的减少解析时间，这种优化对于连接速度较漫的移动设备而言尤为重要。对于XML文档较大但只需要文档的一部分时，XML Pull解析器则是更为有效的方法。

(三)WebView

目前很多android app都内置了可以显示web页面的界面，会发现这个界面一般都是由一个叫做WebView的组件渲染出来的，学习该组件可以为你的app开发提升扩展性。

先说下WebView的一些优点：

• 可以直接显示和渲染web页面，直接显示网页
• webview可以直接用html文件（网络上或本地assets中）作布
• 和JavaScript交互调用

一、基本使用
首先layout中即为一个基本的简单控件：

<WebView
        android:id="@+id/webView1"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_marginTop="10dp" />

同时，因为要房访问网络，所以manifest中必须要加uses-permission：

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

在activity中即可获得webview的引用，同时load一个网址：

webview = (WebView) findViewById(R.id.webView1);
webview.loadUrl("http://www.baidu.com/");
//webview.reload();// reload page

这个时候发现一个问题，启动应用后，自动的打开了系统内置的浏览器，解决这个问题需要为webview设置 WebViewClient，并重写方法：

webview.setWebViewClient(new WebViewClient(){
            @Override
            public boolean shouldOverrideUrlLoading(WebView view, String url) {
                view.loadUrl(url);
                return true;
            }
        });

若自己定义了一个页面加载进度的progressbar，需要展示给用户的时候，可以通过如下方式获取webview内页面的加载进度：

webview.setWebChromeClient(new WebChromeClient(){
            @Override
            public void onProgressChanged(WebView view, int newProgress) {
                //get the newProgress and refresh progress bar
            }
        });

每个页面，都有一个标题，比如www.baidu.com这个页面的title即“百度一下，你就知道”，那么如何知道当前webview正在加载的页面的title呢：

webview.setWebChromeClient(new WebChromeClient(){
            @Override
            public void onReceivedTitle(WebView view, String title) {
                titleview.setText(title);//a textview
            }
        });

二、通过webview控件下载文件
通常webview渲染的界面中含有可以下载文件的链接，点击该链接后，应该开始执行下载的操作并保存文件到本地中。webview来下载页面中的文件通常有两种方式：

1. 自己通过一个线程写java io的代码来下载和保存文件（可控性好）

2. 调用系统download的模块（代码简单）

方法一：

首先要写一个下载并保存文件的线程类

public class HttpThread extends Thread {
  private String mUrl;
  public HttpThread(String mUrl) {
    this.mUrl = mUrl;
  }
  @Override
  public void run() {
    URL url;
    try {
      url = new URL(mUrl);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setDoInput(true);
      conn.setDoOutput(true);
      InputStream in = conn.getInputStream();
      File downloadFile;
      File sdFile;
      FileOutputStream out = null;
      if(Environment.getExternalStorageState().equals(Environment.MEDIA_UNMOUNTED)){
        downloadFile = Environment.getExternalStorageDirectory();
        sdFile = new File(downloadFile, "test.file");
        out = new FileOutputStream(sdFile);
      }
      //buffer 4k
      byte[] buffer = new byte[1024 * 4];
      int len = 0;
      while((len = in.read(buffer)) != -1){
        if(out != null)
          out.write(buffer, 0, len);
      }
      //close resource
      if(out != null)
        out.close();
      if(in != null){
        in.close();
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

随后要实现一个DownloadListener接口，这个接口实现方法OnDownloadStart()，当用户点击一个可以下载的链接时，该回调方法被调用同时传进来该链接的URL，随后即可以对该URL塞入HttpThread进行下载操作：

//创建DownloadListener (webkit包)

class MyDownloadListenter implements DownloadListener{
  @Override
  public void onDownloadStart(String url, String userAgent,
    String contentDisposition, String mimetype, long contentLength) {
      System.out.println("url ==== >" + url);
      new HttpThread(url).start();
  }
    }

//给webview加入监听

webview.setDownloadListener(new MyDownloadListenter());

方法二：

直接发送一个action_view的intent即可：

class MyDownloadListenter implements DownloadListener{
        @Override
        public void onDownloadStart(String url, String userAgent,
      String contentDisposition, String mimetype, long contentLength) {
  System.out.println("url ==== >" + url);
  //new HttpThread(url).start();

  Uri uri = Uri.parse(url);
  Intent intent = new Intent(Intent.ACTION_VIEW, uri);
  startActivity(intent);
        }
    }

三、错误处理
当我们使用浏览器的时候，通常因为加载的页面的服务器的各种原因导致各种出错的情况，最平常的比如404错误，通常情况下浏览器会提示一个错误提示页面。事实上这个错误提示页面是浏览器在加载了本地的一个页面，用来提示用户目前已经出错了。

但是当我们的app里面使用webview控件的时候遇到了诸如404这类的错误的时候，若也显示浏览器里面的那种错误提示页面就显得很丑陋了，那么这个时候我们的app就需要加载一个本地的错误提示页面，即webview如何加载一个本地的页面。

1. 首先我们需要些一个html文件，比如error_handle.html，这个文件里面就是当出错的时候需要展示给用户看的一个错误提示页面，尽量做的精美一些。然后将该文件放置到代码根目录的assets文件夹下。

2. 随后我们需要复写WebViewClient的onRecievedError方法，该方法传回了错误码，根据错误类型可以进行不同的错误分类处理

webview.setWebViewClient(new WebViewClient(){

      @Override
      public void onReceivedError(WebView view, int errorCode,
        String description, String failingUrl) {
    switch(errorCode)
    {
    case HttpStatus.SC_NOT_FOUND:
        view.loadUrl("file:///android_assets/error_handle.html");
        break;
    }
      }
  });

其实，当出错的时候，我们可以选择隐藏掉webview，而显示native的错误处理控件，这个时候只需要在onReceivedError里面显示出错误处理的native控件同时隐藏掉webview即可。

(四)Json

android中用jsonObject解析json数据
json数据格式解析我自己分为两种；

一种是普通的，一种是带有数组形式的；

普通形式的：
服务器端返回的json数据格式如下：

     {"userbean":{"Uid":"100196","Showname":"\u75af\u72c2\u7684\u7334\u5b50","Avtar":null,"State":1}}

分析代码
// TODO 状态处理 500 200

 int res = 0; 
 res = httpClient.execute(httpPost).getStatusLine().getStatusCode(); 
            if (res == 200) { 

/* *
* 当返回码为200时，做处理
*
* 得到服务器端返回json数据，并做处理
* */

                HttpResponse httpResponse = httpClient.execute(httpPost); 
                StringBuilder builder = new StringBuilder(); 
                BufferedReader bufferedReader2 = new BufferedReader( 
                        new InputStreamReader(httpResponse.getEntity().getContent())); 
                String str2 = ""; 
                for (String s = bufferedReader2.readLine(); s != null; s = bufferedReader2 
                        .readLine()) { 
                    builder.append(s); 
                } 
                Log.i("cat", ">>>>>>" + builder.toString());

  JSONObject jsonObject = new JSONObject(builder.toString()) 

    String Uid; 
    String Showname; 
     String Avtar; 
    String State; 
   Uid = jsonObject.getString("Uid"); 
 Showname = jsonObject.getString("Showname"); 
 Avtar = jsonObject.getString("Avtar"); 
State = jsonObject.getString("State");         

带数组形式的：
服务器端返回的数据格式为：

{"calendar": 
    {"calendarlist": 
            [ 
            {"calendar_id":"1705","title":"(\u4eb2\u5b50)ddssd","category_name":"\u9ed8\u8ba4\u5206\u7c7b","showtime":"1288927800","endshowtime":"1288931400","allDay":false}, 
            {"calendar_id":"1706","title":"(\u65c5\u884c)","category_name":"\u9ed8\u8ba4\u5206\u7c7b","showtime":"1288933200","endshowtime":"1288936800","allDay":false} 
            ] 
    } 
}

分析代码如下：

// TODO 状态处理 500 200 
    int res = 0; 
    res = httpClient.execute(httpPost).getStatusLine().getStatusCode(); 
                if (res == 200) { 
 /* * 当返回码为200时，做处理 
   *     得到服务器端返回json数据，并做处理 
   * */ 
                    HttpResponse httpResponse = httpClient.execute(httpPost); 
                    StringBuilder builder = new StringBuilder(); 
                    BufferedReader bufferedReader2 = new BufferedReader( 
                            new InputStreamReader(httpResponse.getEntity().getContent())); 
                    String str2 = ""; 
                    for (String s = bufferedReader2.readLine(); s != null; s = bufferedReader2 
                            .readLine()) { 
                        builder.append(s); 
                    } 
                    Log.i("cat", ">>>>>>" + builder.toString()); 

 /** 
 * 这里需要分析服务器回传的json格式数据， 
  */  
      JSONObject jsonObject = new JSONObject(builder.toString()) 
                            .getJSONObject("calendar"); 
                    JSONArray jsonArray = jsonObject.getJSONArray("calendarlist"); 
                    for(int i=0;i
                        JSONObject jsonObject2 = (JSONObject)jsonArray.opt(i); 
                        CalendarInfo calendarInfo = new CalendarInfo(); 
                        calendarInfo.setCalendar_id(jsonObject2.getString("calendar_id")); 
                        calendarInfo.setTitle(jsonObject2.getString("title")); 
                        calendarInfo.setCategory_name(jsonObject2.getString("category_name")); 
                        calendarInfo.setShowtime(jsonObject2.getString("showtime")); 
                        calendarInfo.setEndtime(jsonObject2.getString("endshowtime")); 
                        calendarInfo.setAllDay(jsonObject2.getBoolean("allDay")); 
                        calendarInfos.add(calendarInfo); 
                    }

总结，普通形式的只需用JSONObject ，带数组形式的需要使用JSONArray 将其变成一个list。

android中用gson解析json

什么是JSON
1 JavaScript Object Notation
2 JSON数据是一系列键值对的集合
3 JSON在网络数据传输中应用广泛
4 JSON相对于XML，解析更方便

{  
    "name":"Michael",  
    "address":  
    {  
        "city":"Beijing",  
        "street":"xxxRoad",  
        "post":"200000"  
    }  
}  

大括号就是一个JSON对象 中括号代表一个JSON对象的数组

JSON数据格式的特点

JSON vs XML

●JSON和XML可读性基本相同
●JSON和XML同样拥有丰富的解析手段
●JSON相对于XML体积更小
●JSON与JavaScript交互更方便
●JSON对数据描述性相对较差

使用Gson解析JSON数据
自带JsonReader 针对3.0 因此不建议使用
Gson 导入gson.jar

第一种方式（普通解析）
//首先生成一个JsonReader对象

JsonReader reader= new JsonReader(new StringReader(jsonData));  
reader.beginArray();    //代表开始解析数组  
while(reader.hasNext()){  
    reader.beginObejct();   //代表开始解析对象  
    while(reader.hasNext()){  
        String tagName=reader.nextName();   //得到键  
        reader.nextInt();   //得到值 同样还有nextString等  
    }  
    reader.endObject();  
}  
reader.endArray();  

第二种方式（解析一个JSON对象）
//创建一个代表JSON对象的Bean

Gson gson=new Gson();  
User user=gson.fromJson(jsonData,User.class); 

//jsonData是一个Json对象

第三种方式(JSON对象数组)

Type listType=new TypeToken>(){}.getType();    //TypeToken是一个空的抽象类  
Gson gson=new Gson();  
LinkedList users=gson.fromJson(jsonData,ListType);  //User对象会被保存到LinkedList中  
//再进行遍历  
for(Iterator iterator = users.iterator();iterator.hasNext();){  
    User user=(User)iterator.next();  
    //...doSomething  
}