java.util.Collections$CheckedMap java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 OutputStreamWriter o =OutputStream out;new OutputStreamWriter(out)
OutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
HttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
Smart code suggestions by Tabnine
}

private void typeCheck(Object key, Object value) {
  if (key != null && !keyType.isInstance(key))
    throw new ClassCastException(badKeyMsg(key));
  if (value != null && !valueType.isInstance(value))
    throw new ClassCastException(badValueMsg(value));
}

@SuppressWarnings("unchecked")
public void putAll(Map<? extends K, ? extends V> t) {
  // Satisfy the following goals:
  // - good diagnostics in case of type mismatch
  // - all-or-nothing semantics
  // - protection from malicious t
  // - correct behavior if t is a concurrent map
  Object[] entries = t.entrySet().toArray();
  List<Map.Entry<K,V>> checked = new ArrayList<>(entries.length);
  for (Object o : entries) {
    Map.Entry<?,?> e = (Map.Entry<?,?>) o;
    Object k = e.getKey();
    Object v = e.getValue();
    typeCheck(k, v);
    checked.add(
      new AbstractMap.SimpleImmutableEntry<>((K) k, (V) v));
  }
  for (Map.Entry<K,V> e : checked)
    m.put(e.getKey(), e.getValue());
}

                   Class<K> keyType,
                   Class<V> valueType) {
return new CheckedMap<>(m, keyType, valueType);

                   Class<K> keyType,
                   Class<V> valueType) {
return new CheckedMap<>(m, keyType, valueType);

@SuppressWarnings("unchecked")
public void putAll(Map<? extends K, ? extends V> t) {
  // Satisfy the following goals:
  // - good diagnostics in case of type mismatch
  // - all-or-nothing semantics
  // - protection from malicious t
  // - correct behavior if t is a concurrent map
  Object[] entries = t.entrySet().toArray();
  List<Map.Entry<K,V>> checked = new ArrayList<>(entries.length);
  for (Object o : entries) {
    Map.Entry<?,?> e = (Map.Entry<?,?>) o;
    Object k = e.getKey();
    Object v = e.getValue();
    typeCheck(k, v);
    checked.add(
      new AbstractMap.SimpleImmutableEntry<>((K) k, (V) v));
  }
  for (Map.Entry<K,V> e : checked)
    m.put(e.getKey(), e.getValue());
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

public V put(K key, V value) {
  typeCheck(key, value);
  return m.put(key, value);
}

public V put(K key, V value) {
  typeCheck(key, value);
  return m.put(key, value);
}

private void typeCheck(Object key, Object value) {
  if (key != null && !keyType.isInstance(key))
    throw new ClassCastException(badKeyMsg(key));
  if (value != null && !valueType.isInstance(value))
    throw new ClassCastException(badValueMsg(value));
}

/**
 * Returns a dynamically typesafe view of the specified map. Trying to
 * insert an element of the wrong type into this map throws a
 * {@code ClassCastException}. At creation time the types in {@code m} are
 * not checked for correct type.
 *
 * @param m
 *            the map to be wrapped in a typesafe map.
 * @param keyType
 *            the type of the keys permitted to insert.
 * @param valueType
 *            the type of the values permitted to insert.
 * @return a typesafe map.
 */
public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType,
    Class<V> valueType) {
  return new CheckedMap<K, V>(m, keyType, valueType);
}

Javadoc

A dynamically typesafe view of a Map.

Most used methods

Popular in Java

Parsing JSON documents to java classes using gson
scheduleAtFixedRate (Timer)
getSystemService (Context)
findViewById (Activity)
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
Hashtable (java.util)
A plug-in replacement for JDK1.5 java.util.Hashtable. This version is based on org.cliffc.high_scale
TimerTask (java.util)
The TimerTask class represents a task to run at a specified time. The task may be run once or repeat
Executors (java.util.concurrent)
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
LoggerFactory (org.slf4j)
The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo
Top 25 Plugins for Webstorm

How to useCollections$CheckedMap in java.util

Best Java code snippets using java.util.Collections$CheckedMap (Showing top 16 results out of 315)

How to use
Collections$CheckedMap
in
java.util