org.apache.commons.collections.Bag Java Examples

/**
 * Compares this Bag to another.
 * This Bag equals another Bag if it contains the same number of occurrences of
 * the same elements.
 * 
 * @param object  the Bag to compare to
 * @return true if equal
 */
public boolean equals(Object object) {
    if (object == this) {
        return true;
    }
    if (object instanceof Bag == false) {
        return false;
    }
    Bag other = (Bag) object;
    if (other.size() != size()) {
        return false;
    }
    for (Iterator it = map.keySet().iterator(); it.hasNext();) {
        Object element = it.next();
        if (other.getCount(element) != getCount(element)) {
            return false;
        }
    }
    return true;
}
 

/**
 * Remove any members of the bag that are not in the given
 * bag, respecting cardinality.
 * @see #retainAll(Collection)
 * 
 * @param other  the bag to retain
 * @return <code>true</code> if this call changed the collection
 */
boolean retainAll(Bag other) {
    boolean result = false;
    Bag excess = new HashBag();
    Iterator i = uniqueSet().iterator();
    while (i.hasNext()) {
        Object current = i.next();
        int myCount = getCount(current);
        int otherCount = other.getCount(current);
        if (1 <= otherCount && otherCount <= myCount) {
            excess.add(current, myCount - otherCount);
        } else {
            excess.add(current, myCount);
        }
    }
    if (!excess.isEmpty()) {
        result = removeAll(excess);
    }
    return result;
}
 

/**
 * Bag 测试
 * 主要测试重复元素的统计
 */
@SuppressWarnings("deprecation")
private static void bagTest(){
	//定义4种球
	Bag box=new HashBag(Arrays.asList("red","blue","black","green"));
	System.out.println("box.getCount():"+box.getCount("red"));//box.getCount():1
	box.add("red", 5);//红色的球增加五个
	System.out.println("box.size():"+box.size());	//box.size():9
	System.out.println("box.getCount():"+box.getCount("red"));//box.getCount():6
}
 

/**
 * Returns <code>true</code> if the bag contains all elements in
 * the given collection, respecting cardinality.
 * 
 * @param other  the bag to check against
 * @return <code>true</code> if the Bag contains all the collection
 */
boolean containsAll(Bag other) {
    boolean result = true;
    Iterator it = other.uniqueSet().iterator();
    while (it.hasNext()) {
        Object current = it.next();
        boolean contains = getCount(current) >= other.getCount(current);
        result = result && contains;
    }
    return result;
}
 

/**
 * Determines if the bag contains the given elements.
 * 
 * @param coll  the collection to check against
 * @return <code>true</code> if the Bag contains all the collection
 */
public boolean containsAll(Collection coll) {
    if (coll instanceof Bag) {
        return containsAll((Bag) coll);
    }
    return containsAll(new HashBag(coll));
}
 

/**
 * Remove any members of the bag that are not in the given
 * bag, respecting cardinality.
 *
 * @param coll  the collection to retain
 * @return true if this call changed the collection
 */
public boolean retainAll(Collection coll) {
    if (coll instanceof Bag) {
        return retainAll((Bag) coll);
    }
    return retainAll(new HashBag(coll));
}
 

/**
 * Factory method to create an unmodifiable bag.
 * <p>
 * If the bag passed in is already unmodifiable, it is returned.
 * 
 * @param bag  the bag to decorate, must not be null
 * @return an unmodifiable Bag
 * @throws IllegalArgumentException if bag is null
 */
public static Bag decorate(Bag bag) {
    if (bag instanceof Unmodifiable) {
        return bag;
    }
    return new UnmodifiableBag(bag);
}
 

/**
 * Factory method to create a transforming bag.
 * <p>
 * If there are any elements already in the bag being decorated, they
 * are NOT transformed.
 * 
 * @param bag  the bag to decorate, must not be null
 * @param transformer  the transformer to use for conversion, must not be null
 * @return a new transformed Bag
 * @throws IllegalArgumentException if bag or transformer is null
 */
public static Bag decorate(Bag bag, Transformer transformer) {
    return new TransformedBag(bag, transformer);
}
 

