是否在给定分组的集合中包含指定值<br>
如果给定分组对应集合不存在，则返回false

@param group 分组名
@param value 测试的值
@param otherValues 其他值
@return 是否包含
325152
public boolean contains(String group, String value, String... otherValues) {
		if (ArrayUtil.isNotEmpty(otherValues)) {
			// 需要测试多个值的情况
			final List<String> valueList = Arrays.asList(otherValues);
			valueList.add(value);
			return contains(group, valueList);
		} else {
			// 测试单个值
			final LinkedHashSet<String> valueSet = getValues(group);
			if (CollectionUtil.isEmpty(valueSet)) {
				return false;
			}

			return valueSet.contains(value);
		}
	}
1308037
public boolean contains(String group, Collection<String> values) {
		final LinkedHashSet<String> valueSet = getValues(group);
		if (CollectionUtil.isEmpty(values) || CollectionUtil.isEmpty(valueSet)) {
			return false;
		}

		return valueSet.containsAll(values);
	}
339816
void putAll(ParsedValues other) {

        if (this.keys == null) {
            int v = other.len;
            if (v != Integer.MIN_VALUE) {
                if ((this.len == Integer.MIN_VALUE) || this.duplicateKeysAllowed || (this.len == v)) {
                    this.len = v;
                } else {
                    throw new AmbivalentValueException(PlainTime.DIGITAL_HOUR_OF_DAY);
                }
            }
            v = other.mask;
            if (v != Integer.MIN_VALUE) {
                if ((this.mask == Integer.MIN_VALUE) || this.duplicateKeysAllowed || (this.mask == v)) {
                    this.mask = v;
                } else {
                    throw new AmbivalentValueException(PlainTime.MINUTE_OF_HOUR);
                }
            }
            v = other.threshold;
            if (v != Integer.MIN_VALUE) {
                if ((this.threshold == Integer.MIN_VALUE) || this.duplicateKeysAllowed || (this.threshold == v)) {
                    this.threshold = v;
                } else {
                    throw new AmbivalentValueException(PlainTime.SECOND_OF_MINUTE);
                }
            }
            v = other.count;
            if (v != Integer.MIN_VALUE) {
                if ((this.count == Integer.MIN_VALUE) || this.duplicateKeysAllowed || (this.count == v)) {
                    this.count = v;
                } else {
                    throw new AmbivalentValueException(PlainTime.NANO_OF_SECOND);
                }
            }
            for (int i = 0; i < 3; i++) {
                v = other.ints[i];
                if (v != Integer.MIN_VALUE) {
                    if ((this.ints[i] == Integer.MIN_VALUE) || this.duplicateKeysAllowed || (this.ints[i] == v)) {
                        this.ints[i] = v;
                    } else {
                        throw new AmbivalentValueException(getIndexedElement(i));
                    }
                }
            }
            Map<ChronoElement<?>, Object> m = other.map;
            if (m != null) {
                for (ChronoElement<?> e : m.keySet()) {
                    this.put(e, m.get(e));
                }
            }
            return;
        }

        Object[] elements = other.keys;
        Object current;

        for (int i = 0; i < elements.length; i++) {
            if ((current = elements[i]) != null) {
                ChronoElement<?> element = ChronoElement.class.cast(current);
                if (element.getType() == Integer.class) {
                    this.put(element, other.ints[i]);
                } else {
                    this.put(element, other.values[i]);
                }
            }
        }

    }
593049
public static ListValue of(Timestamp first, Timestamp... other) {
    return newBuilder().addValue(first, other).build();
  }
1365195
public String put(String group, String key, String value) {
		group = StrUtil.nullToEmpty(group).trim();
		writeLock.lock();
		try {
			LinkedHashMap<String, String> valueMap = this.get(group);
			if (null == valueMap) {
				valueMap = new LinkedHashMap<>();
				this.put(group, valueMap);
			}
			this.size = -1;
			return valueMap.put(key, value);
		} finally {
			writeLock.unlock();
		}
	}
685813
public boolean containsValue(final Object value) {
	return ! forEachPair( 
		new LongObjectProcedure() {
			public boolean apply(long iterKey, Object iterValue) {
				return (value != iterValue);
			}
		}
	);
}
584687
def merge_into_group(self, group):
        
        super(ValueConstant, self).merge_into_group(group)
        group.value = self.value
205551
@Override
	public boolean contains(final Object value) {
		lock.readLock().lock();
		try {
			if (value == null) {
				return false;
			}
			for (@SuppressWarnings("rawtypes")
			final Map.Entry entry : entrySet()) {
				final Object otherValue = entry.getValue();
				if (otherValue != null && otherValue.equals(value)) {
					return true;
				}
			}
			return false;
		} finally {
			lock.readLock().unlock();
		}
	}
399247
public void addValue(String value)
    {
        if(this.values == null)
            this.values = new ArrayList<String>();
        this.values.add(value);
    }
1134564
private List<Boolean> asBooleanList(Object value) {
        boolean[] values = (boolean[]) value;
        List<Boolean> list = new ArrayList<Boolean>(values.length);
        for (boolean booleanValue : values) {
            list.add(booleanValue);
        }
        return list;
    }
1116305
public boolean containsValue (int value) {
		K[] keyTable = this.keyTable;
		int[] valueTable = this.valueTable;
		for (int i = capacity + stashSize; i-- > 0;)
			if (keyTable[i] != null && valueTable[i] == value) return true;
		return false;
	}
256283
@Override
	public List<CPOptionValue> findByGroupId(long groupId) {
		return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
295304
public boolean isInGroup(final String other) {
        return ParserRegistry.getParser(group).getGroup().equals(ParserRegistry.getParser(other).getGroup());
    }
263884
public boolean acceptsValue(String value) {
		if (value==null) {
			return false;
		} else if (hasValues()) {
			return getValuesList().contains(value);
		} else {
			return true;
		}
	}
473165
public Collection<String> values(String group) {
		group = StrUtil.nullToEmpty(group).trim();
		readLock.lock();
		try {
			final LinkedHashMap<String, String> valueMap = this.get(group);
			if (MapUtil.isNotEmpty(valueMap)) {
				return valueMap.values();
			}
		} finally {
			readLock.unlock();
		}
		return Collections.emptyList();
	}
473567
public static <T> T check(T value, T elseValue, IChecker checker) {
        return check(value, elseValue, checker.check());
    }
52626
private boolean attributeEquals(Object value, Object otherValue) {
        if (value == null && otherValue == null) {
            return true;
        } else if (value == null || otherValue == null) {
            return false;
        } else {
            if (value.getClass().isArray()) {
                return Arrays.equals((Object[]) value, (Object[]) otherValue);
                  
            } else {
                return value.equals(otherValue);
            }
        }
    }