How to use

put

method

in

org.apache.commons.collections4.MultiMap

/**
 * Provides checking for adding the index.
 *
 * @param object the object to index
 * @throws IllegalArgumentException if the object maps to an existing key and the index
 *   enforces a uniqueness constraint
 */
private void addToIndex(final C object) {
  final K key = keyTransformer.transform(object);
  if (uniqueIndex && index.containsKey(key)) {
    throw new IllegalArgumentException("Duplicate key in uniquely indexed collection.");
  }
  index.put(key, object);
}

/**
 * Populates a MultiMap using the supplied <code>Transformer</code>s to transform the elements
 * into keys and values.
 *
 * @param <K>  the key type
 * @param <V>  the value type
 * @param <E>  the type of object contained in the {@link Iterable}
 * @param map the <code>MultiMap</code> to populate.
 * @param elements the <code>Iterable</code> containing the input values for the map.
 * @param keyTransformer the <code>Transformer</code> used to transform the element into a key value
 * @param valueTransformer the <code>Transformer</code> used to transform the element into a value
 * @throws NullPointerException if the map, collection or transformers are null
 */
public static <K, V, E> void populateMap(final MultiMap<K, V> map, final Iterable<? extends E> elements,
                     final Transformer<E, K> keyTransformer,
                     final Transformer<E, V> valueTransformer) {
  final Iterator<? extends E> iter = elements.iterator();
  while (iter.hasNext()) {
    final E temp = iter.next();
    map.put(keyTransformer.transform(temp), valueTransformer.transform(temp));
  }
}

private void appendHeader(String name, Object value) {
  if (responseExpirationCalculator != null) {
    responseExpirationCalculator.addHeader(name, value);
  }
  headers.put(name, value);
}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
  in.defaultReadObject();
  headers = new MultiValueMap();
  Iterator iter = serializableHeadersBackingList.entrySet().iterator();
  while (iter.hasNext()) {
    Map.Entry entry = (Entry) iter.next();
    Collection c = (Collection) entry.getValue();
    for (Iterator ic = c.iterator(); ic.hasNext();) {
      headers.put(entry.getKey(), ic.next());
    }
  }
  serializableHeadersBackingList = null;
}

private void replaceHeader(String name, Object value) {
  if (responseExpirationCalculator != null) {
    responseExpirationCalculator.addHeader(name, value);
  }
  headers.remove(name);
  headers.put(name, value);
}

public CMUdict(Reader reader)
  throws IOException, PronouncingDictionaryException
{
  String line;
  int lineNumber = 0;
  final Pattern cmuPattern = Pattern.compile("(.+?)(\\(\\d+\\))?  (.*)");
  final BufferedReader bufRead = new BufferedReader(reader);
  dict = new MultiValueMap();
  while ((line = bufRead.readLine()) != null) {
    lineNumber++;
    if (line.length() < 3) {
      throw new PronouncingDictionaryException(
          "syntax error on line " + lineNumber);
    }
    // Skip comment lines
    if (line.substring(0, 3).equals(";;;")) {
      continue;
    }
    Matcher m = cmuPattern.matcher(line);
    if (!m.find()) {
      throw new PronouncingDictionaryException(
          "syntax error on line " + lineNumber);
    }
    dict.put(m.group(1), m.group(3));
  }
  bufRead.close();
}

for (Element grapheme : graphemes) {
  for (Element phoneme : phonemes) {
    dict.put(grapheme.getText(), phoneme.getText());

  @Test
  public void replay() throws Exception {
    // GIVEN
    MultiMap headers = new MultiValueMap();
    headers.put(CacheConstants.HEADER_CACHE_CONTROL, CacheConstants.HEADER_VALUE_NO_CACHE);

    when(response.containsHeader(CacheConstants.HEADER_CACHE_CONTROL)).thenReturn(true);

    cachedEntry = new ContentCachedEntry("contentType", "characterEncoding", 0, headers, 0l, "originalUrl", 0) {
      @Override
      protected void writeContent(HttpServletRequest request, HttpServletResponse response, FilterChain chain, boolean acceptsGzipEncoding) throws IOException, ServletException {
      }

      @Override
      protected boolean canServeGzipContent() {
        return false;
      }
    };
    // WHEN
    cachedEntry.replay(request, response, null);

    // THEN
    verify(response).setHeader(CacheConstants.HEADER_CACHE_CONTROL, CacheConstants.HEADER_VALUE_NO_CACHE);
  }
}