Java 无休止的listview对每个元素收费

我知道有很多关于这个主题的文档，但是我对没完没了的ListView有一个问题。在用户滚动之前，每一行必须显示一个进度条，但它不会成功。当应用程序启动时，所有元素都会加载到ProgressBar中。这是所有的代码

public class MainActivity extends Activity implements EndlessListView.EndlessListener{

    EndlessListView lv;
    List<String> listOfElements;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        RelativeLayout layout = new RelativeLayout(this);

        lv = new EndlessListView(this);
        listOfElements = fillList();

        EndlessAdapter adp = new EndlessAdapter(this, listOfElements,-1); 

        lv.setLoadingView();
        lv.setAdapter(adp);
        lv.fillAdapter(listOfElements);
        lv.setListener(this);

        layout.addView(lv);


        setContentView(layout);
    }


    public List<String> fillList(){
        List<String> listOfElements = new ArrayList<String>();
        for (int i = 0; i < 200; i++) {
            listOfElements.add("Element "+i );
        }
        return listOfElements;
    }

}


public class EndlessListView extends ListView{

    Context context;
    private EndlessListener listener;
    private EndlessAdapter adapter;


    public EndlessListView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public EndlessListView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EndlessListView(Context context) {
        super(context);
    }

    public void setContext(Context context){
        this.context = context;
    }

    public void setLoadingView() {

        LinearLayout layout = new LinearLayout(super.getContext());

        //this.addView(layout);
    }


    public void setAdapter(EndlessAdapter adapter) {
        super.setAdapter(adapter);
        this.adapter = adapter;
    }


    public EndlessListener setListener() {
        return listener;
    }

    public void setListener(EndlessListener listener) {
        this.listener = listener;
    }

    public static interface EndlessListener {

    }

    public void fillAdapter(List<String> data){
        adapter.addAll(data);
        adapter.notifyDataSetChanged();
    }


}

公共类MainActivity扩展活动实现EndlessListView.EndlessListener{
无端滑动视图lv；
元素列表；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
RelativeLayout布局=新的RelativeLayout（此）；
lv=新的EndlessListView（本）；
listOfElements=fillList（）；
EndlessAdapter adp=新的EndlessAdapter（这是元素列表，-1）；
lv.setLoadingView（）；
低压设置适配器（adp）；
低压填充适配器（元件清单）；
lv.setListener（this）；
布局。添加视图（lv）；
setContentView（布局）；
}
公共列表fillList（）{
列表元素=新的ArrayList（）；
对于（int i=0；i<200；i++）{
元素列表。添加（“元素”+i）；
}
返回元素列表；
}
}
公共类EndlessListView扩展了ListView{
语境；
私密的听者；
专用EndlessAdapter适配器；
公共EndlessListView（上下文上下文、属性集属性、int-defStyle）{
超级（上下文、属性、定义样式）；
}
公共EndlessListView（上下文、属性集属性）{
超级（上下文，attrs）；
}
公共EndlessListView（上下文）{
超级（上下文）；
}
公共void setContext（上下文）{
this.context=上下文；
}
public void setLoadingView（）{
LinearLayout布局=新的LinearLayout（super.getContext（））；
//此.addView（布局）；
}
公共void setAdapter（EndlessAdapter适配器）{
super.setAdapter（适配器）；
this.adapter=适配器；
}
public EndlessListener setListener（）{
返回侦听器；
}
公共void setListener（EndlessListener侦听器）{
this.listener=listener；
}
公共静态接口EndlessListener{
}
公共无效填充适配器（列表数据）{
adapter.addAll（数据）；
adapter.notifyDataSetChanged（）；
}
}

