You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
110 lines
2.6 KiB
110 lines
2.6 KiB
package mightypork.utils;
|
|
|
|
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
|
|
/**
|
|
* Map sorting utils
|
|
*
|
|
* @author Ondřej Hruška (MightyPork)
|
|
*/
|
|
public class MapSort {
|
|
|
|
/**
|
|
* Sort a map by keys, maintaining key-value pairs, using natural order.
|
|
*
|
|
* @param map map to be sorted
|
|
* @return linked hash map with sorted entries
|
|
*/
|
|
@SuppressWarnings({ "rawtypes" })
|
|
public static <K extends Comparable, V> LinkedHashMap<K, V> byKeys(Map<K, V> map)
|
|
{
|
|
return byKeys(map, null);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sort a map by keys, maintaining key-value pairs.
|
|
*
|
|
* @param map map to be sorted
|
|
* @param comparator a comparator, or null for natural ordering
|
|
* @return linked hash map with sorted entries
|
|
*/
|
|
@SuppressWarnings({ "unchecked" })
|
|
public static <K, V> LinkedHashMap<K, V> byKeys(Map<K, V> map, Comparator<K> comparator)
|
|
{
|
|
final List<K> keys = new LinkedList<>(map.keySet());
|
|
|
|
if (comparator == null) {
|
|
comparator = new Comparator<K>() {
|
|
|
|
@Override
|
|
public int compare(K arg0, K arg1)
|
|
{
|
|
return ((Comparable<K>) arg0).compareTo(arg1);
|
|
}
|
|
};
|
|
}
|
|
|
|
Collections.sort(keys, comparator);
|
|
|
|
final LinkedHashMap<K, V> sortedMap = new LinkedHashMap<>();
|
|
for (final K key : keys) {
|
|
sortedMap.put(key, map.get(key));
|
|
}
|
|
|
|
return sortedMap;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sort a map by values, maintaining key-value pairs, using natural order.
|
|
*
|
|
* @param map map to be sorted
|
|
* @return linked hash map with sorted entries
|
|
*/
|
|
@SuppressWarnings("rawtypes")
|
|
public static <K, V extends Comparable> LinkedHashMap<K, V> byValues(Map<K, V> map)
|
|
{
|
|
return byValues(map, null);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sort a map by values, maintaining key-value pairs.
|
|
*
|
|
* @param map map to be sorted
|
|
* @param comparator a comparator, or null for natural ordering
|
|
* @return linked hash map with sorted entries
|
|
*/
|
|
public static <K, V> LinkedHashMap<K, V> byValues(Map<K, V> map, final Comparator<V> comparator)
|
|
{
|
|
final List<Map.Entry<K, V>> entries = new LinkedList<>(map.entrySet());
|
|
|
|
Collections.sort(entries, new Comparator<Map.Entry<K, V>>() {
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public int compare(Entry<K, V> o1, Entry<K, V> o2)
|
|
{
|
|
if (comparator == null) return ((Comparable<V>) o1.getValue()).compareTo(o2.getValue());
|
|
return comparator.compare(o1.getValue(), o2.getValue());
|
|
}
|
|
});
|
|
|
|
final LinkedHashMap<K, V> sortedMap = new LinkedHashMap<>();
|
|
|
|
for (final Map.Entry<K, V> entry : entries) {
|
|
sortedMap.put(entry.getKey(), entry.getValue());
|
|
}
|
|
|
|
return sortedMap;
|
|
}
|
|
}
|
|
|