How to use

contains

method

in

java.util.List

public void addConfiguration(Configuration configuration) {
  if (configList.contains(configuration)) {
    return;
  }
  this.configList.add(configuration);
}

 @Override
 public Boolean apply(Constructor<?> input) {
  return asList(input.getParameterTypes()).contains(String.class);
 }
})

/**
 * Filter the list of requested WebSocket extensions.
 * <p>As of 4.1, the default implementation of this method filters the list to
 * leave only extensions that are both requested and supported.
 * @param request the current request
 * @param requestedExtensions the list of extensions requested by the client
 * @param supportedExtensions the list of extensions supported by the server
 * @return the selected extensions or an empty list
 */
protected List<WebSocketExtension> filterRequestedExtensions(ServerHttpRequest request,
    List<WebSocketExtension> requestedExtensions, List<WebSocketExtension> supportedExtensions) {
  List<WebSocketExtension> result = new ArrayList<>(requestedExtensions.size());
  for (WebSocketExtension extension : requestedExtensions) {
    if (supportedExtensions.contains(extension)) {
      result.add(extension);
    }
  }
  return result;
}

@NonNull
private synchronized List<Entry<?, ?>> getOrAddEntryList(@NonNull String bucket) {
 if (!bucketPriorityList.contains(bucket)) {
  // Add this unspecified bucket as a low priority bucket.
  bucketPriorityList.add(bucket);
 }
 List<Entry<?, ?>> entries = decoders.get(bucket);
 if (entries == null) {
  entries = new ArrayList<>();
  decoders.put(bucket, entries);
 }
 return entries;
}

  private void pickAnycastTargets(List<Address> anycast_targets) {
    int index=dests.indexOf(local_addr);
    for(int i=index + 1; i < index + 1 + anycast_count; i++) {
      int new_index=i % dests.size();
      Address tmp=dests.get(new_index);
      if(!anycast_targets.contains(tmp))
        anycast_targets.add(tmp);
    }
  }
}

public synchronized void subscribe(ClientIdentity clientIdentity) throws CanalMetaManagerException {
  List<ClientIdentity> clientIdentitys = destinations.get(clientIdentity.getDestination());
  if (clientIdentitys.contains(clientIdentity)) {
    clientIdentitys.remove(clientIdentity);
  }
  clientIdentitys.add(clientIdentity);
}

assertTrue(parameterNames.contains("getField"));
assertEquals("value3", request.getParameter("field3"));
List<String> parameterValues = Arrays.asList(request.getParameterValues("field3"));
assertEquals(1, parameterValues.size());
assertTrue(parameterValues.contains("value3"));
assertEquals("value4", request.getParameter("field4"));
parameterValues = Arrays.asList(request.getParameterValues("field4"));
assertEquals(2, parameterValues.size());
assertTrue(parameterValues.contains("value4"));
assertTrue(parameterValues.contains("value5"));
assertEquals("value4", request.getParameter("field4"));
assertEquals("getValue", request.getParameter("getField"));
assertEquals(3, parameterMapKeys.size());
assertTrue(field4Index != -1);
assertTrue(getFieldIndex != -1);
parameterValues = Arrays.asList((String[]) parameterMapValues.get(field3Index));
assertEquals(1, parameterValues.size());
assertTrue(parameterValues.contains("value3"));
parameterValues = Arrays.asList((String[]) parameterMapValues.get(field4Index));
assertEquals(2, parameterValues.size());
assertTrue(parameterValues.contains("value4"));
assertTrue(parameterValues.contains("value5"));
parameterValues = Arrays.asList((String[]) parameterMapValues.get(getFieldIndex));
assertEquals(1, parameterValues.size());
assertTrue(parameterValues.contains("getValue"));

 List<?> peerProtocols = (List) args[0];
 for (int i = 0, size = peerProtocols.size(); i < size; i++) {
  String protocol = (String) peerProtocols.get(i);
  if (protocols.contains(protocol)) {
   return selected = protocol;
 return selected = protocols.get(0); // On no intersection, try peer's first protocol.
} else if ((methodName.equals("protocolSelected") || methodName.equals("selected"))
  && args.length == 1) {

@Test
public void normal() {
  List<Integer> list = new VolatileSizeArrayList<Integer>();
  assertEquals(0, list.size());
  assertFalse(list.contains(1));
  assertFalse(list.remove((Integer)1));
  assertTrue(list.contains(2));
  assertFalse(list.remove((Integer)10));
  assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7), list);
  assertFalse(list.isEmpty());
  assertEquals(7, list.size());
  assertFalse(list.retainAll(Arrays.asList(1, 2, 3, 4, 5, 6, 7)));
  assertEquals(7, list.size());
    assertEquals(i, list.get(i - 1).intValue());
  assertFalse(list.equals(list3));
  list3.add(7);
  assertTrue(list3.equals(list));
  assertTrue(list.equals(list3));

private static boolean validParameters(String methodAnnotation, Class[] parameterTypes) {
 List<Class<?>> localMapping = mapping.get(methodAnnotation.replace("@", ""));
 if (localMapping == null) {
  return false;
 }
 for (Class<?> parameterType : parameterTypes) {
  if (!localMapping.contains(parameterType)) {
   return false;
  }
 }
 return true;
}

@VisibleForTesting
protected static void mergeParentProperties(Map<String, String> childProps, Map<String, String> parentProps) {
 for (Map.Entry<String, String> entry : parentProps.entrySet()) {
  String key = entry.getKey();
  if ((!childProps.containsKey(key) || childProps.get(key).equals(entry.getValue()))
   && !NON_HERITED_PROPERTIES_FOR_CHILD.contains(key)) {
   childProps.put(entry.getKey(), entry.getValue());
  }
 }
}

/**
 * Test Filtering and limit to depth 1
 */
@Test
public void testFilterAndLimitB() {
  final List<File> results = new TestFileFinder(NOT_SVN, 1).find(javaDir);
  assertEquals("[B] Result Size", 2, results.size());
  assertTrue("[B] Start Dir",   results.contains(javaDir));
  assertTrue("[B] Org Dir",     results.contains(orgDir));
}

@Override
public void addChangeListener(ConfigChangeListener listener, Set<String> interestedKeys, Set<String> interestedKeyPrefixes) {
 if (!m_listeners.contains(listener)) {
  m_listeners.add(listener);
  if (interestedKeys != null && !interestedKeys.isEmpty()) {
   m_interestedKeys.put(listener, Sets.newHashSet(interestedKeys));
  }
  if (interestedKeyPrefixes != null && !interestedKeyPrefixes.isEmpty()) {
   m_interestedKeyPrefixes.put(listener, Sets.newHashSet(interestedKeyPrefixes));
  }
 }
}

  @Override
  public void adjustSqlDigest(List<MeasureDesc> measureDescs, SQLDigest sqlDigest) {
    for (SQLCall call : sqlDigest.aggrSqlCalls) {
      if (FUNC_INTERSECT_COUNT_DISTINCT.equals(call.function)) {
        TblColRef col = (TblColRef) call.args.get(1);
        if (!sqlDigest.groupbyColumns.contains(col))
          sqlDigest.groupbyColumns.add(col);
      }
    }
  }
}

