how to swap key in map?

is there a way to sort this numbers stored in a string variable?

TreeMap<String,List<QBFElement>> qbfElementMap = new TreeMap<String, List<QBFElement>>();

this is the map where the key is :

27525-1813, 
27525-3989, 
27525-4083, 
27525-4670,
27525-4911, 
27526-558,  
27526-1303, 
27526-3641, 
27526-4102, 
27527-683,
27527-2411, 
27527-4342

this is the list of keys and the value for each of the key is a list.

now, how can i sort this key in ascending order by number.

ex. if i want to sort : 1,2,11,20,31,3,10

i want to have as output is : 1,2,3,10,11,20,31

but when i use the autosort of treemap the output goes : 1,10,11,2,20,3,31

how can i sort it in ascending order by numer开发者_运维技巧ic?

and the language is java :) thank you:)

The keys in your map are not Integer but String values. That's why the key's are sorted like observed.

Either change the Map to

TreeMap<Long,List<QBFElement>> qbfElementMap

or create it with a specialized Comparatorthat will provide the expected numerical order for the String type keys.

A mapping from your String values to Longs could be done like this:

private Long convertToLongTypeKey(String key) {
  String[] parts = key.split("-");
  // next lines assumes, that the second part is in range 0...9999
  return Long.parseLong(parts[0]) * 10000 + Long.parseLong(parts[1]);
}

An implementation of Comparator<String> could use the same mapping to create a numerical comparision of two String based keys:

new TreeMap<String,List<QBFElement>>(new Comparator<String>(){
  @Override
  public int compare(String key1, String key2) {
    String[] parts1 = key1.split("-");
    Long long1 = Long.parseLong(parts1[0]) * 10000 + Long.parseLong(parts1[1]);
    String[] parts2 = key2.split("-");
    Long long2 = Long.parseLong(parts2[0]) * 10000 + Long.parseLong(parts2[1]);
    return long1.compareTo(long2);
  }
});

You can change the way that the TreeMap sorts its keys by providing a custom comparator to the constructor. If you want, you can define a new Comparator that compares strings by breaking them up into numeric components.

It seems like a better idea, though, would be to not use Strings as your keys. The data you're using as keys is clearly not textual - it's numeric - and you might want to define a custom type to represent it. For example:

public class KeyType implements Comparable<KeyType> {
    private final int first;
    private final int second;

    public KeyType(int first, int second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public boolean equals(Object other) {
        if (!(other instanceof KeyType)) return false;
        KeyType realOther = (KeyType) other;
        return realOther.first == first && realOther.second == second;
    }

    @Override
    public int hashCode() {
        return first + 31 * second;
    }

    public int compareTo(KeyType other) {
        if (first != other.first)
            return first - other.first;
        return second - other.second;
    }
}

This approach is the most expressive and robust. It gives you better access to the individual fields of the keys you're using, and also prevents you from adding nonsensical keys into the map like the string "Lalalalala". I'd strongly suggest using this approach, or at least one like it. The type system is your friend.

A TreeMap can take a custom comparator for custom sorting. Write a comparator that sorts the keys the way you want and use it when you create the treemap

TreeMap<String,List<QBFElement>> qbfElementMap = new TreeMap<String, List<QBFElement>>(myComparator);