Commons-Collections（一）之list

Bag

Bag继承自Collection接口，定义了一个集合，该集合会记录对象在集合中出现的次数。

假设你有一个包，包含{a, a, b, c}。调用getCount(a)方法将返回2，调用uniqueset()方法将返回{a, b, c}的set集合。

public interface Bag<E> extends Collection<E> {}

顾名思义，它是包的意思，所以也是拿来装数据的。

HashBag

HashBag使用HashMap作为数据存储，是一个标准的Bag实现。

    public static void main(String[] args) {
        Bag hashBag = new HashBag();
        String s1 = "s1";
        String s2 = "s2";
        hashBag.add(s1);
        hashBag.add(s1);
        //一次性放置多个元素
        hashBag.add(s2, 3);

        // 获得包中元素迭代器
        Iterator<?> iterator = hashBag.iterator();
        System.out.println("包中元素为：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("包中元素个数为：" + hashBag.size()); //5
        //下面两个特有的方法 使用起来较为方便
        System.out.println("包中entity1个数为：" + hashBag.getCount(s1)); //2
        System.out.println("去重后个数为：" + hashBag.uniqueSet().size()); //2
    }
结果输出：
包中元素为：
s1
s1
s2
s2
s2
包中元素个数为：5
包中entity1个数为：2
去重后个数为：2

TreeBag

TreeBag使用TreeMap作为数据存储，用法与HashBag类似，只是TreeBag会使用自然顺序对元素进行排序。

总结

使用的方式和List差不多，效果也大同小异。
场景：比如我们需要具体知道每个元素出现的次数的时候，并且实现快速去重，使用Bag会非常便捷

对应的BagUtils，能提供BagUtils.EMPTY_BAG、synchronizedBag、unmodifiableBag等编程同步、只读的快捷方法

BoundedCollection：有限制的集合

继承自Collection，他提供了一些列的有用的实现

FixedSizeList：固定长度大小的List

    public static void main(String[] args) {
        FixedSizeList<String> c = FixedSizeList.fixedSizeList(Arrays.asList("fang", "shi", "xiang"));

        System.out.println(c); //[fang, shi, xiang]
        System.out.println(c.size()); //3

        //c.remove("fang"); //java.lang.UnsupportedOperationException: List is fixed size
        //c.add("fang"); //UnsupportedOperationException: List is fixed size

        //虽然不能增加和删除 但可以改
        c.set(2, "heng");
        System.out.println(c); //[fang, shi, heng]
        System.out.println(c.get(2));

        //BoundedCollection提供的两个方法
        c.isFull(); //如果是FixedSizeList 永远返回true 因为大小肯定是固定的
        c.maxSize(); //值同size()方法
    }

UnmodifiableBoundedCollection：不能修改的List

CircularFifoQueue：环形的先进先出队列

当达到指定的size长度后，符合FIfo先进先出的原则被环形覆盖

    public static void main(String[] args) {
        CircularFifoQueue<String> c = new CircularFifoQueue<>(3);

        // 这个siz二和MaxSize就有差异化了
        System.out.println(c.size()); //0
        System.out.println(c.maxSize()); //3

        c.add("fang");
        c.add("shi");
        c.add("xiang");

        //我们发现虽然长度是3  但是因为循环的特性 再添加一个并不会报错  而是
        c.add("heng");
        System.out.println(c); //[shi, xiang, heng]

        // 继续添加 就会把前面的继续挤出来 满员了之后，符合先进先出的原则
        c.add("heng2");
        c.add("heng3");
        System.out.println(c); //[heng, heng2, heng3]
    }

GrowthList LazyList ：list自增长效果

GrowthList修饰另一个列表，可以使其在因set或add操作造成索引超出异常时无缝的增加列表长度，可以避免大多数的IndexOutOfBoundsException。

    public static void main(String[] args) {
        List<String> src = new ArrayList<>();
        src.add("11");
        src.add("22");
        src = GrowthList.growthList(src);
        System.out.println(src);

        //经过GrowthList.growthList一修饰后  这个list能够最大程度的避免空数组越界问题  有时候还是挺有用的
        // 索引超出，自动增长
        src.set(4, "44");
        System.out.println(src); //[11, 22, null, null, 44]

    }

备注：LazyList修饰另一个列表，当调用get方法时，如果索引超出列表长度，列表会自动增长，我们可以通过一个工厂获得超出索引位置的值。LazyList和GrowthList都可以实现对修饰的列表进行增长，但是LazyList发生在get时候，而GrowthList发生在set和add时候，我们也可以混合使用这两种列表。

SetUniqueList

SetUniqueList实现了一个不允许重复元素的列表，有点和Set类似。但是由有List，保证了顺序

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("fang");
        list.add("shi");
        list.add("shi");
        list.add("xiang");
        System.out.println(list); //[fang, shi, shi, xiang]

        //完美实现去重 且还完美保证了顺序
        list = SetUniqueList.setUniqueList(list);
        System.out.println(list); //[fang, shi, xiang]

        // 但是需要注意 因为已经是SetUniqueList 类型了  这个时候add相同元素就不再好使了
        list.add("shi");
        System.out.println(list); //[fang, shi, xiang]
    }