/**
 * Factory method to create a predicated (validating) bag.
 * <p>
 * If there are any elements already in the bag being decorated, they
 * are validated.
 * 
 * @param bag  the bag to decorate, must not be null
 * @param predicate  the predicate to use for validation, must not be null
 * @return a new predicated Bag
 * @throws IllegalArgumentException if bag or predicate is null
 * @throws IllegalArgumentException if the bag contains invalid elements
 */
public static Bag decorate(Bag bag, Predicate predicate) {
    return new PredicatedBag(bag, predicate);
}
 

/**
 * Constructor that wraps (not copies).
 * 
 * @param bag  the bag to decorate, must not be null
 * @param lock  the lock to use, must not be null
 * @throws IllegalArgumentException if bag is null
 */
protected SynchronizedSortedBag(Bag bag, Object lock) {
    super(bag, lock);
}
 

/**
 * Factory method to create a typed bag.
 * <p>
 * If there are any elements already in the bag being decorated, they
 * are validated.
 * 
 * @param bag  the bag to decorate, must not be null
 * @param type  the type to allow into the bag, must not be null
 * @return a new typed Bag
 * @throws IllegalArgumentException if bag or type is null
 * @throws IllegalArgumentException if the bag contains invalid elements
 */
public static Bag decorate(Bag bag, Class type) {
    return new PredicatedBag(bag, InstanceofPredicate.getInstance(type));
}
 

/**
 * Gets the bag being decorated.
 * 
 * @return the decorated bag
 */
protected Bag getBag() {
    return (Bag) collection;
}
 

/**
 * Constructor that wraps (not copies).
 * 
 * @param bag  the bag to decorate, must not be null
 * @param lock  the lock to use, must not be null
 * @throws IllegalArgumentException if bag is null
 */
protected SynchronizedBag(Bag bag, Object lock) {
    super(bag, lock);
}
 

/**
 * Constructor that wraps (not copies).
 * 
 * @param bag  the bag to decorate, must not be null
 * @throws IllegalArgumentException if bag is null
 */
protected SynchronizedBag(Bag bag) {
    super(bag);
}
 

/**
 * Factory method to create a synchronized bag.
 * 
 * @param bag  the bag to decorate, must not be null
 * @return a new synchronized Bag
 * @throws IllegalArgumentException if bag is null
 */
public static Bag decorate(Bag bag) {
    return new SynchronizedBag(bag);
}
 

/**
 * Constructor that wraps (not copies).
 * 
 * @param bag  the bag to decorate, must not be null
 * @throws IllegalArgumentException if bag is null
 */
private UnmodifiableBag(Bag bag) {
    super(bag);
}
 

/**
 * Constructor that wraps (not copies).
 * <p>
 * If there are any elements already in the bag being decorated, they
 * are NOT transformed.
 * 
 * @param bag  the bag to decorate, must not be null
 * @param transformer  the transformer to use for conversion, must not be null
 * @throws IllegalArgumentException if bag or transformer is null
 */
protected TransformedBag(Bag bag, Transformer transformer) {
    super(bag, transformer);
}
 

/**
 * Gets the decorated bag.
 * 
 * @return the decorated bag
 */
protected Bag getBag() {
    return (Bag) collection;
}
 

/**
 * Constructor that wraps (not copies).
 * 
 * @param bag  the bag to decorate, must not be null
 * @throws IllegalArgumentException if list is null
 */
protected AbstractBagDecorator(Bag bag) {
    super(bag);
}
 

/**
 * Gets the bag being decorated.
 * 
 * @return the decorated bag
 */
protected Bag getBag() {
    return (Bag) getCollection();
}
 

/**
 * Gets the decorated bag.
 * 
 * @return the decorated bag
 */
protected Bag getBag() {
    return (Bag) getCollection();
}
 

/**
 * Constructor that wraps (not copies).
 * <p>
 * If there are any elements already in the bag being decorated, they
 * are validated.
 * 
 * @param bag  the bag to decorate, must not be null
 * @param predicate  the predicate to use for validation, must not be null
 * @throws IllegalArgumentException if bag or predicate is null
 * @throws IllegalArgumentException if the bag contains invalid elements
 */
protected PredicatedBag(Bag bag, Predicate predicate) {
    super(bag, predicate);
}