Java 时间到期时从Recyclerview中删除项目

我需要删除一个项目时，时间到期，部分我得到了通过引用这个输出

滚动列表后，一些过期项目不会被删除，时间也不会更新

package com.techno.deliveryboy.Adapter;

import android.os.Handler;
import android.support.v4.app.FragmentActivity;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import com.techno.deliveryboy.Pojos.DummyTimer;
import com.techno.deliveryboy.R;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

/**
 * Created by developer on 23/7/16.
 */
public class Incoiming_orders_Adapter extends RecyclerView.Adapter<RecyclerView.ViewHolder>  {

    private LayoutInflater lf;
    Boolean onBind = true;
    private List<MyViewHolder> lstHolders;
    ArrayList<Integer> unbindvalues=new ArrayList<>();
    private Handler mHandler = new Handler();
    List<DummyTimer> lstProducts=new ArrayList<>();
    private Runnable updateRemainingTimeRunnable = new Runnable() {
        @Override
        public void run() {
            synchronized (lstHolders) {
                long currentTime = System.currentTimeMillis();

                for (MyViewHolder holder : lstHolders) {

                    holder.updateTimeRemaining(currentTime);


                }


            }
        }
    };

    public Incoiming_orders_Adapter(FragmentActivity activity, List<DummyTimer> lstProduct) {

        lstHolders = new ArrayList<>();
        lstProducts=lstProduct;

        startUpdateTimer();
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext())
                .inflate(R.layout.incoming_orders_item, parent, false);
        return new MyViewHolder(itemView);
    }

    private void startUpdateTimer() {
        Timer tmr = new Timer();
        tmr.schedule(new TimerTask() {
            @Override
            public void run() {
                mHandler.post(updateRemainingTimeRunnable);

            }
        }, 1000, 1000);
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
      if(holder instanceof MyViewHolder){
          onBind=true;
          MyViewHolder holder1= (MyViewHolder) holder;
          synchronized (lstHolders) {
              lstHolders.add(holder1);

           }
          holder1.setData(lstProducts.get(position),position);
          onBind=false;

      }
    }

    @Override
    public int getItemCount() {
        return lstProducts.size();
    }
    public void removeAt(int position) {

       /* for (Iterator<MyViewHolder> iterator = lstHolders.iterator(); iterator.hasNext();) {

           iterator.remove();
        }*/


        if(!onBind) {
            if(unbindvalues!=null&&unbindvalues.size()!=0&&position>=0){
                for (Integer i:unbindvalues) {
                    lstProducts.remove(position);
                    notifyItemRemoved(position);
                }
                unbindvalues.clear();

            }else {
                if(position>=0){
                    lstProducts.remove(position);
                    notifyItemRemoved(position);
                }

            }




            notifyDataSetChanged();
        }else {
            System.out.println("+Bind->true+");
            if(position>=0)
            unbindvalues.add(position);
        }
    }


    public class MyViewHolder extends RecyclerView.ViewHolder {
        public TextView title, tvTimeRemaining, genre;
        DummyTimer mProduct;
        public void setData(DummyTimer item, int position) {
            mProduct = item;
            title.setText(item.name);
            updateTimeRemaining(System.currentTimeMillis());
        }

        public MyViewHolder(View view) {
            super(view);
            title = (TextView) view.findViewById(R.id.Item_Totalvalue);
            tvTimeRemaining= (TextView) view.findViewById(R.id.Item_timeout);
        }

        public void updateTimeRemaining(long currentTime) {
            long timeDiff = mProduct.expirationTime - currentTime;
            if (timeDiff > 0) {
                int seconds = (int) (timeDiff / 1000) % 60;
                int minutes = (int) ((timeDiff / (1000 * 60)) % 60);
                int hours = (int) ((timeDiff / (1000 * 60 * 60)) % 24);
                tvTimeRemaining.setText(hours + " hrs " + minutes + " mins " + seconds + " sec");
            } else {
              // tvTimeRemaining.setText(String.valueOf(getAdapterPosition()));


                removeAt(getAdapterPosition());

            }
        }
    }

    @Override
    public long getItemId(int position) {
        return position;
    }
}

