listview分页载入问题

方案一:

底部有查看很多其它能够使用HeaderViewListAdapter
假设须要加入数据, 就向Adapter绑定的数据里面加入. 然后调用Adapter.notifyDataSetChanged()方法, ListView会自己主动刷新;

public class

HeaderViewListAdapter

extends Object
implements Filterable WrapperListAdapter

java.lang.Object
↳	android.widget.HeaderViewListAdapter

Class Overview

---

ListAdapter used when a ListView has header views. This ListAdapter wraps another one and also keeps track of the header views and their associated data objects.

This is intended as a base class; you will probably not need to use this class directly in your own code.

方案二:

简单说一下怎么实现listview分页载入：
1.在listview初始化的时候加个footview，并初始化相关变量以及要设置listview的OnScrollListener：
listview = (ListView) layoutMain.findViewById(R.id.vidoe_list);
                layoutFooter = (RelativeLayout) mLayoutInflater.inflate(
                                R.layout.contact_list_footer, null);
                listview.addFooterView(layoutFooter);
                adapter = new VideoListAdapter();
                
                listview.setAdapter(adapter);
                listview.setOnItemClickListener(mItemClickListener);
                listview.setOnScrollListener(mHLOnScrollListener);


2.载入数据：载入数据的时候最好用一个线程来执行载入过程，完了之后就用handler发个消息出来。这里要控制这个线程的
生命周期，假如线程已经启动而且还没跑完，就先不要再启动，等上一次跑完再start一个线程

        private Thread threadLoadHLData;
        List<VidoeDetailInfoItem> listVideoInfo = new ArrayList<VidoeDetailInfoItem>();// 数据列表
        List data ;
        private void onLoadData(final String url, final String pageName) {

                if (threadLoadHLData == null || !threadLoadHLData.isAlive()) {//检測线程状态
                        threadLoadHLData = new Thread() {
                                public void run() {
                                        Looper.prepare();
                                        try {
                                                 data = VideoDownloadClient.requestPageData(
                                                                VideoListLayoutManager.this.ctx, url,
                                                                PageParserFactory.getParser(parserType), pageName);
                                                //sleep(200);
                                                if(null != data){
                                                        HLhandler.obtainMessage(1).sendToTarget();
                                                }else{
                                                        HLhandler.obtainMessage(2).sendToTarget();
                                                }
                                        } catch (IOException e) {
                                                // TODO Auto-generated catch block
                                                Log.e("IOException", e.getMessage());
                                                HLhandler.obtainMessage(2).sendToTarget();
                                        }
                                }
                        };
                        threadLoadHLData.start();
                }
        }



3.在OnScrollListener的实现方法中检測是不是已经滑动到最后一个：
OnScrollListener mHLOnScrollListener = new OnScrollListener(){

                public void onScroll(AbsListView view, int firstVisibleItem,
                                int visibleItemCount, int totalItemCount) {
                        // TODO Auto-generated method stub
                        if (firstVisibleItem + visibleItemCount == totalItemCount) {//推断是不是最后一个
                                // 开线程去下载网络数据
                                if (threadLoadHLData == null || !threadLoadHLData.isAlive()) {
                                        
                                        onLoadData(url );／／这里的载入数据跟開始初始化时一样的
                                        //if (pageHLIndex < 82) {
                                                pageHLIndex++;
                                        //}
                                        
                                }
                        }

                }

                @Override
                public void onScrollStateChanged(AbsListView view, int scrollState) {
                        // TODO Auto-generated method stub

                }
                
        };

方案三:

