Removes the specified element from this set if it is present.

@param e element to be removed from this set, if present
@return <tt>true</tt> if the set contained the specified element
507686
public boolean remove(Object e) {
        if (e == null)
            return false;
        Class<?> eClass = e.getClass();
        if (eClass != elementType && eClass.getSuperclass() != elementType)
            return false;
        int eOrdinal = ((Enum<?>)e).ordinal();
        int eWordNum = eOrdinal >>> 6;

        long oldElements = elements[eWordNum];
        elements[eWordNum] &= ~(1L << eOrdinal);
        boolean result = (elements[eWordNum] != oldElements);
        if (result)
            size--;
        return result;
    }
79774
public boolean remove(final T element) {
    for (int i = 0; i < this.size; i++)
      if (this.elements[i].equals(element)) {
        System.arraycopy(this.elements, i + 1, this.elements, i, this.size - (i + 1));
        this.size--;
        return true;
      }
    return false;
  }
1372189
public boolean remove(Object o) {
        boolean removed = false;
        for (Set<T> s : sets)
            if (s.remove(o))
                removed = true;
        return removed;
    }
1108262
public boolean contains (E e) {
		for (int i = 0; size > i; i++) {
			if (e == data[i]) {
				return true;
			}
		}
		return false;
	}
902169
public Set<ElementDescriptor<?>> getRemoved()
	{
		return mRemove == null ? null : Collections.unmodifiableSet(mRemove.keySet());
	}
1078775
public void removeMatch(Element e, PseudoClassType pseudoClass)
    {
        if (elements != null)
        {
            Set<PseudoClassType> classes = elements.get(e);
            if (classes != null)
                classes.remove(pseudoClass);
        }   
    }
888765
public boolean contains(T element) {
    if (element == null) { return false; }
    return comparator.compare(element, min) > -1 && comparator.compare(element, max) < 1;
  }
918412
public boolean remove(Set<?> set, Object object) {
		if (set == null || object == null) {
			return false;
		}
		
		return set.remove(object);
	}
607791
boolean contains(Linked<?> e) {
        return (e.getPrevious() != null)
                || (e.getNext() != null)
                || (e == first);
    }
524551
protected boolean fail(Throwable e) {
        if (done.compareAndSet(false, true)) {
            onErrorCore(e);
            return true;
        }
        return false;
    }
702170
public static boolean contains(Enumeration<?> enumeration, Object element) {
        if (enumeration != null) {
            while (enumeration.hasMoreElements()) {
                Object candidate = enumeration.nextElement();
                if (ObjectUtils.nullSafeEquals(candidate, element)) {
                    return true;
                }
            }
        }
        return false;
    }
613025
@Override
    public boolean removeFirstOccurrence(E e) {
        boolean result = queue.removeFirstOccurrence(e);
        if (result) {
            addCapacity(-1);
        }
        return result;
    }
507375
@Override
   public boolean remove(Object element)
   {
      for (int index = size - 1; index >= 0; index--) {
         if (element == elementData[index]) {
            final int numMoved = size - index - 1;
            if (numMoved > 0) {
               System.arraycopy(elementData, index + 1, elementData, index, numMoved);
            }
            elementData[--size] = null;
            return true;
         }
      }

      return false;
   }
781278
public synchronized void remove(E key)
    {    
        Entry<E, T> entry = map.get(key);
        this.tail.prev = entry.prev;
        entry.prev.next = this.tail;
        map.remove(entry.key);
        this.length--;   
    }
765929
public boolean remove(Object o) {
        boolean ret = super.remove(WeakElement.create(o));
        processQueue();
        return ret;
    }
243978
private boolean findAndRemove(Object e) {
        if (e != null) {
            for (Node pred = null, p = head; p != null; ) {
                Object item = p.item;
                if (p.isData) {
                    if (item != null && item != FORGOTTEN && e.equals(item) &&
                        p.tryMatchData()) {
                        unsplice(pred, p);
                        return true;
                    }
                }
                else if (item == null)
                    break;
                pred = p;
                if ((p = p.next) == UNLINKED) { // stale
                    pred = null;
                    p = head;
                }
            }
        }
        return false;
    }
531634
@Override
    public boolean add(T e) {
        if (elements.add(e)) {
            ordered.add(e);
            return true;
        } else {
            return false;
        }
    }