package com.techno.deliveryboy.Adapter；
导入android.os.Handler；
导入android.support.v4.app.FragmentActivity；
导入android.support.v7.widget.RecyclerView；
导入android.view.LayoutInflater；
导入android.view.view；
导入android.view.ViewGroup；
导入android.widget.TextView；
导入com.techno.deliveryboy.Pojos.DummyTimer；
导入com.techno.deliveryboy.R；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Timer；
导入java.util.TimerTask；
/**
*由开发商于2016年7月23日创建。
*/
公共类Incoiming\u orders\u适配器扩展了RecyclerView.Adapter{
私人停车场；
布尔onBind=true；
私人名单持有人；
ArrayList unbindvalues=新的ArrayList（）；
私有处理程序mHandler=新处理程序（）；
List lstProducts=new ArrayList（）；
private Runnable UpdateMainingTimeRunnable=new Runnable（）{
@凌驾
公开募捐{
已同步（LST）{
长currentTime=System.currentTimeMillis（）；
用于（MyViewHolder:LSTholder）{
holder.updateTimeRemaining（当前时间）；
}
}
}
};
公共输入\订单\适配器（碎片活动活动，列表产品）{
lstHolders=新的ArrayList（）；
lstProducts=lstProduct；
startUpdateTimer（）；
}
@凌驾
public RecyclerView.ViewHolder onCreateViewHolder（视图组父级，int-viewType）{
View itemView=LayoutInflater.from（parent.getContext（））
.充气（R.layout.incoming_orders_item，parent，false）；
返回新的MyViewHolder（itemView）；
}
私有void startUpdateTimer（）{
定时器tmr=新定时器（）；
tmr.时间表（新时间任务（）{
@凌驾
公开募捐{
mHandler.post（updateMainingTimeRunnable）；
}
}, 1000, 1000);
}
@凌驾
BindViewHolder上的公共无效（RecyclerView.ViewHolder，int位置）{
if（MyViewHolder的持有者实例）{
onBind=true；
MyViewHolder持有者1=（MyViewHolder）持有者；
已同步（LST）{
新增（持有人1）；
}
holder1.setData（lstProducts.get（position），position）；
onBind=false；
}
}
@凌驾
public int getItemCount（）{
返回lstProducts.size（）；
}
公共无效删除（内部位置）{
/*for（迭代器迭代器=lstHolders.Iterator（）；迭代器.hasNext（）；）{
iterator.remove（）；
}*/
如果（！onBind）{
if（unbindvalues！=null&&unbindvalues.size（）！=0&&position>=0）{
对于（整数i：未绑定值）{
移除（位置）；
已移除（位置）的项目；
}
unbindvalues.clear（）；
}否则{
如果（位置>=0）{
移除（位置）；
已移除（位置）的项目；
}
}
notifyDataSetChanged（）；
}否则{
System.out.println（“+Bind->true+”；
如果（位置>=0）
取消绑定值。添加（位置）；
}
}
公共类MyViewHolder扩展了RecyclerView.ViewHolder{
公共文本视图标题，电视剩余时间，类型；
DummyTimer MPProduct；
公共void setData（DummyTimer项，int位置）{
MPProduct=项目；
title.setText（项目名称）；
UpdateTimerMaining（System.currentTimeMillis（））；
}
公共MyViewHolder（视图）{
超级（视图）；
title=（TextView）view.findViewById（R.id.Item_Totalvalue）；
TVTimeLeving=（TextView）view.findViewById（R.id.Item_timeout）；
}
public void updateTimeRemaining（长currentTime）{
long-timeDiff=MPProduct.expirationTime-currentTime；
如果（时间差>0）{
整数秒=（整数）（时间差/1000）%60；
int分钟=（int）（（timeDiff/（1000*60））%60）；
整小时=（整小时）（（时间差/（1000*60*60））%24）；
tvTimeLeving.setText（小时+小时+分钟+分钟+秒+秒）；
}否则{
//tvTimeRemaining.setText（String.valueOf（getAdapterPosition（））；
移除（getAdapterPosition（））；
}
}
}
@凌驾
公共长getItemId（int位置）{
返回位置；
}
}

---

请给出您的评论。

您想要的东西与“过滤”相似，不同之处在于您想要删除该项目。我建议为列表中的所有计时器设置一个观察者，每当您的计时器超过时间表时，您必须更新观察者，这将从您拥有的项目列表或阵列列表中删除它。通知您的数据集已发生更改，该更改将刷新您的RecyclerView。

您可以通过设置每秒触发

onTick（）

方法来实现这一点。在方法中检查是否有过期的对象？如果发现任何对象，请通过调用

notifyItemRemoved（）

将其删除

以下是回收器视图适配器的代码：

