RecyclerView学习笔记(1) ChildHelper.Bucket

简介

RecyclerView中的ChildHelper.Bucket是一个工具类，实现了类似List<Boolean>的数据结构，从而达到减少内存占用的目的。
Bucket是一个链表结构，有两个字段：mData用于存储当前信息，next指向下一个数据

public static class Bucket {        final static int BITS_PER_WORD = Long.SIZE;        final static long LAST_BIT = 1L << (Long.SIZE - 1);        long mData = 0;//当前数据        Bucket next;//指向下一个数据}

mData是long类型，存在64个bit位，每一个bit位可以是0或者1，代表true或false。这样一个mData可以存储64个(long类型的位数)true或false信息。相对于List<Boolean>,而且是最多64位。当然，如果需要集合的大小超过了64，则相关的信息存储到了next中，这就是使用链表的作用了吧。

toString方法

链式调用next，打印mData的二进制字符串，不同的buckt用xx分隔(后面有使用示例)

@Override        public String toString() {            return next == null ? Long.toBinaryString(mData)                    : next.toString() + "xx" + Long.toBinaryString(mData);        }

调用端代码：

Log.i(TAG,bucket.toString());//0        bucket.set(65);        Log.i(TAG,bucket.toString());//10xx0

set方法

设置对应index位的bit为1(index从0开始)

public void set(int index) {            if (index >= BITS_PER_WORD) {//如果index大于等于64，则相关信息设置到next中                ensureNext();                next.set(index - BITS_PER_WORD);            } else {                mData |= 1L << index;            }        }

调用端代码：

ChildHelper.Bucket bucket = new ChildHelper.Bucket();bucket.set(3);Log.i(TAG,bucket.toString());//1000

从结果可以看到：idex为3的位置的bit已经被设置成1了

get方法

判断index对应的bit是否为1，如果为1，返回true，否则返回false。

public boolean get(int index) {            if (index >= BITS_PER_WORD) {//如果index大于等于64，则从next中获取                ensureNext();                return next.get(index - BITS_PER_WORD);            } else {                return (mData & (1L << index)) != 0;            }        }

调用端代码：

bucket.set(4);Log.i(TAG,bucket.toString());//10000boolean has4 = bucket.get(4);Log.i(TAG,"has4=" + has4);//has4=true

可以看到index为4的bit为1，就返回了true

clear方法

设置index对应的bit为0

public void clear(int index) {            if (index >= BITS_PER_WORD) {//如果index大于等于64，则设置next中相应数据                if (next != null) {                    next.clear(index - BITS_PER_WORD);                }            } else {                mData &= ~(1L << index);            }        }

调用端代码：

bucket.set(3);        Log.i(TAG,bucket.toString());//1000        bucket.clear(3);        Log.i(TAG,bucket.toString());//0

可以看到index为3对应的bit已经被设置成0

countOnesBefore方法

计算比index小的所有位数上bit为1的总个数。
例如 0001 1010，如果index为5，则结果为3；如果index为4，则结果是2

public int countOnesBefore(int index) {            if (next == null) {                if (index >= BITS_PER_WORD) {                    return Long.bitCount(mData);                }                return Long.bitCount(mData & ((1L << index) - 1));            }            if (index < BITS_PER_WORD) {                return Long.bitCount(mData & ((1L << index) - 1));            } else {                return next.countOnesBefore(index - BITS_PER_WORD) + Long.bitCount(mData);            }        }

调用端代码：

bucket.set(4);        Log.i(TAG,bucket.toString());//10000        boolean has4 = bucket.get(4);        Log.i(TAG,"has4=" + has4);//has4=true        bucket.set(3);        bucket.set(2);        Log.i(TAG,bucket.toString());//11100        int i = bucket.countOnesBefore(5);        Log.i(TAG,"i=" + i);//i=3(前5位中bit为1的总数)        int j = bucket.countOnesBefore(4);        Log.i(TAG,"j=" + j);//j=2(前4位中bit为1的总数)

可以看到，如果当前bucket为11100，则countOnesBefore(5)为3，countOnesBefore(4)为2。

reset方法

重置，所有数据置为0

public void reset() {            mData = 0;            if (next != null) {                next.reset();            }        }

调用端代码：

bucket.set(65);        Log.i(TAG,bucket.toString());//10xx0        bucket.reset();        Log.i(TAG,bucket.toString());//0xx0

insert方法

在index位置插入指定bit：value为true插入1，value为false插入0

public void insert(int index, boolean value) {            if (index >= BITS_PER_WORD) {//如果index大于等于64，则在next中插入                ensureNext();                next.insert(index - BITS_PER_WORD, value);            } else {                final boolean lastBit = (mData & LAST_BIT) != 0;                long mask = (1L << index) - 1;                final long before = mData & mask;//小于index的数据                final long after = ((mData & ~mask)) << 1;//大于index的数据，已经左移一位，腾出当前位置                mData = before | after;                if (value) {                    set(index);//value为ture插入1                } else {                    clear(index);//value为false插入0                }                if (lastBit || next != null) {                    ensureNext();                    next.insert(0, lastBit);//将当前bucket最高位的bit插入到next的index为0的位置上（实现左移操作）                }            }        }

调用端代码：

bucket.reset();        Log.i(TAG,bucket.toString());//0xx0        bucket.set(6);        bucket.set(5);        Log.i(TAG,bucket.toString());//0xx1100000        bucket.insert(6,false);        Log.i(TAG,bucket.toString());//0xx10100000(6和5之间插入一位，插入的值为0)        bucket.insert(6,true);        Log.i(TAG,bucket.toString());//0xx101100000(6和5之间插入一位，插入的值为0)

可以看到在index为6的位置上插入了指定bit，低于6的数据保持不变，大于等于6的数据左移了一位

remove方法

移除index对应位置的bit。低于index的所有数据保持不变，高于index的数据右移一位。

public boolean remove(int index) {            if (index >= BITS_PER_WORD) {//如果index大于等于64，则在next中移除                ensureNext();                return next.remove(index - BITS_PER_WORD);            } else {                long mask = (1L << index);                final boolean value = (mData & mask) != 0;                mData &= ~mask;//index未bit置为0                mask = mask - 1;                final long before = mData & mask;//小于index的数据                // cannot use >> because it adds one.                final long after = Long.rotateRight(mData & ~mask, 1);//大于index的数据（已右移一位）                mData = before | after;                if (next != null) {//如果next存在                    if (next.get(0)) {//如果next的index为0的bit为1                        set(BITS_PER_WORD - 1);//设置当前最高位的bit为1(相当于右移一位)                    }                    next.remove(0);//next需要进行：删除index为0的操作                }                return value;            }        }

调用端代码：

Log.i(TAG,bucket.toString());//0xx101100000(6和5之间插入一位，插入的值为0)bucket.remove(6);Log.i(TAG,bucket.toString());//0xx10100000(移除位置6的bit)

可以看到index为6的bit删除了，低于6的数据保持不变，高于6的数据全部右移了一位

总结

Bucket通过链表的数据结构和long类型可以存储64位bit为1或0的特性，实现了类似List<Boolean>的数据结构，从而达到减少内存占用的目的。