Develop Reference

Java unique value map

I need a map with unique keys and also storing duplicate values only once. The interface will be the Map but I don't want that the same value use memory multiple times. For example:
In a normal Map implementation like HashMap suposing value.equals(value') and value.equals(value'') but value!=value' and value!=value' and value!=value'' if we:
put(key1, value);
put(key2, value');
put(key3, value'');
Then the value will be stored three times.
I tried to make my own implementation which looks like:
class MyMap2<K, V> extends HashMap<K, V> {
private Map<V, V> values;
public MyMap2() {
values = new HashMap<V, V>();
}
#Override
public V put(final K key, final V value) {
V v = values.get(value);
if (v == null) {
v = value;
values.put(v, v);
}
return super.put(key, v);
}
}
This implementation stores the value just one time (Please, note that I'm using the same value). But is there any Map which already implements this kind of data structure with get/put O(1)?
Please, note that BiMap is not useful because it will cause an error in case of duplicated values.

This implementation already promises constant time get/put operations. The worst case is when inserting a new value that has never been seen yet. In this case you will:
Attempt to find the value in the values map - O(1), since it's a HashMap.
Not find it, and put the value in the values map - O(1), since it's a HashMap.
Put the key-value pair in super - O(1), since it's a HashMap.
You find a better way of implementing this logic, but not by an order of magnitude.
EDIT:
Note that the implementation may put in super twice, which is just redundant. It can be tweaked to be slightly cleaner:
#Override
public V put(final K key, final V value) {
V v = values.get(value);
if (v == null) {
v = value
values.put(v, v);
}
return super.put(key, v);
}

This was already asked before.
Check out BiMap.

ArrayList sorting, application stuck

I have an ArrayList filled with words from a text file, that I need to sort by occurrence of words, from the most occurring to the less occurring. I copy the original ArrayList with the words to another Arraylist as well as adding on top the number of occurrences. So the word in the new ArrayList would look, for example:
"password:125" where "password" is the word and "125" is the number of occurrences in the ArrayList.
for (int i=0;i<sorter.size();i++) {
sorter2.add(sorter.get(i)+":"+Collections.frequency(sorter, sorter.get(i)));
}
Afterwards I sort the ArrayList with this class:
public class RepeatFormulaCounter implements Comparator<String> {
#Override
public int compare(String o1, String o2) {
if (findValue(o2) != findValue(o1)) {
return findValue(o2) - findValue(o1);
}
return o2.compareTo(o1);
}
public int findValue(String find){
int result=0;
String spliter[]=find.split(":");
result=Integer.parseInt(spliter[1]);
return result;
}
}
However as I have 5 text files filled with words which 3 of the files are around 45 000 words and 2 with more than 1 000 000, The files with around 45000 words are sorted and displayed without any problems, but when I start to sort the ones with more than 1 000 000 words the application gets stuck. Why does it happen? and how can I fix it?
Please notice I am using a GUI application to displaying it. And I am using 2 similar sort classes for other ways of sorting by different criteria's which display and perform without any problems.

Why do you store words as "password:125"? You are working in very inefficient way. You must use efficient data structure to store your word's statistics. Use Map interface and choose right implementation to store words with its occurrence.
Map<String, Integer> wordsMap = new HashMap<String,Double>();
/* Fill the wordsMap with data, then use this function to sort.
Fill and update value by key is simple:
wordsMap .put(key, 50); <-- put value
wordsMap .put(key, map.get(key) + 1); <--- update value
For example:
wordsMap .put("google", 0); <-- put value
wordsMap .put("google", map.get("google") + 1); <--- increment value by 1
*/
public static <K, V extends Comparable<? super V>> Map<K, V>
sortByValue( Map<K, V> map )
{
List<Map.Entry<K, V>> list =
new LinkedList<>( map.entrySet() );
Collections.sort( list, new Comparator<Map.Entry<K, V>>()
{
#Override
public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
{
return (o1.getValue()).compareTo( o2.getValue() );
}
} );
Map<K, V> result = new LinkedHashMap<>();
for (Map.Entry<K, V> entry : list)
{
result.put( entry.getKey(), entry.getValue() );
}
return result;
}
// sortByValue(wordsMap);
Additionally, you can read about classes Hashtable, LinkedHashMap, TreeMap and then choose the one with better performance. They implements the same Map interface, but has different asymptotics for internal implementation of put(), get() and other methods.
The Javadocs from Sun for each collection class will generally tell you exactly what you want.
HashMap, for example:
This implementation provides constant-time performance for the basic
operations (get and put), assuming the hash function disperses the
elements properly among the buckets. Iteration over collection views
requires time proportional to the "capacity" of the HashMap instance
(the number of buckets) plus its size (the number of key-value
mappings).
TreeMap:
This implementation provides guaranteed log(n) time cost for the
containsKey, get, put and remove operations.
TreeSet:
This implementation provides guaranteed log(n) time cost for the basic
operations (add, remove and contains).
Read more about this.
If it will be still slower then yours expectations, you can use multithreading. If you have processor with 8 cores, you can split your file to 8 peaces, count words in 8 threads, merge results, and then run sort.

Most likely a memory issue. Try increasing your jvm heap size. You make lots of temporary strings and your garbage collector will go crazy at large data sizes.

I think the problem might be outside of the code shown, but you could try to reduce object trashing by reducing the amount of find calls and then number of objects created (currently, each find call creates 3 new objects and you call find 4 times in compare):
#Override
public int compare(String o1, String o2) {
int f2 = findValue(o2);
int f1 = findValue(o1);
if (f2 != f1) {
return f2 - f1;
}
return o2.compareTo(o1);
}
public int findValue(String find){
int result = 0;
int cut = find.lastIndexOf(':');
result = Integer.parseInt(find.substring(cut + 1));
return result;
}
This can probably be improved some more by getting rid of substring...
Probably a better option would be to hand in the map that you use for counting to the comparator constructor, and then use it in the comparator:
public class CountComparator implements Comparator<String> {
Map<String, Integer> counts;
public CountComparator(Map<String, Integer> counts) {
this.counts = counts;
}
public int compare(String o1, String o2) {
int f2 = counts.get(o2);
int f1 = counts.get(o1);
if (f1 != f2) {
return f2 - f1;
}
return o2.compareTo(o1);
}
}

Make use of streams that were introduced in Java 8. They are great for processing data.
HashMap<String, Integer> occurences = new HashMap<>();
...
Stream<String> stream = occurences.entrySet().stream()
.sorted((a, b) -> b.getValue() - a.getValue())
.map(kv -> kv.getKey());
String[] sortedWords = stream.toArray(size -> new String[size]);

Is there any data structure that offers fast key/value access, but that is also ordered and can be accessed by a position index?

Basically, I need something like a TreeMap but that would allow me to get the element at the position X efficiently.

You can use a ListOrderedMap from Apache Commons Collections.
It gives you a get(int index) method to retrieve the key at position index on top of the usual Map methods.

A balanced tree can be used for both lookups by key and by index, both in O(log N) time, if you store a "size" field in each node which tracks how many key/value pairs are contained in the node and all its descendants.
The code for looking up a value by index would look something like this (in pseudocode):
def at(index)
if index == this.left.size
return this.value
else if index < this.left.size
return this.left.at(index)
else
return this.right.at(index - this.left.size - 1)

TreeMap get complexity is O(log n)
I guess it is not a concern in performance.
Also as i know array has O(1) but the your demands match with treemap.
The SortedMap Interface with TreeMap is suitable for you :).

It wouldn't be difficult to combine some data structures to provide this. Assuming there are no duplicates then the sketch below could work. If you do need to support duplicates then wrap your objects with something that provides unique hashes like the default Object class does.
I have no idea how you want use the positional data so I didn't add any methods that relate to reordering or iterating but it wouldn't be difficult. Sounds like the Apaches ListOrderedMap is a good choice too.
public class OrderedMap<K, V>{
private ArrayList<V> values;
private HashMap<K, V> map;
private HashMap<K, Integer> keysToIndices;
public OrderedMap(){
values = new ArrayList<>();
map = new HashMap<>();
keysToIndices = new HashMap<>();
}
public void put(K key, V value){
values.add(value);
map.put(key, value);
keysToIndices.put(key, values.size()-1);
}
public T get(K key){
return map.get(key);
}
public V remove(K key){
map.remove(key);
return values.remove(keysToIndices.remove(key))
}
}

Java HashMap: How to get a key and value by index?

I am trying to use a HashMap to map a unique string to a string ArrayList like this:
HashMap<String, ArrayList<String>>
Basically, I want to be able to access the keys by number, not by using the key's name. And I want to be able to access said key's value, to iterate over it. I'm imagining something like this:
for(all keys in my hashmap) {
for(int i=0; i < myhashmap.currentKey.getValue.size(); i++) {
// do things with the hashmaps elements
}
}
Is there an easy way to do this?

Here is the general solution if you really only want the first key's value
Object firstKey = myHashMap.keySet().toArray()[0];
Object valueForFirstKey = myHashMap.get(firstKey);

You can iterate over keys by calling map.keySet(), or iterate over the entries by calling map.entrySet(). Iterating over entries will probably be faster.
for (Map.Entry<String, List<String>> entry : map.entrySet()) {
List<String> list = entry.getValue();
// Do things with the list
}
If you want to ensure that you iterate over the keys in the same order you inserted them then use a LinkedHashMap.
By the way, I'd recommend changing the declared type of the map to <String, List<String>>. Always best to declare types in terms of the interface rather than the implementation.

HashMaps are not ordered, unless you use a LinkedHashMap or SortedMap. In this case, you may want a LinkedHashMap. This will iterate in order of insertion (or in order of last access if you prefer). In this case, it would be
int index = 0;
for ( Map.Entry<String,ArrayList<String>> e : myHashMap.iterator().entrySet() ) {
String key = e.getKey();
ArrayList<String> val = e.getValue();
index++;
}
There is no direct get(index) in a map because it is an unordered list of key/value pairs. LinkedHashMap is a special case that keeps the order.

Kotlin HashMap Answer
You can get key by index. Then get value by key.
val item = HashMap<String, String>() // Dummy HashMap.
val keyByIndex = item.keys.elementAt(0) // Get key by index. I selected "0".
val valueOfElement = item.getValue(keyByIndex) // Get value.

You can do:
for(String key: hashMap.keySet()){
for(String value: hashMap.get(key)) {
// use the value here
}
}
This will iterate over every key, and then every value of the list associated with each key.

A solution is already selected. However, I post this solution for those who want to use an alternative approach:
// use LinkedHashMap if you want to read values from the hashmap in the same order as you put them into it
private ArrayList<String> getMapValueAt(LinkedHashMap<String, ArrayList<String>> hashMap, int index)
{
Map.Entry<String, ArrayList<String>> entry = (Map.Entry<String, ArrayList<String>>) hashMap.entrySet().toArray()[index];
return entry.getValue();
}

for (Object key : data.keySet()) {
String lKey = (String) key;
List<String> list = data.get(key);
}

I came across the same problem, read a couple of answers from different related questions and came up with my own class.
public class IndexableMap<K, V> extends HashMap<K, V> {
private LinkedList<K> keyList = new LinkedList<>();
#Override
public V put(K key, V value) {
if (!keyList.contains(key))
keyList.add(key);
return super.put(key, value);
}
#Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
#Override
public void clear() {
keyList.clear();
super.clear();
}
public List<K> getKeys() {
return keyList;
}
public int getKeyIndex(K key) {
return keyList.indexOf(key);
}
public K getKeyAt(int index) {
if (keyList.size() > index)
return keyList.get(index);
return null;
}
public V getValueAt(int index) {
K key = getKeyAt(index);
if (key != null)
return get(key);
return null;
}
}
Example (types are differing from OPs question just for clarity):
Map<String, Double> myMap = new IndexableMap<>();
List<String> keys = myMap.getKeys();
int keyIndex = myMap.getKeyIndex("keyString");
String key = myMap.getKeyAt(2);
Double value myMap.getValueAt(2);
Keep in mind that it does not override any of the complex methods, so you will need to do this on your own if you want to reliably access one of these.
Edit: I made a change to the putAll() method, because the old one had a rare chance to cause HashMap and LinkedList being in different states.

Try this:
myhashmap.entrySet()
.forEach{
println(it.getKey())
println(it.getValue())
}
or if you want by index
myhashmap.entrySet()[0].getKey()
myhashmap.entrySet()[0].getValue()
myhashmap.entrySet()[1].getKey()
myhashmap.entrySet()[1].getValue()

HashMaps don't keep your key/value pairs in a specific order. They are ordered based on the hash that each key's returns from its Object.hashCode() method. You can however iterate over the set of key/value pairs using an iterator with:
for (String key : hashmap.keySet())
{
for (list : hashmap.get(key))
{
//list.toString()
}
}

If you don't care about the actual key, a concise way to iterate over all the Map's values would be to use its values() method
Map<String, List<String>> myMap;
for ( List<String> stringList : myMap.values() ) {
for ( String myString : stringList ) {
// process the string here
}
}
The values() method is part of the Map interface and returns a Collection view of the values in the map.

You can use Kotlin extension function
fun LinkedHashMap<String, String>.getKeyByPosition(position: Int) =
this.keys.toTypedArray()[position]
fun LinkedHashMap<String, String>.getValueByPosition(position: Int) =
this.values.toTypedArray()[position]

You'll need to create multiple HashMaps like this for example
Map<String, String> fruitDetails = new HashMap();
fruitDetails.put("Mango", "Mango is a delicious fruit!");
fruitDetails.put("Guava" "Guava is a delicious fruit!");
fruitDetails.put("Pineapple", "Pineapple is a delicious fruit!");
Map<String, String> fruitDetails2 = new HashMap();
fruitDetails2.put("Orange", "Orange is a delicious fruit!");
fruitDetails2.put("Banana" "Banana is a delicious fruit!");
fruitDetails2.put("Apple", "Apple is a delicious fruit!");
// STEP 2: Create a numeric key based HashMap containing fruitDetails so we can access them by index
Map<Integer, Map<String, String>> hashMap = new HashMap();
hashMap.put(0, fruitDetails);
hashMap.put(1, fruitDetails2);
// Now we can successfully access the fruitDetails by index like this
String fruit1 = hashMap.get(0).get("Guava");
String fruit2 = hashMap.get(1).get("Apple");
System.out.println(fruit1); // outputs: Guava is a delicious fruit!
System.out.println(fruit2); // outputs: Apple is a delicious fruit!

Java Class that implements Map and keeps insertion order?

I'm looking for a class in java that has key-value association, but without using hashes. Here is what I'm currently doing:
Add values to a Hashtable.
Get an iterator for the Hashtable.entrySet().
Iterate through all values and:
Get a Map.Entry for the iterator.
Create an object of type Module (a custom class) based on the value.
Add the class to a JPanel.
Show the panel.
The problem with this is that I do not have control over the order that I get the values back, so I cannot display the values in the a given order (without hard-coding the order).
I would use an ArrayList or Vector for this, but later in the code I need to grab the Module object for a given Key, which I can't do with an ArrayList or Vector.
Does anyone know of a free/open-source Java class that will do this, or a way to get values out of a Hashtable based on when they were added?
Thanks!

I suggest a LinkedHashMap or a TreeMap. A LinkedHashMap keeps the keys in the order they were inserted, while a TreeMap is kept sorted via a Comparator or the natural Comparable ordering of the keys.
Since it doesn't have to keep the elements sorted, LinkedHashMap should be faster for most cases; TreeMap has O(log n) performance for containsKey, get, put, and remove, according to the Javadocs, while LinkedHashMap is O(1) for each.
If your API that only expects a predictable sort order, as opposed to a specific sort order, consider using the interfaces these two classes implement, NavigableMap or SortedMap. This will allow you not to leak specific implementations into your API and switch to either of those specific classes or a completely different implementation at will afterwards.

LinkedHashMap will return the elements in the order they were inserted into the map when you iterate over the keySet(), entrySet() or values() of the map.
Map<String, String> map = new LinkedHashMap<String, String>();
map.put("id", "1");
map.put("name", "rohan");
map.put("age", "26");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " = " + entry.getValue());
}
This will print the elements in the order they were put into the map:
id = 1
name = rohan
age = 26

