Butterknife.OnClick中防止按键过快的点击的的一种解决方案。

按键的防抖就是判断一下两次点击的时间差，但是如果在Butterknife.OnClick中写，每次都要写一堆代码
其实我们希望的最理想的解决方案是：

@OnClick({R.id.record, R.id.combine})
public void onClick(View view) {
    if (AntiShake.check(view.getId())) {    //判断是否多次点击
        return;  
    }
    switch (view.getId()) {
        case R.id.hos_detail_visit_record:
           //todo
            break;
        case R.id.combine_chart:
            //todo
    }
}

实现方法如下：

第一个类类似于NoDoubleClickListener 判断下两次点击的时间

public class OneClick {
    private String methodName;
    private static final int CLICK_DELAY_TIME = 1000;
    private long lastClickTime = 0;

    public OneClick(String methodName) {
        this.methodName = methodName;
    }

    public String getMethodName() {
        return methodName;
    }

    public boolean check() {
        long currentTime = Calendar.getInstance().getTimeInMillis();
        if (currentTime - lastClickTime > CLICK_DELAY_TIME) {
            lastClickTime = currentTime;
            return false;
        } else {
            return true;
        }
    }
}

第二个类静态变量存储点击事件，可以定制存储的数量超出了可以自动删除之前的。

public class AntiShake {

    private static LimitQueue queue = new LimitQueue<>(20);

    public static boolean check(Object o) {
        String flag;
        if(o == null) {
            flag = Thread.currentThread().getStackTrace()[2].getMethodName();
        } else {
            flag = o.toString();
        }
        for (OneClick util : queue.getArrayList()) {
            if (util.getMethodName().equals(flag)) {
                return util.check();
            }
        }
        OneClick clickUtil = new OneClick(flag);
        queue.offer(clickUtil);
        return clickUtil.check();
    }
}

第三个类就是存储一定对象的链表，超出了定义的范围就删除第一个对象

public class LimitQueue  {

    private int limitedSize;

    private LinkedList linkedList = new LinkedList<>();

    public LimitQueue(int size) {
        this.limitedSize = size;
    }

    public void offer(E e) {
        if (linkedList.size() >= limitedSize) {
            linkedList.poll();
        }
        linkedList.offer(e);
    }

    public E get(int position) {
        return linkedList.get(position);
    }

    public E getLast() {
        return linkedList.getLast();
    }

    public E getFirst() {
        return linkedList.getFirst();
    }

    public int getLimit() {
        return limitedSize;
    }

    public void setLimitedSize(int size) {
        this.limitedSize = size;
    }

    public int size() {
        return linkedList.size();
    }

    public ArrayList getArrayList() {
        ArrayList arrayList = new ArrayList<>();
        for (int i = 0; i < linkedList.size(); i ++) {
            arrayList.add(linkedList.get(i));
        }
        return arrayList;
    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < linkedList.size(); i++) {
            buffer.append(linkedList.get(i));
            buffer.append(" ");
        }
        return buffer.toString();
    }
}

使用时直接 增加 if (AntiShake.check(view.getId())) 判断就可以了。如果有不对的地方，请提出宝贵的意见。