Android 从ccustom gridview获取精确视图

我注意到，对GridView使用ArrayAdapter并循环使用视图，我多次调用getView方法并创建了许多视图

正如您在下面的代码中看到的，我需要一个特定元素的ArrayList。但是，由于android回收了它的视图，我在arrayList中得到的元素可能太多了。我怎样才能做到只在ArrayList中输入元素的确切数量（如果我有4个视图，我只需要4个元素）

谢谢

代码：GridViewAdapter类

public class GridViewAdapter extends ArrayAdapter<String>  {

    private LayoutInflater inflater = null;
    private final String TAG = "GridViewAdapter";
    public Context mContext; 
    public int layoutResourceId;
    private ArrayList<String> mFilePathList = new ArrayList<String>();
    private ArrayList<ImageView> mFeatureImageCollection = new ArrayList<ImageView>();
    private ArrayList<ToggleButton> mFeatureImageButtonCollection = new ArrayList<ToggleButton>();

    public GridViewAdapter(Context context, int resource) {
        super(context, resource);
        this.mContext = context;
    }

    public GridViewAdapter(Context context, int attrs, int defStyle) {
        super(context, attrs, defStyle);

    }

    public void add(String path) {
        mFilePathList.add(path);
    }


    @Override
    public void notifyDataSetChanged() {
        // TODO Auto-generated method stub
        super.notifyDataSetChanged();
    }

    @Override
    public void remove(String object) {
        // TODO Auto-generated method stub
        super.remove(object);
    }

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

    @Override
    public String getItem(int position) {
        // TODO Auto-generated method stub
        Log.w(TAG, "im in getItem");
        return mFilePathList.get(position);
    }

    @Override
    public long getItemId(int position) {
        // TODO Auto-generated method stub
        Log.i(TAG, "getItemId");
        return position;
    }


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

        GridImageView view;
        if (convertView == null) {

            inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            view = (GridImageView) inflater.inflate(R.layout.grid_elements, null);

            view.setTag(position);
            Log.i(TAG, "VIEW TAG: "+ view.getTag());
            mFeatureImageCollection.add(view.mFeaturedImage);
            mFeatureImageButtonCollection.add(view.mFeaturedImageButton);

        } else {

            view = (GridImageView) convertView;
        }

        view.showItems(mFilePathList, position, this, mFeatureImageCollection, mFeatureImageButtonCollection);

        return view;
    }
}

公共类GridViewAdapter扩展了ArrayAdapter{
专用充气机=空；
私有最终字符串标记=“GridViewAdapter”；
公共语境；
公共内部布局资源；
私有ArrayList mFilePathList=新ArrayList（）；
私有ArrayList mFeatureImageCollection=新建ArrayList（）；
私有ArrayList MFeatureMageButtonCollection=新ArrayList（）；
公共GridViewAdapter（上下文，int资源）{
超级（上下文、资源）；
this.mContext=上下文；
}
公共GridViewAdapter（上下文上下文、int attrs、int defStyle）{
超级（上下文、属性、定义样式）；
}
公共void添加（字符串路径）{
添加（路径）；
}
@凌驾
public void notifyDataSetChanged（）{
//TODO自动生成的方法存根
super.notifyDataSetChanged（）；
}
@凌驾
公共无效删除（字符串对象）{
//TODO自动生成的方法存根
超级。移除（对象）；
}
@凌驾
public int getCount（）{
返回mFilePathList.size（）；
}
@凌驾
公共字符串getItem（int位置）{
//TODO自动生成的方法存根
Log.w（标记“im in getItem”）；
返回mFilePathList.get（位置）；
}
@凌驾
公共长getItemId（int位置）{
//TODO自动生成的方法存根
Log.i（标记“getItemId”）；
返回位置；
}
@凌驾
公共视图getView（最终整数位置、视图转换视图、视图组父视图）{
GridImageView视图；
if（convertView==null）{
充气器=（LayoutInflater）mContext.getSystemService（Context.LAYOUT\u充气器\u SERVICE）；
视图=（GridImageView）充气器。充气（R.layout.grid_元素，null）；
视图.设置标签（位置）；
Log.i（标记，“视图标记：+VIEW.getTag（））；
添加（view.mFeaturedImage）；
mFeatureImageButtonCollection.add（view.mFeaturedImageButton）；
}否则{
视图=（GridImageView）convertView；
}
view.showItems（mFilePathList、position、this、mFeatureImageCollection、mFeatureImageButtonCollection）；
返回视图；
}
}