Android market里软件列表，每页显示10条记录，没有显示上一页，下一页的button，依靠手滑动动态载入数据，当向下滚动时，最下边显示 Loading… 。数据载入结束，Loading底栏消失。关于ListView的分段显示，有现成的库可用，比方 cwac-endless, 这个库不好之处，就是底部Loading的View无法定制。另一个在google code上的androidpageablelistview 这个能够实现主要的分页，有手动操作显示上一页，下一页的button。查阅了非常多资料，发现事实上ListView自带一个实现分页载入的方法，用到addFooterView/removeView 这两个函数“加入”或“去掉“ListView页脚。以下是一个研究ListView分页时做的一个Demo，比較简单，我把思路我源代码和大家分享一下，希望对大家有所帮助。
效果图：  
实现思路如是：用onScroll方法实现”滑动“后处理检查是否还有新的记录，假设有，调用addFooterView，加入记录到adapter, adapter调用 notifyDataSetChanged 更新数据;假设没有记录了， 把自己定义的mFooterView去掉。这里没有重写onScrollStateChanged函数，那么在onScroll就须要一个外部变量mFirstCell记录滑动位置。

代码例如以下：

import android.app.ListActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.BaseAdapter;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.AbsListView.OnScrollListener;
import android.widget.LinearLayout.LayoutParams;
/**
* 
* @author huangbq
*
*/
public class MainActivity extends ListActivity implements OnScrollListener {

private static final String TAG = "MainActivity";
private listViewAdapter adapter = new listViewAdapter();
ListView listView ;
private int lastItem = 0;
LinearLayout loadingLayout;
/**
  * 设置布局显示属性
  */
    private LayoutParams mLayoutParams =new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,LinearLayout.LayoutParams.WRAP_CONTENT);
    /**
  * 设置布局显示目标最大化属性
  */
    private LayoutParams FFlayoutParams =new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);
    
private ProgressBar progressBar;
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  Log.i(TAG, "onCreate(Bundle savedInstanceState)>>>>>>>>>>>>>>>" );
     //线性布局
  LinearLayout layout = new LinearLayout(this);
    //设置布局 水平方向
  layout.setOrientation(LinearLayout.HORIZONTAL);
   //进度条
  progressBar = new ProgressBar(this);
   //进度条显示位置
  progressBar.setPadding(0, 0, 15, 0);
  //把进度条增加到layout中
  layout.addView(progressBar, mLayoutParams);
  //文本内容
  TextView textView = new TextView(this);
  textView.setText("载入中...");
  textView.setGravity(Gravity.CENTER_VERTICAL);
  //把文本增加到layout中
  layout.addView(textView, FFlayoutParams);
  //设置layout的重力方向，即对齐方式是
  layout.setGravity(Gravity.CENTER);
  
  //设置ListView的页脚layout
  loadingLayout = new LinearLayout(this);
  loadingLayout.addView(layout, mLayoutParams);
  loadingLayout.setGravity(Gravity.CENTER);
  
  //得到一个ListView用来显示条目
  listView = getListView();
  //加入到页脚显示
  listView.addFooterView(loadingLayout);
  //给ListView加入适配器
  setListAdapter(adapter);
  //给ListView注冊滚动监听
  listView.setOnScrollListener(this);
}
@Override
public void onScroll(AbsListView v, int firstVisibleItem,
   int visibleItemCount, int totalItemCount) {
  Log.i(TAG , "Scroll>>>first: " + firstVisibleItem + ", visible: " + visibleItemCount + ", total: " + totalItemCount);
  lastItem = firstVisibleItem + visibleItemCount - 1;
  Log.i(TAG , "Scroll>>>lastItem:" + lastItem);
  //显示50条ListItem，即0-49，由于onScroll是在“滑动”运行过之后才触发，所以用adapter.count<=41作条件
  if (adapter.count<=41) {
   if (firstVisibleItem+visibleItemCount==totalItemCount) {
    adapter.count += 10;
    adapter.notifyDataSetChanged();
    listView.setSelection(lastItem);
    int currentPage=adapter.count/10;
    Toast.makeText(getApplicationContext(), "第"+currentPage+"页", Toast.LENGTH_LONG).show();
   }
  }
  else {
    listView.removeFooterView(loadingLayout); 
  }
  
  
}
@Override
public void onScrollStateChanged(AbsListView v, int state) {
  if (lastItem == adapter.count && state == OnScrollListener.SCROLL_STATE_IDLE) {
   Log.i(TAG,"ScrollStateChanged>>>state:"+state+"lastItem:" + lastItem);
   //显示50条ListItem，即0-49，由于onScrollStateChanged是在“拖动滑动”运行过之后才触发，所以用adapter.count<=41作条件
   if (adapter.count<=41) {
    adapter.count += 10;
    adapter.notifyDataSetChanged();
   }

  }
}
  /**
   * 要用用于生成显示数据
   * @author huangbq
   *
   */
