Checks whether the value exists in an ArrayList of certain key.

@param key the string of the uri
@param value the request body of the uri
@return true or false depending whether the uri and request body have already been processed
15261
private boolean arrayKeyValueExists(String key, String value) {
    if (visitedPost.containsKey(key)) {
      for(String s : visitedPost.get(key)) {
        if(s.equals(value)) {
          return true;
        }
      }
    }

    return false;

  }
958575
public boolean containsKey(Key<?> key) {
    for (int i = 0; i < size; i++) {
      if (bytesEqual(key.asciiName(), name(i))) {
        return true;
      }
    }
    return false;
  }
1216189
public boolean contains(String key) {
        if (!ramMode.equals(DualCacheRamMode.DISABLE) && ramCacheLru.snapshot().containsKey(key)) {
            return true;
        }
        try {
            dualCacheLock.lockDiskEntryWrite(key);
            if (!diskMode.equals(DualCacheDiskMode.DISABLE) && diskLruCache.get(key) != null) {
                return true;
            }
        } catch (IOException e) {
            logger.logError(e);
        } finally {
            dualCacheLock.unLockDiskEntryWrite(key);
        }
        return false;
    }
203817
public static boolean isValid(final String value) {
        if (value == null) {
            return true;
        }
        if (value.length() == 0) {
            return false;
        }
        try {
            InternetAddress.parse(value, false);
            return true;
        } catch (final AddressException ex) {
            return false;
        }
    }
330689
public boolean containsValue(String path, Object value) {
        return JSONPath.containsValue(jsonObject, checkPath(path), value);
    }
463558
@Override
    public boolean containsValue(Object value) {
        try {
            lockAllSegments();
            for (LinkedHashMapSegment<K, V> seg : segments) {
                if (seg.containsValue(value))
                    return true;
            }
            return false;
        } finally {
            unlockAllSegments();
        }
    }
186109
public boolean exists(String key) throws Exception {
        boolean isExist = false;
        Jedis jedis = null;
        try {
            jedis = this.jedisPool.getResource();
            isExist = jedis.exists(SafeEncoder.encode(key));

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            this.jedisPool.returnBrokenResource(jedis);
            throw e;
        } finally {
            if (jedis != null) {
                this.jedisPool.returnResource(jedis);
            }
        }
        return isExist;
    }
568903
public boolean hasCachedValue(Key key) {
		try {
			readLock.lock();
			return content.containsKey(key);
		} finally {
			readLock.unlock();
		}
	}
635248
public boolean containsKey(Object key) {
	int k = checkKey(key);
	int index = Arrays.binarySearch(keyIndices, k);
	return index >= 0;
    }
192986
public boolean exists(Value keyValue) {
		Key subKey = makeSubKey(keyValue);
		return client.exists(this.policy, subKey);
	}
408728
public boolean containsAttr(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetAttr().getMap().containsKey(key);
  }
774002
@Override
    public boolean containsValue(Object value) {
        for (V v : values()) {
            if (v.equals(value)) {
                return true;
            }
        }
        return false;
    }
683116
public boolean containsKey(Object key) {
		// the key is a direct hit from our cache
		if(cache.containsKey(key))
			return true;
		// the key is a direct hit from our hashmap
		if(container.containsKey(key))
			return true;

		// check if the requested key is a matching string of a regex key from our container
		Iterator<String> regexKeys = container.keySet().iterator();
		while(regexKeys.hasNext()) {
			if(Pattern.matches(regexKeys.next(), (String) key))
				return true;
		}
		
		// if the three previous tests yield no result, the key does not exist
		return false;
	}
541855
public boolean containsValues(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetValues().getMap().containsKey(key);
  }
60952
public boolean isValueExistForKey(String key) {
		boolean isValueExists;
		try {
			String string = getString(key, "");
			isValueExists = !string.equalsIgnoreCase("");
		} catch (ClassCastException e) {
			try {
				int anInt = getInt(key, 0);
				isValueExists = anInt != 0;
			} catch (ClassCastException e1) {
				try {
					long aLong = getLong(key, 0);
					isValueExists = aLong != 0;
				} catch (ClassCastException e2) {
					try {
						float aFloat = getFloat(key, 0f);
						isValueExists = aFloat != 0;
					} catch (ClassCastException e3) {
						try {
							boolean aBoolean = getBoolean(key, false);
							isValueExists = !aBoolean;
						} catch (Exception e4) {
							isValueExists = false;
							e.printStackTrace();
						}
					}

				}

			}
		} catch (Exception e) {
			isValueExists = false;
		}
		return isValueExists;
	}
583400
public boolean set(String key, V value)
    {
        int index = exactMatchSearch(key);
        if (index >= 0)
        {
            v[index] = value;
            return true;
        }

        return false;
    }
382867
@Override
    public final boolean has(final String key) {
        String result = this.obj.optString(key, null);
        return result != null;
    }