代码：GridViewImage

public class GridImageView  extends RelativeLayout {

    private final String TAG = "GridImageView";
    private boolean mFeaturedImageSet;
    public ImageView mAddedPhotoButton;
    public ImageView mFeaturedImage;
    public ImageView mDeleteImageButton;
    public ToggleButton mFeaturedImageButton;
    public Button btnAddPhoto;
    private boolean featureImageIsChecked = false;
    private static ArrayList<String> mFilePathList;
    private Iterator<ToggleButton> itr1;
    private Iterator<ImageView> itr2;

    public GridImageView(Context context, AttributeSet attrs) {
        super(context, attrs);      
        mFeaturedImageSet = false;
    }


    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();        
        btnAddPhoto = (Button) findViewById(R.id.btnAddPhoto);
        mAddedPhotoButton = (ImageView) findViewById(R.id.ivAddedPhoto);
        mDeleteImageButton = (ImageView) findViewById(R.id.ivDeleteImageButton);
        mFeaturedImage = (ImageView) findViewById(R.id.ivFeaturedImage);        
        mFeaturedImageButton = (ToggleButton) findViewById(R.id.ivFirstPhoto);
        mFeaturedImage.setVisibility(View.INVISIBLE);       
    }

    public void showItems(final ArrayList<String> mFilePathList, final int position, 
            final GridViewAdapter myAdapter, final ArrayList<ImageView> mFeatureImageCollection, 
            final ArrayList<ToggleButton> mFeatureImageButtonCollection) {

        this.mFilePathList = mFilePathList;

        Bitmap bm = decodeSampledBitmapFromUri(mFilePathList.get(position), 95, 95);
        mAddedPhotoButton.setImageBitmap(bm);
                //invoked to delete a view/element
        mDeleteImageButton.setVisibility(View.VISIBLE);
        mDeleteImageButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                File file= new File(mFilePathList.get(position));
                if(file.exists()) {
                     file.delete();
                }
                myAdapter.remove(mFilePathList.get(position));
                mFilePathList.remove(position);
                //VendiFragment.mFilePaths.remove(position);

                myAdapter.notifyDataSetChanged();
            }
        });


        Log.i(TAG, "Position = " + Integer.toString(position));

        Log.i(TAG, "Feature Image Value = " + Boolean.toString(mFeaturedImageSet));
        if (!mFeaturedImageSet && position == 0){
            mFeaturedImage.setVisibility(View.VISIBLE);
            mFeaturedImageButton.setBackgroundResource(R.drawable.first_photo_on);
            mFeaturedImageSet = true;
        }

        //when selected it enables or disables the Feature Image from the view element
        mFeaturedImageButton.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                Log.i(TAG, "mFeatureImageCollection.sixe(): " + mFeatureImageCollection.size());
                Log.i(TAG, "resetting al feature images to invisible");
//sets all the featuredImage view to invisible!
                //sets all the featuredImageButtons to unChecked!
                for (int i = 0; i < mFeatureImageCollection.size(); i++){
                    ImageView mFeatureImageTemp = mFeatureImageCollection.get(i);
                    Log.i(TAG, "rendi tutti invisibile");
                    mFeatureImageTemp.setVisibility(View.INVISIBLE);                    

                    ToggleButton mFeatureImageButtonTemp = mFeatureImageButtonCollection.get(i);
                    mFeatureImageButtonTemp.setChecked(false);

                    mFeatureImageButtonTemp.setBackgroundResource(R.drawable.first_photo_off);
                }

                //mFeaturedImage.setVisibility(View.VISIBLE);

                Log.e(TAG, mFilePathList.get(position).toString());
                Log.e(TAG, Boolean.toString(isChecked));
                //if check make visible and viceversa
                if (isChecked) {
                    Log.e(TAG, "rendi visibile");
                    buttonView.setBackgroundResource(R.drawable.first_photo_on);
                    buttonView.setChecked(true);
                    mFeaturedImage.setVisibility(View.VISIBLE);
                    mFeaturedImageSet = true;
                } else {
                    Log.e(TAG, "rendi invisibile");
                    buttonView.setChecked(false);
                    buttonView.setBackgroundResource(R.drawable.first_photo_off);
                    mFeaturedImage.setVisibility(View.INVISIBLE);
                    mFeaturedImageSet = false;
                }

                setFilePathListSequence(mFilePathList, buttonView, position);

            }
        });
    }



    public static ArrayList<String> getFilePathList(){
        return mFilePathList;
    }

    public void setFilePathListSequence(ArrayList<String> list, View v, int i){
        if (v.getVisibility() == View.VISIBLE) {
            String temp = list.get(i);
            list.remove(i);
            list.add(0, temp);
        }


        //serve per verificare la corretteza della modifica alla lista dei file path
        for (int j = 0; j < list.size(); j++){
            Log.e(TAG, "list item: " + j + " "+ list.get(j).toString());
        }

    }

    public Bitmap decodeSampledBitmapFromUri(String path, int reqWidth, int reqHeight) {

        Bitmap bm = null;
        // First decode with inJustDecodeBounds=true to check dimensions
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);

        // Calculate inSampleSize
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;
        bm = BitmapFactory.decodeFile(path, options);

        return bm;
    }

    public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {

        // Raw height and width of image
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            if (width > height) {
                inSampleSize = Math.round((float) height / (float) reqHeight);
            } else {
                inSampleSize = Math.round((float) width / (float) reqWidth);
            }
        }
        return inSampleSize;
    }
}