class listViewAdapter extends BaseAdapter {
  int count = 10;
  public int getCount() {
   Log.i(TAG, "getCount>>>count:" + count);
   return count;
  }
  public Object getItem(int pos) {
   Log.i(TAG, "getItem>>>pos:" + pos);
   return pos;
  }
  public long getItemId(int pos) {
   Log.i(TAG, "getItemId>>>ItemId:" + pos);
   return pos;
  }
  public View getView(int pos, View v, ViewGroup p) {
   Log.i(TAG, "getView>>>pos:" + pos);
   TextView view;
   if (v==null) {
    view = new TextView(MainActivity.this);
   }
   else {
    view=(TextView)v;
   }
   view.setText("ListItem " + pos);
   view.setTextSize(20f);
   view.setGravity(Gravity.CENTER);
   view.setHeight(60);
   return view;
  }
}
}

demon下载:http://www.eoeandroid.com/forum.php?mod=viewthread&tid=52761

方案四:

这里仅仅给出关键代码，数据库和adapter自己去写吧，实现了listview的上下缓存。数据是从数据库得到的
public class HomeActivity extends Activity {
        /** Called when the activity is first created. */

        TextView mTextView;

        ListView mListView;
        MusicListViewAdapter mMusicListViewAdapter;
        boolean isLoadingMusicData = false;

        // 当前能够显示的LinkedList数据集合
        LinkedList<Music> nowMusicList;

        // 每次查询多少条数据
        int pageSize = 15;
        // 一共多少页数据
        long pageCount;
        // 记录查询结果总数
        long resultTotCount;

        // 顶端缓存数据为第几页
        int topCachePageNumber;
        // 底端缓存数据为第几页
        int bottomCachePageNumber;

        // 顶端缓存未插入LinkedList数据--OnScrollListener事件改变
        LinkedList<Music> cacheTopList;
        // 底端缓存未插入LinkedList数据--OnScrollListener事件改变
        LinkedList<Music> cacheBottomList;

        // 是否可显示到全部数据顶端
        boolean isViewAllDataTop;
        // 是否可显示到全部数据底端
        boolean isViewAllDataBottom;

        // 是否已经缓存到全部数据顶端
        boolean isCacheAllDataTop;
        // 是否已经缓存到全部数据底端
        boolean isCacheAllDataBottom;

        // 能够显示的顶端ItemView相应数据库查询结果第几条
        int topViewListToDbPosition;
        // 能够显示的底端ItemView相应数据库查询结果第几条
        int bottomViewListToDbPosition;
        // 能够显示的顶端ItemView相应数据库查询结果页数
        int topViewListToPagePosition;
        // 能够显示的底端ItemView相应数据库查询结果页数
        int bottomViewListToPagePosition;

        // 顶端剩余未显示的ItemView--OnScrollListener事件改变
        int topNoShowItemViewCount;
        // 底端剩余未显示的ItemView--OnScrollListener事件改变
        int bottomNoShowItemViewCount;

        // 当前显示的最顶端--OnScrollListener事件改变
        int topItemViewPosition;
        // 当前显示的最底端--OnScrollListener事件改变
        int bottomItemViewPosition;

        // 重要！推断向上滚动还是向下滚动 --滚动前显示的最顶端--OnScrollListener事件改变
        int oldTopItemViewPosition = -1;
        // 重要！推断向上滚动还是向下滚动 --滚动前显示的最底端--OnScrollListener事件改变
        int oldBottomItemViewPosition = -1;
        // 记录是滚动方向--OnScrollListener事件改变--事实上不须要在这里定义
        int isUpScroll = 0;

