You should store your data in a Map and sort it by values, you can take a look to these links:
Utility Class approach
Instead of a static sorter method you can use this utility Class to sort entries as they are added to the map:
public class ValueSortedMap<K extends Comparable<K> ,V extends Comparable<V> > extends TreeMap<K,V> {
private TreeMap<K,V> sortedMap;
private ValueComparator comparator;
private boolean reverseOrder = false;
public ValueSortedMap() {
this.comparator = new ValueComparator();
this.sortedMap = new TreeMap<K, V>(comparator);
}
public ValueSortedMap(boolean reverseOrder) {
this();
this.reverseOrder = reverseOrder;
}
@Override
public String toString() {
return sortedMap.toString();
}
@Override
public V put(K key, V value) {
if(sortedMap.containsKey(key)){
//remove the key in the sorted set before adding the key again
remove(key);
}
comparator.unsortedMap.put(key, value);
return sortedMap.put(key, value);
}
@Override
public Map.Entry<K, V> firstEntry() {
return sortedMap.firstEntry();
}
@Override
public void clear() {
sortedMap.clear();
comparator.unsortedMap.clear();
}
@Override
public boolean containsKey(Object key) {
return sortedMap.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return sortedMap.containsValue(value);
}
@Override
public Set<Map.Entry<K, V>> entrySet() {
return sortedMap.entrySet();
}
@Override
public V get(Object key) {
return sortedMap.get(key);
}
/**
* 0-based position
* @param position
* @return
*/
public Map.Entry<K, V> getEntryInPosition(int position) {
Iterator<Map.Entry<K,V>> iterator = sortedMap.entrySet().iterator();
int i = 0;
while(iterator.hasNext()){
if(i == position){
return iterator.next();
}else{
i++;
}
}
return null;
}
@Override
public boolean isEmpty() {
return sortedMap.isEmpty();
}
@Override
public Set<K> keySet() {
return sortedMap.keySet();
}
@Override
public void putAll(Map<? extends K, ? extends V> map) {
for(Map.Entry<? extends K, ? extends V> entry : map.entrySet()){
put(entry.getKey(), entry.getValue());
}
}
@Override
public int size() {
return sortedMap.size();
}
@Override
public Collection<V> values() {
return sortedMap.values();
}
@Override
public V remove(Object key) {
sortedMap.remove(key);
return comparator.unsortedMap.remove(key);
}
public class ValueComparator implements Comparator<K>{
public Map<K,V> unsortedMap = new HashMap<K,V>();
@Override
public int compare(K k1, K k2) {
Comparable<V> v1 = unsortedMap.get(k1);
Comparable<V> v2 = unsortedMap.get(k2);
if(Objects.equal(v1,v2)){
return k1.compareTo(k2); //not using reverseOrder comparing keys
}else{
if(reverseOrder){
return ComparisonChain.start().compare(v2, v1, Ordering.natural().nullsFirst()).result();
}else{
return ComparisonChain.start().compare(v1, v2, Ordering.natural().nullsFirst()).result();
}
}
}
}
}