@Test
public void test() {
  assertTrue(Arrays.asList(applicationContext.getEnvironment().getActiveProfiles()).contains(
    getClass().getSimpleName().toLowerCase()));
}

public synchronized void setBucketPriorityList(@NonNull List<String> buckets) {
 List<String> previousBuckets = new ArrayList<>(bucketPriorityList);
 bucketPriorityList.clear();
 bucketPriorityList.addAll(buckets);
 for (String previousBucket : previousBuckets) {
  if (!buckets.contains(previousBucket)) {
   // Keep any buckets from the previous list that aren't included here, but but them at the
   // end.
   bucketPriorityList.add(previousBucket);
  }
 }
}

@Test
public void noCrossBoundaryFusion() {
  for (int i = 0; i < 500; i++) {
    .assertValueCount(1);
    List<Object> list = to.values().get(0);
    assertTrue(list.toString(), list.contains("RxSi"));
    assertTrue(list.toString(), list.contains("RxCo"));

@CollectionSize.Require(absent = {ZERO, ONE})
public void testSubList_contains() {
 List<E> list = getList();
 int size = getNumElements();
 List<E> copy = list.subList(0, size);
 List<E> head = list.subList(0, size - 1);
 List<E> tail = list.subList(1, size);
 assertTrue(copy.contains(list.get(0)));
 assertTrue(head.contains(list.get(0)));
 assertTrue(tail.contains(list.get(1)));
 // The following assumes all elements are distinct.
 assertTrue(copy.contains(list.get(size - 1)));
 assertTrue(head.contains(list.get(size - 2)));
 assertTrue(tail.contains(list.get(size - 1)));
 assertFalse(head.contains(list.get(size - 1)));
 assertFalse(tail.contains(list.get(0)));
}

 protected synchronized void addTypedEventListener(ActivitiEventListener listener, ActivitiEventType type) {
  List<ActivitiEventListener> listeners = typedListeners.get(type);
  if (listeners == null) {
   // Add an empty list of listeners for this type
   listeners = new CopyOnWriteArrayList<ActivitiEventListener>();
   typedListeners.put(type, listeners);
  }

  if (!listeners.contains(listener)) {
   listeners.add(listener);
  }
 }
}

List<Key> getCacheKeys() {
 if (!isCacheKeysSet) {
  isCacheKeysSet = true;
  cacheKeys.clear();
  List<LoadData<?>> loadData = getLoadData();
  //noinspection ForLoopReplaceableByForEach to improve perf
  for (int i = 0, size = loadData.size(); i < size; i++) {
   LoadData<?> data = loadData.get(i);
   if (!cacheKeys.contains(data.sourceKey)) {
    cacheKeys.add(data.sourceKey);
   }
   for (int j = 0; j < data.alternateKeys.size(); j++) {
    if (!cacheKeys.contains(data.alternateKeys.get(j))) {
     cacheKeys.add(data.alternateKeys.get(j));
    }
   }
  }
 }
 return cacheKeys;
}