Implementações alternativas de um HashMap<Object, Object>?

saoj, você poderia ser mais claro sobre o intuito de uma implementação alternativa? Sinceramente eu não entendi.

Por exemplo, isso seria uma implementacão alternativa de um HashMap: http://javolution.org/target/site/apidocs/javolution/util/FastMap.html

Pena que não funciona direito então estou procurando outra.

A HashMap não me atende porque ela gera lixo para o GC a cada add and remove. Imagina usar isso num loop que é executado milhares de vezes por segundo?

Pra falar a verdade não achei nada então peguei o código fonte de HashMap e concertei ela.

void addEntry(final int hash, final K key, final V value, final int bucketIndex) {
		final Entry<K, V> e = table[bucketIndex];
		table[bucketIndex] = entryPool.get();
		table[bucketIndex].reset(hash, key, value, e);
		if (size++ >= threshold) {
			resize(2 * table.length);
		}
	}

final Entry<K, V> removeEntryForKey(final Object key) {
		final int hash = (key == null) ? 0 : hash(key.hashCode());
		final int i = indexFor(hash, table.length);
		Entry<K, V> prev = table[i];
		Entry<K, V> e = prev;

		while (e != null) {
			final Entry<K, V> next = e.next;
			Object k;
			if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
				modCount++;
				size--;
				if (prev == e) {
					table[i] = next;
				} else {
					prev.next = next;
				}
				e.recordRemoval(this);
				entryPool.release(e);
				return e; // no problem here!
			}
			prev = e;
			e = next;
		}

		return e;
	}

Entendi. É que na maioria das aplicações esse lixo a qual você se refere nem é levado em conta, geralmente é algo irrisório e que não impacta na performance. Pelo visto você deve tá criando maps gigantescos.

Mas, já desenrolou né, legal.

marlon patrick:

Entendi. É que na maioria das aplicações esse lixo a qual você se refere nem é levado em conta, geralmente é algo irrisório e que não impacta na performance. Pelo visto você deve tá criando maps gigantescos.

Mas, já desenrolou né, legal.

Sim. Só para aplicacões que não podem ter latencia nenhuma, e GC é uma grande latencia porque para tudo (stop-the-world).

Imagine o seguinte código:

Map<String, String> map = new HashMap<String, String>();

String s1 = "s1";
String s2 = "s2";

for(int i=0;i<10000000;i++) {
   map.put(s1, s2);
   map.remove(s1);
}

Isso vai gerar lixo pra caramba, ou seja, não tem como usar HashMap para sistemas low-latency. (Aí aparece um engracadinho falando para usar C++ ou RTSJ)