If an immutable map fits your needs then there is a library by google called guava (see also guava questions)
Guava provides an ImmutableMap with reliable user-specified iteration order. This ImmutableMap has O(1) performance for containsKey, get. Obviously put and remove are not supported.
ImmutableMap objects are constructed by using either the elegant static convenience methods of() and copyOf() or a Builder object.

You can use LinkedHashMap to main insertion order in Map
The important points about Java LinkedHashMap class are:
It contains only unique elements.
A LinkedHashMap contains values based on the key.
It may have one null key and multiple null values.
It is same as HashMap instead maintains insertion order
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
But if you want sort values in map using User-defined object or any primitive data type key then you should use TreeMap For more information, refer this link

You can maintain a Map (for fast lookup) and List (for order) but a LinkedHashMap may be the simplest. You can also try a SortedMap e.g. TreeMap, which an have any order you specify.

Either You can use LinkedHashMap<K, V> or you can implement you own CustomMap which maintains insertion order.
You can use the Following CustomHashMap with the following features:
Insertion order is maintained, by using LinkedHashMap internally.
Keys with null or empty strings are not allowed.
Once key with value is created, we are not overriding its value.
HashMap vs LinkedHashMap vs CustomHashMap
interface CustomMap<K, V> extends Map<K, V> {
public boolean insertionRule(K key, V value);
}
#SuppressWarnings({ "rawtypes", "unchecked" })
public class CustomHashMap<K, V> implements CustomMap<K, V> {
private Map<K, V> entryMap;
// SET: Adds the specified element to this set if it is not already present.
private Set<K> entrySet;
public CustomHashMap() {
super();
entryMap = new LinkedHashMap<K, V>();
entrySet = new HashSet();
}
#Override
public boolean insertionRule(K key, V value) {
// KEY as null and EMPTY String is not allowed.
if (key == null || (key instanceof String && ((String) key).trim().equals("") ) ) {
return false;
}
// If key already available then, we are not overriding its value.
if (entrySet.contains(key)) { // Then override its value, but we are not allowing
return false;
} else { // Add the entry
entrySet.add(key);
entryMap.put(key, value);
return true;
}
}
public V put(K key, V value) {
V oldValue = entryMap.get(key);
insertionRule(key, value);
return oldValue;
}
public void putAll(Map<? extends K, ? extends V> t) {
for (Iterator i = t.keySet().iterator(); i.hasNext();) {
K key = (K) i.next();
insertionRule(key, t.get(key));
}
}
public void clear() {
entryMap.clear();
entrySet.clear();
}
public boolean containsKey(Object key) {
return entryMap.containsKey(key);
}
public boolean containsValue(Object value) {
return entryMap.containsValue(value);
}
public Set entrySet() {
return entryMap.entrySet();
}
public boolean equals(Object o) {
return entryMap.equals(o);
}
public V get(Object key) {
return entryMap.get(key);
}
public int hashCode() {
return entryMap.hashCode();
}
public boolean isEmpty() {
return entryMap.isEmpty();
}
public Set keySet() {
return entrySet;
}
public V remove(Object key) {
entrySet.remove(key);
return entryMap.remove(key);
}
public int size() {
return entryMap.size();
}
public Collection values() {
return entryMap.values();
}
}
Usage of CustomHashMap:
public static void main(String[] args) {
System.out.println("== LinkedHashMap ==");
Map<Object, String> map2 = new LinkedHashMap<Object, String>();
addData(map2);
System.out.println("== CustomHashMap ==");
Map<Object, String> map = new CustomHashMap<Object, String>();
addData(map);
}
public static void addData(Map<Object, String> map) {
map.put(null, "1");
map.put("name", "Yash");
map.put("1", "1 - Str");
map.put("1", "2 - Str"); // Overriding value
map.put("", "1"); // Empty String
map.put(" ", "1"); // Empty String
map.put(1, "Int");
map.put(null, "2"); // Null
for (Map.Entry<Object, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " = " + entry.getValue());
}
}
O/P:
== LinkedHashMap == | == CustomHashMap ==
null = 2 | name = Yash
name = Yash | 1 = 1 - Str
1 = 2 - Str | 1 = Int
= 1 |
= 1 |
1 = Int |
If you know the KEY's are fixed then you can use EnumMap. Get the values form Properties/XML files
EX:
enum ORACLE {
IP, URL, USER_NAME, PASSWORD, DB_Name;
}
EnumMap<ORACLE, String> props = new EnumMap<ORACLE, String>(ORACLE.class);
props.put(ORACLE.IP, "127.0.0.1");
props.put(ORACLE.URL, "...");
props.put(ORACLE.USER_NAME, "Scott");
props.put(ORACLE.PASSWORD, "Tiget");
props.put(ORACLE.DB_Name, "MyDB");

I don't know if it is opensource, but after a little googling, I found this implementation of Map using ArrayList. It seems to be pre-1.5 Java, so you might want to genericize it, which should be easy. Note that this implementation has O(N) access, but this shouldn't be a problem if you don't add hundreds of widgets to your JPanel, which you shouldn't anyway.

Whenever i need to maintain the natural order of things that are known ahead of time, i use a EnumMap
the keys will be enums and you can insert in any order you want but when you iterate it will iterate in the enum order (the natural order).
Also when using EnumMap there should be no collisions which can be more efficient.
I really find that using enumMap makes for clean readable code.
Here is an example