这是关键代码：

    public class EndlessAdapter extends ArrayAdapter<String> {

    private List<String> itemList;
    private Context ctx;
    private int layoutId;

    public EndlessAdapter(Context ctx, List<String> itemList, int layoutId) {
        super(ctx, layoutId, itemList);
        this.itemList = itemList;
        this.ctx = ctx;
    }

    @Override
    public int getCount() {
        return itemList.size();
    }

    @Override
    public String getItem(int position) {
        return itemList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return itemList.get(position).hashCode();
    }


    @Override
    public View getView(int position, View convertView, ViewGroup parent) {

        TextView tv = new TextView(ctx);
        ProgressBar pg = new ProgressBar(ctx);

        if (convertView == null) {
            tv = new TextView(ctx);
            pg = new ProgressBar(ctx);
            convertView = pg;


        } else {
            pg = (ProgressBar) convertView;
        }
        //tv.setText(itemList.get(position));
        FakeImageLoader fake = new FakeImageLoader(tv, pg, position);
        fake.execute();
        System.out.println("Me estoy pintando y soy el elemento "
                + itemList.get(position));

        return convertView;
    }





    private class FakeImageLoader extends AsyncTask<String, Void, TextView> {

        private TextView tv;
        private ProgressBar pg;
        private int position;

        public FakeImageLoader(TextView tv,
                ProgressBar pg, int position) {
            this.tv = tv;
            this.pg = pg;
            this.position = position;
        }

        protected void onPreExecute() {


        }

        protected TextView doInBackground(String... params) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return createItem(position);
        }

        protected void onPostExecute(TextView text) {
            tv = text;
            addNewData(tv, pg,position);
        }

        public TextView createItem(int position) {
            TextView text = new TextView(ctx);
            text.setText(itemList.get(position));
            System.out.println(itemList.get(position));
            text.setTextSize(20);
            return text;
        }

    }

    public void addNewData(TextView text, ProgressBar pg, int position) {

        System.out.println("Entra");
        pg.setVisibility(View.INVISIBLE);
        text.setText(itemList.get(position));

    }

}

公共类EndlessAdapter扩展了ArrayAdapter{
私人清单项目清单；
私有上下文ctx；
私人内部布局；
公共EndlessAdapter（上下文ctx、列表项列表、int-layoutId）{
超级（ctx、布局ID、项目列表）；
this.itemList=itemList；
this.ctx=ctx；
}
@凌驾
public int getCount（）{
返回itemList.size（）；
}
@凌驾
公共字符串getItem（int位置）{
返回itemList.get（位置）；
}
@凌驾
公共长getItemId（int位置）{
返回itemList.get（position.hashCode（）；
}
@凌驾
公共视图getView（int位置、视图转换视图、视图组父视图）{
TextView tv=新的TextView（ctx）；
ProgressBar pg=新的ProgressBar（ctx）；
if（convertView==null）{
电视=新文本视图（ctx）；
pg=新进度条（ctx）；
convertView=pg；
}否则{
pg=（进度条）转换视图；
}
//tv.setText（itemList.get（position））；
FakeImageLoader fake=新的FakeImageLoader（电视、pg、位置）；
fake.execute（）；
System.out.println（“Me estoy pintando y soy el elemento”
+itemList.get（position））；
返回视图；
}
私有类FakeImageLoader扩展异步任务{
私家图文电视；
私人ProgressBar pg；
私人职位；
公共FakeImageLoader（文本视图电视，
进度条pg，int位置）{
this.tv=tv；
this.pg=pg；
这个位置=位置；
}
受保护的void onPreExecute（）{
}
受保护的TextView doInBackground（字符串…参数）{
试一试{
睡眠（1000）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
返回项目（位置）；
}
受保护的void onPostExecute（文本视图文本）{
电视=文本；
添加新数据（电视、pg、位置）；
}
公共文本视图createItem（int位置）{
TextView text=新的TextView（ctx）；
setText（itemList.get（position））；
System.out.println（itemList.get（position））；
text.setTextSize（20）；
返回文本；
}
}
public void addNewData（文本视图文本、进度条pg、int位置）{
系统输出打印项次（“Entra”）；
pg.setVisibility（视图不可见）；
setText（itemList.get（position））；
}
}

---

注意。

您没有在关键代码中正确实现视图持有者模式意味着getViewEndlessAdapter adp=new EndlessAdapter（这是元素列表，-1）；为什么要使用-1作为布局？