Lines Matching full:code
65 * Creates a <i>mutable</i>, empty {@code HashMap} instance.
70 * <p><b>Note:</b> if {@code K} is an {@code enum} type, use {@link
73 * @return a new, empty {@code HashMap}
80 * Creates a {@code HashMap} instance with enough capacity to hold the
84 * @return a new, empty {@code HashMap} with enough
85 * capacity to hold {@code expectedSize} elements without rehashing
86 * @throws IllegalArgumentException if {@code expectedSize} is negative
102 * {@code expectedSize} entries.
104 * @throws IllegalArgumentException if {@code expectedSize} is negative
112 * Creates a <i>mutable</i> {@code HashMap} instance with the same mappings as
118 * <p><b>Note:</b> if {@code K} is an {@link Enum} type, use {@link
122 * @return a new {@code HashMap} initialized with the mappings from
123 * {@code map}
131 * Creates a <i>mutable</i>, empty, insertion-ordered {@code LinkedHashMap}
137 * @return a new, empty {@code LinkedHashMap}
144 * Creates a <i>mutable</i>, insertion-ordered {@code LinkedHashMap} instance
151 * @return a new, {@code LinkedHashMap} initialized with the
152 * mappings from {@code map}
160 * Creates a <i>mutable</i>, empty {@code TreeMap} instance using the natural
166 * @return a new, empty {@code TreeMap}
174 * Creates a <i>mutable</i> {@code TreeMap} instance with the same mappings as
182 * @return a new {@code TreeMap} initialized with the mappings from {@code
183 * map} and using the comparator of {@code map}
190 * Creates a <i>mutable</i>, empty {@code TreeMap} instance using the given
193 * <p><b>Note:</b> if mutability is not required, use {@code
197 * @return a new, empty {@code TreeMap}
203 // following code from being compiled:
210 * Creates an {@code EnumMap} instance.
213 * @return a new, empty {@code EnumMap}
220 * Creates an {@code EnumMap} with the same mappings as the specified map.
222 * @param map the map from which to initialize this {@code EnumMap}
223 * @return a new {@code EnumMap} initialized with the mappings from {@code
225 * @throws IllegalArgumentException if {@code m} is not an {@code EnumMap}
234 * Creates an {@code IdentityHashMap} instance.
236 * @return a new, empty {@code IdentityHashMap}
248 * when accessing any of its collection views: <pre> {@code
279 * <p>Since this method uses {@code HashMap} instances internally, the keys of
284 * mappings, call {@code left.equals(right)} instead of this method.
440 * @param values the values to use when constructing the {@code Map}
442 * @return a map mapping the result of evaluating the function {@code
444 * @throws IllegalArgumentException if {@code keyFunction} produces the same
446 * @throws NullPointerException if any elements of {@code values} is null, or
447 * if {@code keyFunction} produces {@code null} for any value
462 * Creates an {@code ImmutableMap<String, String>} from a {@code Properties}
463 * instance. Properties normally derive from {@code Map<Object, Object>}, but
465 * a plain-old-{@code Map} out of a {@code Properties}.
467 * @param properties a {@code Properties} object to be converted
469 * {@code properties}
470 * @throws ClassCastException if any key in {@code Properties} is not a
471 code String}
472 * @throws NullPointerException if any key or value in {@code Properties} is
518 * This also has the side-effect of redefining {@code equals} to comply with
605 * views, result in an {@code UnsupportedOperationException}.
660 * Implements {@code Collection.contains} safely for forwarding collections of
661 * map entries. If {@code o} is an instance of {@code Map.Entry}, it is
665 * <p>Note that {@code c} is the backing (delegate) collection, rather than
669 * @param o the object that might be contained in {@code c}
670 * @return {@code true} if {@code c} contains {@code o}
680 * Implements {@code Collection.remove} safely for forwarding collections of
681 * map entries. If {@code o} is an instance of {@code Map.Entry}, it is
685 * <p>Note that {@code c} is backing (delegate) collection, rather than the
689 * @param o the object to remove from {@code c}
690 * @return {@code true} if {@code c} was changed
702 * example, the code:
703 * <pre> {@code
714 * ... prints {@code {a=2.0, b=3.0}}.
731 * {@code Map.toString()}. For this to perform well, {@code function} should
848 * Returns a map containing the mappings in {@code unfiltered} whose keys
849 * satisfy a predicate. The returned map is a live view of {@code unfiltered};
852 * <p>The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
853 * values()} views have iterators that don't support {@code remove()}, but all
854 * other methods are supported by the map and its views. The map's {@code
855 * put()} and {@code putAll()} methods throw an {@link
859 * <p>When methods such as {@code removeAll()} and {@code clear()} are called
863 * <p>The returned map isn't threadsafe or serializable, even if {@code
866 * <p>Many of the filtered map's methods, such as {@code size()},
886 * Returns a map containing the mappings in {@code unfiltered} whose values
887 * satisfy a predicate. The returned map is a live view of {@code unfiltered};
890 * <p>The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
891 * values()} views have iterators that don't support {@code remove()}, but all
897 * <p>When methods such as {@code removeAll()} and {@code clear()} are called
901 * <p>The returned map isn't threadsafe or serializable, even if {@code
904 * <p>Many of the filtered map's methods, such as {@code size()},
921 * Returns a map containing the mappings in {@code unfiltered} that satisfy a
922 * predicate. The returned map is a live view of {@code unfiltered}; changes
925 * <p>The resulting map's {@code keySet()}, {@code entrySet()}, and {@code
926 * values()} views have iterators that don't support {@code remove()}, but all
927 * other methods are supported by the map and its views. The map's {@code
928 * put()} and {@code putAll()} methods throw an {@link
934 * <p>When methods such as {@code removeAll()} and {@code clear()} are called
938 * <p>The returned map isn't threadsafe or serializable, even if {@code
941 * <p>Many of the filtered map's methods, such as {@code size()},
955 * Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when
1138 * input to {@code Entry.setValue()}.
1257 * {@code AbstractMap} extension that implements {@link #isEmpty()} as {@code
1258 * entrySet().isEmpty()} instead of {@code size() == 0} to speed up
1259 * implementations where {@code size()} is O(n), and it delegates the {@code
1269 * is invoked at most once on a given map, at the time when {@code
1323 * Returns {@code true} if this map contains no key-value mappings.
1325 * <p>The implementation returns {@code entrySet().isEmpty()}.
1327 * @return {@code true} if this map contains no key-value mappings
1338 * Delegates to {@link Map#get}. Returns {@code null} on {@code
1350 * Delegates to {@link Map#containsKey}. Returns {@code false} on {@code
