【Guava】集合工具Collections2

Collections2

private  Collections2() {
}

私有构造器，也没有静态构造器，所以可以很明确它是一个纯工具类了。

filter过滤方法

传入一个带过滤的容器，和一个实现过滤规则的函数类，返回一个带有过滤动作的容器

public static  Collection filter(
      Collection unfiltered, Predicate predicate) {
    if (unfiltered instanceof FilteredCollection) {
      // Support clear(), removeAll(), and retainAll() when filtering a filtered
      // collection.
      return ((FilteredCollection) unfiltered).createCombined(predicate);
    }

    return new FilteredCollection(checkNotNull(unfiltered), checkNotNull(predicate));
}

如果是Collections2.FilteredCollection类，则直接转型到Collections2.FilteredCollection，然后返回这个类。如果不是Collections2.FilteredCollection，则new一个，将传入的容器和规则传入。

static class FilteredCollection extends AbstractCollection {
    // 存储待处理的集合
    final Collection unfiltered;
    //存储过滤规则
    final Predicate predicate;

    FilteredCollection(Collection unfiltered, Predicate predicate) {
      this.unfiltered = unfiltered;
      this.predicate = predicate;
    }
   
    //根据新的过滤规则和原来的过滤规则合并创建一个新的容器
    FilteredCollection createCombined(Predicate newPredicate) {
      return new FilteredCollection(unfiltered, Predicates.and(predicate, newPredicate));
      // . above needed to compile in JDK 5
    }

    //添加元素方法
    @Override
    public boolean add(@ParametricNullness E element) {
      //根据过滤规则进行测试是否符合，如果符合便进行添加
      checkArgument(predicate.apply(element));
      return unfiltered.add(element);
    }

    //添加一个容器中所有元素
    @Override
    public boolean addAll(Collection collection) {
      //遍历容器，并对每一个容器进行筛选
      for (E element : collection) {
        checkArgument(predicate.apply(element));
      }
      //如果都满足就添加
      return unfiltered.addAll(collection);
    }

    //...其他方法
}

转型方法

传入一个转型的类，再传入一个转型规则

public static  Collection transform(
      Collection fromCollection, Function function) {
    return new TransformedCollection<>(fromCollection, function);
}

static class TransformedCollection
      extends AbstractCollection {
    //需要转型的容器
    final Collection fromCollection;
    //转型规则
    final Function function;

    TransformedCollection(Collection fromCollection, Function function) {
      this.fromCollection = checkNotNull(fromCollection);
      this.function = checkNotNull(function);
    }

   //根据转型规则进行迭代
    @Override
    public Iterator iterator() {
      return Iterators.transform(fromCollection.iterator(), function);
    }

    //...其他方法
}

有序排列方法

//第一种是调用了第二种
public static > Collection> orderedPermutations(Iterable elements) {
    return orderedPermutations(elements, Ordering.natural());
}

//第二种直接创建了Collections2.OrderedPermutationCollection类
public static  Collection> orderedPermutations(Iterable elements, Comparator comparator) {
    return new Collections2.OrderedPermutationCollection(elements, comparator);
}

private static final class OrderedPermutationCollection extends AbstractCollection> {
    //不可变集合
    final ImmutableList inputList;
    //比较器
    final Comparator comparator;
    final int size;

    OrderedPermutationCollection(Iterable input, Comparator comparator) {
      this.inputList = ImmutableList.sortedCopyOf(comparator, input);
      this.comparator = comparator;
      this.size = calculateSize(inputList, comparator);
    }

    /**
     * The number of permutations with repeated elements is calculated as follows:
     *
     * 

     *   
For an empty list, it is 1 (base case).对于空列表，它是1(基线条件)。
     *   
When r numbers are added to a list of n-r elements, the number of permutations is
     *       increased by a factor of (n choose r). 
             当向n-r个元素的列表中添加r个数字时，排列的次数是(n choose r)的倍数。
     * 
     */
    private static  int calculateSize(
        List sortedInputList, Comparator comparator) {
      int permutations = 1;//用于存储排列数，初始值为1
      int n = 1;//用于追踪当前元素的索引位置，初始值为1
      int r = 1;//用于追踪当前重复元素的次数，初始值为1
      while (n < sortedInputList.size()) {
         //使用比较器比较索引为n-1和n的元素
        int comparison = comparator.compare(sortedInputList.get(n - 1), sortedInputList.get(n));
        if (comparison < 0) {//如果索引n-1的元素小于索引n的元素
          // We move to the next non-repeated element.
            //更新排列数。
            //IntMath.binomial用于计算二项式系数的函数
            //IntMath.saturatedMultiply 用于计算两数相乘，但不会溢出int的最大最小值
          permutations = IntMath.saturatedMultiply(permutations, IntMath.binomial(n, r));
          r = 0;//重置r=0
          if (permutations == Integer.MAX_VALUE) {
            return Integer.MAX_VALUE;
          }
        }
        n++;
        r++;
      }
      return IntMath.saturatedMultiply(permutations, IntMath.binomial(n, r));
    }

    @Override
    public Iterator> iterator() {
      return new OrderedPermutationIterator(inputList, comparator);
    }

    //..。其他方法
  }