        // 是否须要添加顶端缓存数据--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needCacheTopList;
        // 是否须要添加底端缓存数据--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needCacheBottomList;
        // 是否须要删除顶端缓存数据--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needDelCacheTopList;
        // 是否须要删除底端缓存数据--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needDelCacheBottomList;

        // 是否应该追加顶端ItemView--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needAddTopItemView;
        // 是否应该追加底端ItemView--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needAddBottomItemView;
        // 是否应该追加顶端ItemView--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needDelTopItemView;
        // 是否应该追加底端ItemView--OnScrollListener事件改变--事实上不须要在这里定义
        boolean needDelBottomItemView;

        // 是否正在更新
        boolean isUping = true;

        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);

                // 获得符合查询条件记录的总数ResultSet totality
                resultTotCount = MusicAppliction.mListViewUtil.getAllMusicCount();
                // 依据每页大小计算分页数量
                pageCount = resultTotCount / pageSize + 1;

                // 连续取最初2页数据并给nowMusicList赋值，用于初始化显示
                nowMusicList = MusicAppliction.mListViewUtil.getMusicListLimit(0,
                                pageSize * 2 - 1);
                Log.i("getMusicListLimit", "size:" + nowMusicList.size());

                // 设置当前能够显示ItemView相应数据库查询结果

                // 能够显示的顶端ItemView相应数据库查询结果第几条
                topViewListToDbPosition = 0;
                // 能够显示的底端ItemView相应数据库查询结果第几条
                if (pageCount > 2) {
                        bottomViewListToDbPosition = pageSize * 2 - 1;
                } else {
                        bottomViewListToDbPosition = nowMusicList.size() - 1;
                }

                // 是否可显示到全部数据顶端
                isViewAllDataTop = true;
                // 是否可显示到全部数据底端
                if (pageCount <= 2) {
                        isViewAllDataBottom = true;
                } else {
                        isViewAllDataBottom = false;
                }

                // 能够显示的顶端ItemView相应数据库查询结果页数
                topViewListToPagePosition = 1;
                // 能够显示的底端ItemView相应数据库查询结果页数
                if (pageCount >= 2) {
                        bottomViewListToPagePosition = 2;
                } else if (pageCount == 1) {
                        bottomViewListToPagePosition = 1;
                }

                // 是否已经缓存到全部数据顶端
                isCacheAllDataTop = true;
                // 是否已经缓存到全部数据底端
                if (pageCount > 2) {
                        isCacheAllDataBottom = false;
                } else {
                        isCacheAllDataBottom = true;
                }

                // 顶端缓存数据为第几页
                topCachePageNumber = -1;
                // 底端缓存数据为第几页
                bottomCachePageNumber = -1;

                // 顶端的缓存数据
                cacheTopList = null;
                // 底端的缓存数据
                cacheBottomList = null;

                // 找到显示音乐的ListView
                mListView = (ListView) findViewById(R.id.MusicListView);
                // 创建Adapter给ListView显示
                mMusicListViewAdapter = new MusicListViewAdapter(this, nowMusicList);
                // 组合Adapter和ListView
                mListView.setAdapter(mMusicListViewAdapter);

                mListView.setOnScrollListener(mOnScrollListener);
                mListView.setFocusable(true);
                mListView.forceLayout();
                // 声明初始化isUping完成
                isUping = false;

        }

        public void initTestData() {

                // 建立初始化数据库和建立相关的表
                // InitDataBaseTable继承自线程
                // 初始化后调用须要运行start()方法
                InitDataBaseTable mInitDataBaseTable = new InitDataBaseTable(this);

                // 运行一个线程，用来在后台初始化数据库和表
                mInitDataBaseTable.start();

        }

        OnScrollListener mOnScrollListener = new OnScrollListener() {

                @Override
                public void onScrollStateChanged(AbsListView view, int scrollState) {

                }

                @Override
                public void onScroll(AbsListView view, int firstVisibleItem,
                                int visibleItemCount, int totalItemCount) {

                        if (isUping) {
                                return;
                        }

                        // 假设能够显示全部数据页则退出
                        if (topViewListToPagePosition == 1
                                        && pageCount == bottomViewListToPagePosition
                                        && firstVisibleItem == 0) {
                                return;
                        }

                        // ------计算并赋值
                        // 顶端剩余未显示的ItemView--OnScrollListener事件改变
                        topNoShowItemViewCount = firstVisibleItem;
                        // 底端剩余未显示的ItemView--OnScrollListener事件改变
                        bottomNoShowItemViewCount = totalItemCount - firstVisibleItem
                                        - visibleItemCount;
                        // 当前显示的最顶端--OnScrollListener事件改变
                        topItemViewPosition = firstVisibleItem;
                        // 当前显示的最底端--OnScrollListener事件改变
                        bottomItemViewPosition = visibleItemCount + firstVisibleItem;

                        //剔除ListView刷新后的Item混乱
                        if (oldTopItemViewPosition + pageSize == topItemViewPosition) {

                                Log.i("testa", "oldTopItemViewPosition+pageSize");
                                oldTopItemViewPosition = topItemViewPosition;
                                // isUpScroll = 0;
                                return;
                        }
                        
                        //剔除ListView刷新后的Item混乱
                        if (oldTopItemViewPosition == topItemViewPosition + pageSize) {
                                Log.i("testa", "topItemViewPosition+pageSize");
                                oldTopItemViewPosition = topItemViewPosition;
                                // isUpScroll = 0;
                                return;
                        }

                        //声明正在更新
                        isUping = true;

                        // ------推断是否须要添加或删除顶端缓存Cache数据
                        // 推断是滚动方向是否向下
                        if (oldTopItemViewPosition < topItemViewPosition
                                        || (oldTopItemViewPosition - pageSize == topItemViewPosition)) {
                                // 推断是否须要删除顶端多余ItemView
                                // 同一时候更新顶端List缓存
                                // 同一时候更新各种位置标志
                                //Log.i("inUpBottom", "bottomCachePageNumber:"+bottomCachePageNumber);

                                //推断是否为初始化的向下滚动
                                if (bottomCachePageNumber == -1) {
                                        // 推断是否有底端数据能够载入
                                        if (pageCount > 2) {
                                                bottomCachePageNumber = 1;
                                                cacheBottomList = MusicAppliction.mListViewUtil
                                                                .getMusicListLimit(++bottomCachePageNumber
                                                                                * pageSize, (bottomCachePageNumber + 1)
                                                                                * pageSize - 1);
                                        }
                                        // 将底端cache的数据追增加nowMusicList
                                        nowMusicList.addAll(cacheBottomList);
                                } else if (bottomNoShowItemViewCount < pageSize
                                                ) {
                                        //不是初始化的向下滚动则进行略微复杂一点的计算
                                        
                                        //推断是否为向上滚动后的向下滚动，防止中间丢失1页
                                        if(isUpScroll == 1){
                                                --bottomCachePageNumber;
                                        }
                                        isUpScroll = 2;

                                        //缓存一个底部页
                                        cacheBottomList = MusicAppliction.mListViewUtil
                                                        .getMusicListLimit(++bottomCachePageNumber
                                                                        * pageSize, (bottomCachePageNumber + 1)
                                                                        * pageSize - 1);
                                        
                                        //将底部页追加到列表
                                        nowMusicList.addAll(cacheBottomList);
                                        
                                        //推断是否须要删除顶部页
                                        if (topNoShowItemViewCount > pageSize) {
                                                for (int i = 0; i < pageSize; i++) {
                                                        nowMusicList.removeFirst();
                                                }
                                                //更新顶部下次须要加载时的起始页
                                                ++topCachePageNumber;
                                                Log.i("topCachePageNumber", "++topCachePageNumber");
                                        }
                                }

                        } else if (oldTopItemViewPosition > topItemViewPosition
                                        || (oldTopItemViewPosition == topItemViewPosition
                                                        - pageSize)) {

                                // 推断是否须要删除底端多余ItemView
                                // 同一时候更新底端List缓存
                                // 同一时候更新各种位置标志

//                                Log.i("inUpTop", "topCachePageNumber:" + topCachePageNumber);
                                
                                //推断是否顶部数据须要追加
                                if (topNoShowItemViewCount < pageSize) {
                                        Log.i("inUpTop", "应该追加顶部");
                                        if (topCachePageNumber >= 1) {
                                                
                                                //防止向上滚动丢失一页
                                                if(isUpScroll == 2){
                                                        ++topCachePageNumber;
                                                }
                                                //标示如今是向上滚动
                                                isUpScroll = 1;
                                                
                                                //取得须要追加的顶部数据
                                                cacheTopList = MusicAppliction.mListViewUtil
                                                                .getMusicListLimit(--topCachePageNumber
                                                                                * pageSize, (topCachePageNumber + 1)
                                                                                * pageSize - 1);

                                                //倒序增加东部数据
                                                for (int i = cacheTopList.size(); i > 0; i--) {
                                                        nowMusicList.add(0, cacheTopList.get(i - 1));
                                                }
                                        }


                                }

                                //更新底部数据
                                if (bottomNoShowItemViewCount > pageSize*2) {
                                        //删除多余的底部数据
                                        for (int i = 0; i < pageSize; i++) {
                                                nowMusicList.removeLast();
                                        }
                                        
                                        //标示如今是向上滚动
                                        isUpScroll = 1;
                                        
                                        //改动下次追加底部数据的起始页
                                        
                                        //当底部缓存页面小于2的时候将不再降低
                                        if(bottomCachePageNumber>2){
                                                --bottomCachePageNumber;
                                        }
                                        
                                        Log.i("MybottomCachePageNumber", "bottomCachePageNumber:"+bottomCachePageNumber);

                                }

                        }

//                        Log.i("OnScrollListener", "--oldTopItemViewPosition:"
//                                        + oldTopItemViewPosition + "--topItemViewPosition："
//                                        + topItemViewPosition);
                        oldTopItemViewPosition = topItemViewPosition;
                        mMusicListViewAdapter.notifyDataSetChanged();
                        isUping = false;

                }
        };
        
}

