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] }
此方法注意了，有相加的功能和去重的功能，很多场景还是很好用的