公共类GridImageView扩展了RelativeLayout{
私有最终字符串标记=“GridImageView”；
私有布尔mFeaturedImageSet；
公共图像查看按钮；
公共图像视图mFeaturedImage；
公共图像查看mDeleteImageButton；
公共切换按钮mFeaturedImageButton；
公共按钮btnAddPhoto；
私有布尔特征ImageIsChecked=false；
私有静态ArrayList mFilePathList；
专用迭代器itr1；
专用迭代器itr2；
公共GridImageView（上下文、属性集属性）{
超级（上下文，attrs）；
mFeaturedImageSet=false；
}
@凌驾
充气时受保护的空隙（）{
超级充气（）；
btnAddPhoto=（按钮）findViewById（R.id.btnAddPhoto）；
mAddedPhotoButton=（ImageView）findViewById（R.id.ivAddedPhoto）；
mDeleteImageButton=（ImageView）findViewById（R.id.ivDeleteImageButton）；
mFeaturedImage=（ImageView）findViewById（R.id.ivFeaturedImage）；
mFeaturedImageButton=（ToggleButton）findViewById（R.id.ivFirstPhoto）；
mFeaturedImage.setVisibility（视图不可见）；
}
公共无效显示项（最终ArrayList mFilePathList、最终整型位置、，
最终GridViewAdapter myAdapter，最终ArrayList mFeatureImageCollection，
最终阵列列表MFeatureMageButtonCollection）{
this.mFilePathList=mFilePathList；
位图bm=decodeSampledBitmapFromUri（mFilePathList.get（position），95,95）；
mAddedPhotoButton.setImageBitmap（bm）；
//调用以删除视图/元素
mDeleteImageButton.setVisibility（View.VISIBLE）；
mDeleteImageButton.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
File File=新文件（mFilePathList.get（position））；
if（file.exists（））{
delete（）；
}
myAdapter.remove（mFilePathList.get（position））；
mFilePathList.remove（位置）；
//VendifFragment.mFilePath.remove（位置）；
myAdapter.notifyDataSetChanged（）；
}
});
Log.i（标记，“Position=“+Integer.toString（Position））；
Log.i（标记，“Feature Image Value=“+Boolean.toString（mFeaturedImageSet））；
如果（！mFeaturedImageSet&&position==0）{
mFeaturedImage.setVisibility（View.VISIBLE）；
mFeaturedImageButton.setBackgroundResource（R.drawable.first\u photo\u on）；
mFeaturedImageSet=true；
}
//选中此选项后，将启用或禁用视图元素中的要素图像
mFeaturedImageButton.setOnCheckedChangeListener（新的CompoundButton.OnCheckedChangeListener（）{
检查更改后的公共无效（复合按钮视图，布尔值已检查）{
Log.i（标记“mFeatureImageCollection.sixe（）：”+mFeatureImageCollection.size（））；
Log.i（标签，“将所有特征图像重置为不可见”）；
//将所有FeatureDiImage视图设置为不可见！
//将所有featuredImageButtons设置为未选中！