/** * Stores the contents of a map in an output stream, as part of serialization. It does not support * concurrent maps whose content may change while the method is running. * * <p>The serialized output consists of the number of entries, first key, first value, second key, * second value, and so on. */ static <K, V> void writeMap(Map<K, V> map, ObjectOutputStream stream) throws IOException { stream.writeInt(map.size()); for (Map.Entry<K, V> entry : map.entrySet()) { stream.writeObject(entry.getKey()); stream.writeObject(entry.getValue()); } }
private void innerUpdateEndOffsets(final Map<TopicPartition, Long> newOffsets, final boolean replace) { for (final Map.Entry<TopicPartition, Long> entry : newOffsets.entrySet()) { List<Long> offsets = endOffsets.get(entry.getKey()); if (replace || offsets == null) { offsets = new ArrayList<>(); } offsets.add(entry.getValue()); endOffsets.put(entry.getKey(), offsets); } }
private Map<String, List<LazyHeaderFactory>> copyHeaders() { Map<String, List<LazyHeaderFactory>> result = new HashMap<>(headers.size()); for (Map.Entry<String, List<LazyHeaderFactory>> entry : headers.entrySet()) { @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops") List<LazyHeaderFactory> valueCopy = new ArrayList<>(entry.getValue()); result.put(entry.getKey(), valueCopy); } return result; }
/** * Match the provided column names and values with the list of columns used. * @param inParameters the parameter names and values */ public List<Object> matchInParameterValuesWithInsertColumns(Map<String, ?> inParameters) { List<Object> values = new ArrayList<>(inParameters.size()); for (String column : this.tableColumns) { Object value = inParameters.get(column); if (value == null) { value = inParameters.get(column.toLowerCase()); if (value == null) { for (Map.Entry<String, ?> entry : inParameters.entrySet()) { if (column.equalsIgnoreCase(entry.getKey())) { value = entry.getValue(); break; } } } } values.add(value); } return values; }
@CanIgnoreReturnValue private Map<R, V> removeColumn(Object column) { Map<R, V> output = new LinkedHashMap<>(); Iterator<Entry<R, Map<C, V>>> iterator = backingMap.entrySet().iterator(); while (iterator.hasNext()) { Entry<R, Map<C, V>> entry = iterator.next(); V value = entry.getValue().remove(column); if (value != null) { output.put(entry.getKey(), value); if (entry.getValue().isEmpty()) { iterator.remove(); } } } return output; }
public void testEntrySetSetValueSameValue() { // TODO: Investigate the extent to which, in practice, maps that support // put() also support Entry.setValue(). if (!supportsPut) { return; } final Map<K, V> map; try { map = makePopulatedMap(); } catch (UnsupportedOperationException e) { return; } Set<Entry<K, V>> entrySet = map.entrySet(); Entry<K, V> entry = entrySet.iterator().next(); final V oldValue = entry.getValue(); final V returnedValue = entry.setValue(oldValue); assertEquals(oldValue, returnedValue); assertTrue(entrySet.contains(mapEntry(entry.getKey(), oldValue))); assertEquals(oldValue, map.get(entry.getKey())); assertInvariants(map); }
@Test public void testGetEnvironmentVariables() { Configuration testConf = new Configuration(); testConf.setString("yarn.application-master.env.LD_LIBRARY_PATH", "/usr/lib/native"); Map<String, String> res = Utils.getEnvironmentVariables("yarn.application-master.env.", testConf); Assert.assertEquals(1, res.size()); Map.Entry<String, String> entry = res.entrySet().iterator().next(); Assert.assertEquals("LD_LIBRARY_PATH", entry.getKey()); Assert.assertEquals("/usr/lib/native", entry.getValue()); }
static <T extends StandardTable<Object, Object, Object>> T populate( SerializationStreamReader reader, T table) throws SerializationException { Map<?, ?> hashMap = (Map<?, ?>) reader.readObject(); for (Entry<?, ?> row : hashMap.entrySet()) { table.row(row.getKey()).putAll((Map<?, ?>) row.getValue()); } return table; }
@Override public BenchmarkResultHook addResults(Map<String, Long> results) { requireNonNull(results, "results is null"); for (Entry<String, Long> entry : results.entrySet()) { Long currentSum = resultsSum.get(entry.getKey()); if (currentSum == null) { currentSum = 0L; } resultsSum.put(entry.getKey(), currentSum + entry.getValue()); } resultsCount++; return this; }
private Map<String, Class<?>> toClassMap(Map<String, ?> map) throws ClassNotFoundException { Map<String, Class<?>> result = new LinkedHashMap<>(map.size()); for (Map.Entry<String, ?> entry : map.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); Class<?> type; if (value instanceof Class) { type = (Class<?>) value; } else if (value instanceof String) { String className = (String) value; type = ClassUtils.forName(className, this.beanClassLoader); } else { throw new IllegalArgumentException("Unknown value [" + value + "] - expected String or Class"); } result.put(key, type); } return result; }
public static boolean mapEquals(Map<?, ?> map1, Map<?, ?> map2) { if (map1 == null && map2 == null) { return true; } if (map1 == null || map2 == null) { return false; } if (map1.size() != map2.size()) { return false; } for (Map.Entry<?, ?> entry : map1.entrySet()) { Object key = entry.getKey(); Object value1 = entry.getValue(); Object value2 = map2.get(key); if (!objectEquals(value1, value2)) { return false; } } return true; }
public void testFilteredValuesIllegalSetValue() { Map<String, Integer> unfiltered = createUnfiltered(); Map<String, Integer> filtered = Maps.filterValues(unfiltered, EVEN); filtered.put("a", 2); filtered.put("b", 4); assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered); Entry<String, Integer> entry = filtered.entrySet().iterator().next(); try { entry.setValue(5); fail(); } catch (IllegalArgumentException expected) { } assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered); }