方案五:

　ListView是Android中最为经常使用的列表类型控件，ListView中的选择项目中样式非常多有的是纯文字的、有的还能够带有图片。它的继承关系例如以下：
　　java.lang.Object
　　android.view.View
　　android.view.ViewGroup
　　android.widget.AdapterView<T extends android.widget.Adapter>
　　android.widget.AbsListView
　　android.widget.ListView
　　android.widget.ListView继承了android.view.ViewGroup。
　　首先看一个纯文本的ListView样例，案例执行后会出现一个城市列表如图6-8所看到的，选择某个城市，弹出一个Toast，关于Toast的概念和使用会在下一节中介绍。
　　程序代码请參考代码
　   chapter6_3/src/com/work/ListView_1_Activity.java
　　public class ListView_1_Activity extends Activity {
　　private ListView listview；
　　@Override
　　public void onCreate（Bundle savedInstanceState） {
　　super.onCreate（savedInstanceState）；
　　setContentView（R.layout.listview_activity）；
　　listview = （ListView）findViewById（R.id.ListView01）；
　　ArrayAdapter<String> adapter = new ArrayAdapter<String>（this，
　　android.R.layout.simple_list_item_1， mStrings）；
　　listview.setAdapter（adapter）；
　　listview.setOnItemClickListener（new AdapterView.OnItemClickListener（） {
　　@Override
　　public void onItemClick（AdapterView<？> parent， View v， int pos，
　　long id） {
　　Toast.makeText（ListView_1_Activity.this， mStrings[pos]，
　　Toast.LENGTH_SHORT）.show（）；
　　}
　　}）；
　　}
　　private String[] mStrings = {
　　"北京市"， "天津市"， "上海"， "重庆"， "乌鲁木齐"， …}；
　　}
　　对 于ArrayAdapter应该已经非常熟悉了，当中的android.R.layout.simple_list_item_1是使用系统的布局样式。 Android系统本身提供了非常多的这种布局文件，可是有的适合于ListView控件，有的适合于Spinner控件，有的适合于它的列表控件，这是 使用时须要注意的。
　　在这样的方式下，须要在布局文件listview_activity。xml中加入ListView控件：
　　<ListView android：id="@+id/ListView01" android：layout_width="wrap_content"
　　android：layout_height="wrap_content"></ListView>
　　由 于ListView在Android中是非经常常使用的列表类型控件，仅仅要是有多条信息须要显示的时候都能够考虑使用ListView展示出来，正是因为 ListView使用的普遍，所以Android又提供了一个列表类型的Activity——ListActivity，来简化ListView开发。
　　通过继承ListActivity类而实现一个简单的ListView功能，而不要直接使用ListView控件。相同上面案例假设使用ListActivity请參考代码清单:
　   chapter6_3/src/com/work/ListView_1.java
　　public class ListView_1 extends ListActivity {
　　/** Called when the activity is first created. */
　　@Override
　　public void onCreate（Bundle savedInstanceState） {
　　super.onCreate（savedInstanceState）；
　　setListAdapter（new ArrayAdapter<String>（this，
　　android.R.layout.simple_list_item_1， mStrings））；
　　getListView（）.setOnItemClickListener（new AdapterView.OnItemClickListener（） {
　　@Override
　　public void onItemClick（AdapterView<？> parent， View v， int pos，
　　long id） {
　　Toast.makeText（ListView_1.this， mStrings[pos]，
　　Toast.LENGTH_SHORT）.show（）；
　　}
　　}）；
　　}
　　private String[] mStrings = {
　　"北京市"， "天津市"， "上海"， "重庆"， "乌鲁木齐"， …}；
　　}
　　查 看代码不难发现这里没有使用布局文件，那就意味着不须要使用R文件来获得控件，所以在程序中使用了getListView（）方法来获得ListView 控件。处理ListView的项目点击事件有两种方法，一种是通过与ListView对象设置setOnItemClickListener方式实现，代 码例如以下：
　　getListView（）.setOnItemClickListener（new AdapterView.OnItemClickListener（） {
　　@Override
　　public void onItemClick（AdapterView<？> parent， View v， int pos，
　　long id） {
　　Toast.makeText（ListView_1.this， mStrings[pos]，
　　Toast.LENGTH_SHORT）.show（）；
　　}
　　}）；
　　第二种是覆盖ListActivity的onListItemClick（ListView l， View v， int position， long id）方法实现，代码例如以下所看到的。
　　@Override
　　protected void onListItemClick（ListView l， View v， int position， long id） {
　　Toast.makeText（ListView_1.this， mStrings[position]， Toast.LENGTH_SHORT）
　　。show（）；
　　}
　　再看一个自己定义Adapter的样例，这是一个带有图标的ListView，
　　自己定义adapter
　　相关程序代码请參考代码清单：
　　 chapter6_3/src/com/work/ListViewIcon_3.java
　　public class ListViewIcon_3 extends ListActivity {
　　@Override
　　public void onCreate（Bundle savedInstanceState） {
　　super.onCreate（savedInstanceState）；
　　setListAdapter（new EfficientAdapter（this））；
　　}
　　private static final String[] DATA = {
　　"北京市"， "天津市"， "上海"， "重庆"， "哈尔滨"，
　　"石家庄"， "秦皇岛"， "济南"， "青岛"， "南京"，
　　"三亚"， "昆明"， "成都"， "长沙"， "武汉"，
　　"九江"， "香港"， "澳门"，"兰州"，"张家口" }；
　　…
　　}
　　自己定义的Adapter是EfficientAdapter，EfficientAdapter的相关代码请參考代码清单：
　　chapter6_3/src/com/work/ListViewIcon_3.java
　　private static class EfficientAdapter extends BaseAdapter {
　　private LayoutInflater mInflater；
　　private Bitmap mIcon0；
　　private Bitmap mIcon1；
　　…  …
　　public EfficientAdapter（Context context） {
　　mInflater = LayoutInflater.from（context）；
　　mIcon0 = BitmapFactory.decodeResource（context.getResources（）， R.drawable.noicon）；
　　mIcon1 = BitmapFactory.decodeResource（context.getResources（）， R.drawable.beijing）；
　　…   …
　　}
　　public int getCount（） {
　　return DATA.length；
　　}
　　public Object getItem（int position） {
　　return DATA[position]；
　　}
　　public long getItemId（int position） {
　　return position；
　　}
　　public View getView（int position， View convertView， ViewGroup parent） {
　　ViewHolder holder；
　　if （convertView == null） {
　　convertView = mInflater。inflate（R.layout.main， null）；
　　holder = new ViewHolder（）；
　　holder.text = （TextView） convertView.findViewById（R.id.textview）；
　　holder.icon = （ImageView） convertView.findViewById（R.id.icon）；
　　convertView.setTag（holder）；
　　} else {
　　holder = （ViewHolder） convertView.getTag（）；
　　}
　　holder.text.setText（DATA[position]）；
　　switch（position）
　　{
　　case 0：
　　holder.icon.setImageBitmap（mIcon1）；
　　break；
　　case 1：
　　holder.icon.setImageBitmap（mIcon2）；
　　break；
　　…
　　default：
　　holder.icon.setImageBitmap（mIcon0）；
　　break；
　　}
　　return convertView；
　　}
　　static class ViewHolder {
　　TextView text；
　　ImageView icon；
　　}
　　}
　　编写自己定义Adapter能够继承BaseAdapter类，假设是数据库使用能够继承CursorAdapter。在本例中继承了BaseAdapter类，BaseAdapter是一个抽象类，必须在它的子类中实现以下的方法：
　　 int getCount（） 返回总数据源中总的记录数；
　　Object getItem（int position） 依据选择的项目的位置，获得选择的数据源中某个项目的数据；
　　 long getItemId（int position） 依据选择的项目的位置；
　　View getView（int position， View convertView， ViewGroup parent） 获得要展示的项目View对象。
　　这 里最为麻烦的方法就是getView（），getView（）方法是ListView的每一个列表项目绘制在屏幕上时被调用。该方法当中的一个參数是 convertView，在ListView第一次显示列表项目的时候，convertView是null值。当向上滑动屏幕时候，屏幕上面的列表项目退 出屏幕，屏幕以下原来不可见的列表项目会进入屏幕，这个时候的convertView不是null值，以下代码的处理对于提供ListView控件提高性 能是至关重要的。
　　if （convertView == null） {
　　convertView = mInflater.inflate（R.layout.main， null）；
　　holder = new ViewHolder（）；
　　holder.text = （TextView） convertView
　　.findViewById（R.id.textview）；
　　holder.icon = （ImageView） convertView.findViewById（R.id.icon）；
　　convertView.setTag（holder）；
　　} else {
　　holder = （ViewHolder） convertView.getTag（）；
　　}
　　仅仅 有在convertView为null时才去实例化控件，创建convertView对象、holder对象，当中convertView对象是通过 mInflater。inflate（R.layout.main， null）方法，从一个main.xml布局文件里载入并创建的。
　　而在convertView非null的时候不会实例化控件，否则每次都要实例化控件，当列表项目非常多时，用户重复滑动屏幕会有“卡”的感觉，不再流畅了。
　　ViewHolder 类是将每个项目中的控件封装起来的类，能够在convertView 为null时候创建ViewHolder类的实例holder，然后通过convertView.setTag（holder）；把它放到 convertView中，而在convertView非null时候，再通过convertView.getTag（）过的一个ViewHolder类 的实例，这样在翻屏的时候就不会重复创建ViewHolder实例对象了，就本例而言仅仅是创建了9个ViewHolder实例。

方案六:AsyncTask, json;

代码介绍：
　　初学android，写了个一小demo。功能非常easy，主要是用来学习，
　　知识要点：
　　1.android全局变量的使用（用来缓存爬取的数据）。
　　2.AsyncTask使用。
　　3.进度条载入数据
　　4.利用Jsoup爬取网页数据并解析

demon:http://www.eoeandroid.com/forum.php?mod=viewthread&tid=172517

方案七：下拉载入

http://www.eoeandroid.com/forum.php?mod=viewthread&tid=172777