私有类RecycleServiceAdapter扩展了RecyclerView.Adapter{ 私有ArrayList mData

    public RecyclerViewAdapter(ArrayList<RowData> data) {
        mData = data;

        //find out the maximum time the timer
        long maxTime = System.currentTimeMillis();
        for (RowData item : mData) {
            maxTime = Math.max(maxTime, item.endTime);
        }

        //set the timer which will refresh the data every 1 second.
        new CountDownTimer(maxTime - System.currentTimeMillis(), 1000) {
            @Override
            public void onTick(long l) {
                for (int i = 0, dataLength = mData.size(); i < dataLength; i++) {
                    RowData item = mData.get(i);
                    item.timeRemaining -= 1000;
                }

                //remove the expired items
                Iterator<RowData> dataIterator = mData.iterator();
                while (dataIterator.hasNext()) {
                    RowData rd = dataIterator.next();
                    if (rd.timeRemaining <= 0) dataIterator.remove();
                }
                notifyDataSetChanged();
            }

            @Override
            public void onFinish() {
                mData.clear();
                notifyDataSetChanged();
            }
        }.start();
    }

    @Override
    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        return new MyViewHolder(LayoutInflater.from(MainActivity.this).inflate(android.R.layout.simple_list_item_2, parent, false));
    }

    @Override
    public void onBindViewHolder(MyViewHolder holder, int position) {
        RowData rowData = mData.get(position);
        holder.titleTv.setText(rowData.title);
        holder.remainingTimeTv.setText(millToMins(rowData.timeRemaining) + " mins remaining");
    }

    private String millToMins(long millisec) {
        return millisec / (60000) + ":" + (int) (millisec/1000) % (60);
    }

    @Override
    public int getItemCount() {
        return mData.size();
    }

    public class MyViewHolder extends RecyclerView.ViewHolder {
        private TextView remainingTimeTv;
        private TextView titleTv;

        public MyViewHolder(View itemView) {
            super(itemView);
            remainingTimeTv = (TextView) itemView.findViewById(android.R.id.text2);
            titleTv = (TextView) itemView.findViewById(android.R.id.text1);
        }
    }

}

公共回收服务适配器（ArrayList数据）{ mData=数据； //找出计时器的最长时间 long maxTime=System.currentTimeMillis（）； 对于（行数据项：mData）{ maxTime=Math.max（maxTime，item.endTime）； } //设置计时器，该计时器将显示w

import android.text.format.DateFormat;

public class TimedItem {
    private final long expireAt;
    private final String  name;

    public TimedItem(String name, long expireAt) {
        this.name = name;
        this.expireAt = expireAt;
    }

    public String getName() {
        return name;
    }

    public String getDescription(){
        return String.format("Expires at %s.", DateFormat.format("h:mm:ss a ddd, MMM, YYYY",this.expireAt));
    }

    public boolean isExpired(){
        return System.currentTimeMillis() > this.expireAt;
    }
}

import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.TextView;

public class TimedItemHolder extends RecyclerView.ViewHolder {
    private final TextView nameView;
    private final TextView descView;
    public TimedItemHolder(View itemView) {
        super(itemView);
        this.nameView = (TextView) itemView.findViewById(android.R.id.text1);
        this.descView = (TextView) itemView.findViewById(android.R.id.text2);
    }

    public TextView getNameView() {
        return nameView;
    }

    public TextView getDescView() {
        return descView;
    }
}

import android.os.Handler;
import android.os.Looper;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;


public class TimerAdapter extends RecyclerView.Adapter<TimedItemHolder> {
    private final List<TimedItem> items = new ArrayList<>();
    private final Handler handler = new Handler(Looper.getMainLooper());
    private final long interval;
    private final Runnable task = new Runnable() {
        @Override
        public void run() {
            int i = 0;
            Iterator<TimedItem> iterator = TimerAdapter.this.items.iterator();
            while (iterator.hasNext()) {
                TimedItem item = iterator.next();
                if (item.isExpired()) {
                    iterator.remove();
                    notifyItemRemoved(i);
                } else {
                    i++;
                }
            }
            handler.postDelayed(this, interval);
        }
    };

    public TimerAdapter(long interval) {
        this.interval = interval;
        handler.postDelayed(task, interval);
    }

    public void addItem(TimedItem item) {
        this.items.add(item);
    }

    public void addAll(Collection<? extends TimedItem> items) {
        this.items.addAll(items);
    }

    public void clear() {
        this.items.clear();
    }

    @Override
    public TimedItemHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(android.R.layout.simple_list_item_2, parent, false);
        return new TimedItemHolder(view);
    }

    @Override
    public void onBindViewHolder(TimedItemHolder holder, int position) {
        TimedItem item = this.items.get(position);
        holder.getNameView().setText(item.getName());
        holder.getDescView().setText(item.getDescription());
    }

    @Override
    public int getItemCount() {
        return this.items.size();
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        handler.removeCallbacks(task);
    }
}

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;

import java.util.Random;


public class TestActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        RecyclerView list = new RecyclerView(this);
        list.setLayoutManager(new LinearLayoutManager(this));
        TimerAdapter adapter = new TimerAdapter(1000);
        list.setAdapter(adapter);
        setContentView(list);


        Random random = new Random();

        for (int i = 0; i < 20; i++) {
            String name = "Item: " + i;
            long expireAt = System.currentTimeMillis() + 5000 + random.nextInt(20000);
            adapter.addItem(new TimedItem(name,expireAt));
        }

        adapter.notifyDataSetChanged();
    }
}