How to use

put

method

in

java.util.HashMap

 private static <K, V> HashMap<K, V> newHashMap(
   Collection<? extends Entry<? extends K, ? extends V>> entries) {
  HashMap<K, V> map = new HashMap<>();
  for (Entry<? extends K, ? extends V> entry : entries) {
   map.put(entry.getKey(), entry.getValue());
  }
  return map;
 }
}

public final int[] getIntArray(int argLength) {
 if (!aints.containsKey(argLength)) {
  aints.put(argLength, new int[argLength]);
 }
 assert (aints.get(argLength).length == argLength) : "Array not built with correct length";
 return aints.get(argLength);
}

void putSanitizeName(RType rType, String sanitizeName, String rawName) {
  HashMap<String, String> sanitizeNameMap;
  if (!sanitizeTypeMap.containsKey(rType)) {
    sanitizeNameMap = new HashMap<>();
    sanitizeTypeMap.put(rType, sanitizeNameMap);
  } else {
    sanitizeNameMap = sanitizeTypeMap.get(rType);
  }
  if (!sanitizeNameMap.containsKey(sanitizeName)) {
    sanitizeNameMap.put(sanitizeName, rawName);
  }
}

public static <V> HashMap<V, Integer> multi_set(List<V> list) {
  HashMap<V, Integer> rtn = new HashMap<>();
  for (V v : list) {
    int cnt = 1;
    if (rtn.containsKey(v)) {
      cnt += rtn.get(v);
    }
    rtn.put(v, cnt);
  }
  return rtn;
}

private static Map<String, Object> createVersions() {
 ArrayList<String> versions = new ArrayList<String>();
 versions.add(VERSION);
 HashMap<String, Object> res = new HashMap<String, Object>();
 res.put("supportedVersions", versions);
 res.put("version", VERSION);
 return Collections.unmodifiableMap(res);
}

public static void registerMetricsConsumer(Map<String, Object> conf, Class klass, Object argument, long parallelismHint) {
  HashMap<String, Object> m = new HashMap<>();
  m.put("class", klass.getCanonicalName());
  m.put("parallelism.hint", parallelismHint);
  m.put("argument", argument);
  List l = (List) conf.get(TOPOLOGY_METRICS_CONSUMER_REGISTER);
  if (l == null) {
    l = new ArrayList();
  }
  l.add(m);
  conf.put(TOPOLOGY_METRICS_CONSUMER_REGISTER, l);
}

 HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put (1, "Mark");
map.put (2, "Tarryn");
List<String> list = new ArrayList<String>(map.values());
for (String s : list) {
  System.out.println(s);
}

private HashMap<String/* brokerName */, Set<MessageQueue>> buildProcessQueueTableByBrokerName() {
  HashMap<String, Set<MessageQueue>> result = new HashMap<String, Set<MessageQueue>>();
  for (MessageQueue mq : this.processQueueTable.keySet()) {
    Set<MessageQueue> mqs = result.get(mq.getBrokerName());
    if (null == mqs) {
      mqs = new HashSet<MessageQueue>();
      result.put(mq.getBrokerName(), mqs);
    }
    mqs.add(mq);
  }
  return result;
}

HashMap<String, Double> map = new HashMap<String, Double>();
ValueComparator bvc = new ValueComparator(map);
TreeMap<String, Double> sorted_map = new TreeMap<String, Double>(bvc);
map.put("A", 99.5);
map.put("B", 67.4);
map.put("C", 67.4);
map.put("D", 67.3);
System.out.println("unsorted map: " + map);
sorted_map.putAll(map);
System.out.println("results: " + sorted_map);

private int add(Word w) {
  Integer id = index.get(w.word);
  if(id==null){
    id = words.size();
    words.add(w);
    index.put(w.word, id);
  }
  return id;
}

@Override
public Map<Errors, Integer> errorCounts() {
  HashMap<Errors, Integer> counts = new HashMap<>();
  for (ReplicaElectionResult result : data.replicaElectionResults()) {
    for (PartitionResult partitionResult : result.partitionResult()) {
      Errors error = Errors.forCode(partitionResult.errorCode());
      counts.put(error, counts.getOrDefault(error, 0) + 1);
    }
  }
  return counts;
}

public void setEnabled (ParticleEmitter emitter, boolean enabled) {
  ParticleData data = particleData.get(emitter);
  if (data == null) particleData.put(emitter, data = new ParticleData());
  data.enabled = enabled;
  emitter.reset();
}

 List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

Map<String,String> codes = new HashMap<String,String>(){{ 
 put("1","one"); 
 put("2","two");
}};

public void buildRunningStats(HashMap<String, String> stats) {
  Iterator<Entry<Integer, Long>> it = this.offsetTable.entrySet().iterator();
  while (it.hasNext()) {
    Entry<Integer, Long> next = it.next();
    int queueId = delayLevel2QueueId(next.getKey());
    long delayOffset = next.getValue();
    long maxOffset = this.defaultMessageStore.getMaxOffsetInQueue(SCHEDULE_TOPIC, queueId);
    String value = String.format("%d,%d", delayOffset, maxOffset);
    String key = String.format("%s_%d", RunningStats.scheduleMessageOffset.name(), next.getKey());
    stats.put(key, value);
  }
}

public static <V> HashMap<V, Integer> multi_set(List<V> list) {
  HashMap<V, Integer> rtn = new HashMap<V, Integer>();
  for (V v : list) {
    int cnt = 1;
    if (rtn.containsKey(v)) {
      cnt += rtn.get(v);
    }
    rtn.put(v, cnt);
  }
  return rtn;
}

private static Map<String, Object> createFormats() {
 ArrayList<String> formats = new ArrayList<String>();
 formats.add(MediaType.APPLICATION_JSON);
 HashMap<String, Object> res = new HashMap<String, Object>();
 res.put("responseTypes", formats);
 return Collections.unmodifiableMap(res);
}

private static Map<String, Object> sanitize(Map<String, Object> flatMap) {
  HashMap<String, Object> santizedMap = new HashMap<>();
  for (Map.Entry<String, Object> entry : flatMap.entrySet()) {
    santizedMap.put(entry.getKey().toLowerCase(), entry.getValue());
  }
  return santizedMap;
}

public static void registerMetricsConsumer(Map conf, Class klass, Object argument, long parallelismHint) {
  HashMap m = new HashMap();
  m.put("class", klass.getCanonicalName());
  m.put("parallelism.hint", parallelismHint);
  m.put("argument", argument);
  List l = (List) conf.get(TOPOLOGY_METRICS_CONSUMER_REGISTER);
  if (l == null) {
    l = new ArrayList();
  }
  l.add(m);
  conf.put(TOPOLOGY_METRICS_CONSUMER_REGISTER, l);
}

/**
 * <code><pre>
 * type ::= string
 *      ::= int
 * </code></pre>
 */
private void writeType(String type)
    throws IOException {
  flushIfFull();
  int len = type.length();
  if (len == 0) {
    throw new IllegalArgumentException("empty type is not allowed");
  }
  if (_typeRefs == null)
    _typeRefs = new HashMap();
  Integer typeRefV = (Integer) _typeRefs.get(type);
  if (typeRefV != null) {
    int typeRef = typeRefV.intValue();
    writeInt(typeRef);
  } else {
    _typeRefs.put(type, Integer.valueOf(_typeRefs.size()));
    writeString(type);
  }
}

public final float[] getFloatArray(int argLength) {
 if (!afloats.containsKey(argLength)) {
  afloats.put(argLength, new float[argLength]);
 }
 assert (afloats.get(argLength).length == argLength) : "Array not built with correct length";
 return afloats.get(argLength);
}