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));
}

public V put(K key, V value) {
  typeCheck(key, value);
  return m.put(key, 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);
}

/**
 * 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);
}

/**
 * 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);
}

@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());
}

@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);

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));
}

                   Class<K> keyType,
                   Class<V> valueType) {
return new CheckedMap<>(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);
}

Javadoc

A dynamically typesafe view of a Map.

Most used methods

Popular in Java

Parsing JSON documents to java classes using gson
scheduleAtFixedRate (Timer)
getContentResolver (Context)
compareTo (BigDecimal)
Container (java.awt)
A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
InetAddress (java.net)
An Internet Protocol (IP) address. This can be either an IPv4 address or an IPv6 address, and in pra
Date (java.sql)
A class which can consume and produce dates in SQL Date format. Dates are represented in SQL as yyyy
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio

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