我表示这个List在我们既希望去重，有需要保持原来顺序的时候，特别特别好用。装饰一下就行，使用也非常方便

TreeList

TreeList实现了优化的快速插入和删除任何索引的列表。这个列表内部实现利用树结构,确保所有的插入和删除都是O(log n)。

    public static void main(String[] args) {
        List<String> list = new TreeList<>();
        list.add("fang");
        list.add("shi");
        list.add("shi");
        list.add("xiang");
        System.out.println(list); //[fang, shi, shi, xiang]

    }

ListUtils

emptyIfNull：同上

defaultIfNull：可以在为null的时候，自己给个默认值返回

fixedSizeList：不解释

hashCodeForList：给List吧它的HashCode计算出来

intersection：取交集，生成一个新的List

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>(){{
            add("a");
            add("b");
            add("c");
        }};
        List<String> list2 = new ArrayList<String>(){{
            add("c");
            add("d");
            add("e");
        }};

        //取出交集 并且返回一个新的List
        List<String> intersection = ListUtils.intersection(list1, list2);

        System.out.println(intersection); //[c]

        //这个方法也能取出交集的效果 但是会直接改变list1里面的元素  list2不变
        list1.retainAll(list2);
        System.out.println(list1); // [c]
        System.out.println(list2); //[c, d, e]
    }

partition：切割 把一个大的List切割成多个List 非常好用

常用场景：有10000个id需要批量查询，我们可以切割一下，200个发一次请求去查询一次，还可以开多个线程，用闭锁去弄

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>(){{
            add("a");
            add("b");
            add("c");

            add("a");
            add("b");
            add("c");

            add("a");
            add("b");
            add("c");
        }};

        List<List<String>> partition = ListUtils.partition(list1, 4);

        System.out.println(partition); //[[a, b, c, a], [b, c, a, b], [c]]
    }

subtract：相当于做减法，用第一个List除去第二个list里含有的元素 ，然后生成一个新的list

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>(){{
            add("a");
            add("b");
            add("c");
        }};
        List<String> list2 = new ArrayList<String>(){{
            add("c");
            add("d");
            add("e");
        }};

        //取出交集 并且返回一个新的List
        List<String> subtract = ListUtils.subtract(list1, list2);

        System.out.println(subtract); //[a,b]
    }

sum：把两个List的元素相加起来 注意：相同的元素不会加两次 生成一个新的List.

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>(){{
            add("a");
            add("b");
            add("c");
        }};
        List<String> list2 = new ArrayList<String>(){{
            add("c");
            add("c");
            add("c");
            add("d");
            add("e");
        }};

        //取出交集 并且返回一个新的List
        List<String> sumlist = ListUtils.sum(list1, list2);

        System.out.println(sumlist); //[a, b, c, d, e]
    }

此方法注意了，有相加的功能和去重的功能，很多场景还是很好用的

union：这个和sum方法不一样，它不带去重的功能。内部调用的addAll方法，但是生成一个新的List