使用LinkedHashMap和Comparator排序器对Map的排序抛砖引玉

Question

本帖最后由 liuzyl 于 2012-09-21 00:00:18 编辑

Answer 1

如果一定要用map存的话，要不这样用treeSet实现排序功能，然后遍历treeSet赋给map
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<Person>(new PersonComparator()); ts.add(new Person(1, "Json", 20));
ts.add(new Person(2, "Peter", 22));
ts.add(new Person(1, "Divid", 25));
ts.add(new Person(3, "Aglia", 27));
ts.add(new Person(3, "Alex", 23));
ts.add(new Person(3, "Molic", 22)); Map<String, Person> map = new HashMap<String, Person>(); for (Iterator<Person> iterator = ts.iterator(); iterator.hasNext();) {
Person p = (Person) iterator.next();
map.put(p.getName(), p);
System.out.println(p.getName() + "|" + p.getLevel() + "|"
+ p.getAge());
}
}
}class PersonComparator implements Comparator<Person> { @Override
public int compare(Person p1, Person p2) {
if (p1.getLevel() == p2.getLevel()) {
return p1.getAge() - p2.getAge();
} return p1.getLevel() - p2.getLevel();
}
lz考虑下

Answer 2

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;/**
 *
 * @author raistlic
 * @date   25/09/2012
 */
public class ValueSortedMap<K, V> implements Map<K, V> {
  
  public static void main(String[] args) {
    
    Map<String, Person> map = new ValueSortedMap<String, Person>(
            new Comparator<Person>() {      @Override
      public int compare(Person o1, Person o2) {
        
        int result = o1.getLevel() - o2.getLevel();
        if( result == 0 )
          result = o1.getAge() - o2.getAge();
        
        return result;
      }
    });
    map.put("Json", new Person(1, "Json", 20));
    map.put("Peter", new Person(2, "Peter", 22));
    map.put("Divid", new Person(1, "Divid", 25));
    map.put("Aglia", new Person(3, "Aglia", 27));
    map.put("Alex", new Person(3, "Alex", 23));
    map.put("Molic", new Person(3, "Molic", 22));
    
    
    for(String key : map.keySet())
      System.out.println(map.get(key));
  }
  
  private Map<K, V> proxyMap;
  private SortedSet<K> keySet;
  private Comparator<? super V> valueComparator;
  private Comparator<Map.Entry<K, V>> entryComparator;
  public ValueSortedMap(Comparator<? super V> comparator) {
    
    if( comparator == null )
      throw new NullPointerException();
    
    this.valueComparator = comparator;
    this.proxyMap = new HashMap<K, V>();
    this.keySet = new TreeSet<K>(new KComparator(comparator));
    this.entryComparator = new EntryComparator(comparator);
  }  @Override
  public Set<K> keySet() {
    
    return new TreeSet<K>(keySet);
  }  @Override
  public Collection<V> values() {
    
    List<V> result = new ArrayList<V>(proxyMap.values());
    Collections.sort(result, this.valueComparator);
    return result;
  }  @Override
  public Set<Entry<K, V>> entrySet() {
    
    Set<Entry<K, V>> result = new TreeSet<Entry<K, V>>(this.entryComparator);
    result.addAll(proxyMap.entrySet());
    return result;
  }  @Override
  public int size() {
    
    return proxyMap.size();
  }  @Override
  public boolean isEmpty() {
    
    return proxyMap.isEmpty();
  }  @Override
  public boolean containsKey(Object key) {
    
    return proxyMap.containsKey(key);
  }  @Override
  public boolean containsValue(Object value) {
    
    return proxyMap.containsValue(value);
  }  @Override
  public V get(Object key) {
    
    return proxyMap.get(key);
  }  @Override
  public V put(K key, V value) {
    
    if( key == null )
      throw new NullPointerException();
    if( value == null )
      throw new NullPointerException();
    
    V result = proxyMap.put(key, value);
    keySet.add(key);
    return result;
  }  @Override
  @SuppressWarnings("unchecked")
  public V remove(Object key) {
    
    keySet.remove((K)key);
    return proxyMap.remove(key);
  }  @Override
  public void putAll(Map<? extends K, ? extends V> m) {
    
    if( m == null )
      throw new NullPointerException();
    
    for(K key : m.keySet())
      put(key, m.get(key));
  }  @Override
  public void clear() {
    
    keySet.clear();
    proxyMap.clear();
  }
  
  private class KComparator implements Comparator<K> {
    
    private final Comparator<? super V> vComparator;
    private KComparator(Comparator<? super V> vComparator) {
      
      assert vComparator != null;
      
      this.vComparator = vComparator;
    }    @Override
    public int compare(K o1, K o2) {
      
      return vComparator.compare(get(o1), get(o2));
    }
  }
  
  private class EntryComparator implements Comparator<Map.Entry<K, V>> {
    
    private final Comparator<? super V> vComparator;
    private EntryComparator(Comparator<? super V> vComparator) {
      
      assert vComparator != null;
      
      this.vComparator = vComparator;
    }
    
    @Override
    public int compare(Entry<K, V> o1, Entry<K, V> o2) {
      
      return vComparator.compare(o1.getValue(), o2.getValue());
    }
  }
}class Person {  private int level;
  private String name;
  private int age;  public Person(int type, String name, int age) {
    this.name = name;
    this.level = type;
    this.age = age;
  }  public String getName() {
    return name;
  }  public void setName(String name) {
    this.name = name;
  }  public int getAge() {
    return age;
  }  public void setAge(int age) {
    this.age = age;
  }  public int getLevel() {
    return level;
  }  public void setLevel(int level) {
    this.level = level;
  }
  
  @Override
  public String toString() {
    
    return getName() + "|" + getLevel() + "|" + getAge()+ "|";
  }
}
最好是  implements SortedMap<K, V>
没时间改了。

Answer 3

public class Person implements Comparable<Person> {
/** 等级 */
private int level;
/** 姓名 */
private String name;
/** 年龄 */
private int age; public Person(int type, String name, int age) {
this.name = name;
this.level = type;
this.age = age;
}
public Person() {
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public int getLevel() {
return level;
} public void setLevel(int level) {
this.level = level;
}
/*@Override*/
public int compareTo(Person o) {
int num = new Integer(this.level).compareTo(new Integer(o.level));
if(num == 0){
return new Integer(this.age).compareTo(new Integer(o.age));
}
return num;
}}测试类
public static void main(String[] args) { TreeSet<Person> set = new TreeSet<Person>();
set.add(new Person(1,"Json", 20));
set.add(new Person( 2,"Peter",22));
set.add(new Person(1,"Divid", 25));
set.add(new Person(3,"Aglia", 27));
set.add(new Person(3,"Alex", 23));
set.add(new Person(3,"Molic", 22));

        Iterator<Person> it = set.iterator();
        while(it.hasNext()){
         Person p =it.next();
         System.out.println(p.getName()+"|"+p.getLevel()+"|"+p.getAge());
        }
        
}

Answer 4

使用TreeSet ,不好取啊..我需要随时取出来值,然后修改level,然后再存进去的..

Answer 5

这个挺好...但是有个问题,我需要再次排序的话..就要hashmap转成treeset...
那和我的也差不多吧~

Answer 6

嗯， 在map里根据条件排序是没有直接的方法的，这两种方法都是间接排序，不过我个人还是习惯用treeSet,你可以自由选择。

Answer 7

我都是这么来的public class KVObject<K, V> { private K key;
private V value; /**
 * @param key
 * @param value
 */
public KVObject(K key, V value) {
this.key = key;
this.value = value;
} public K getKey() {
return key;
} public V getValue() {
return value;
} public void setKey(K key) {
this.key = key;
} public void setValue(V value) {
this.value = value;
} @Override
public String toString() {
return "KVObject [key=" + key + ", value=" + value + "]";
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((key == null) ? 0 : key.hashCode());
result = prime * result + ((value == null) ? 0 : value.hashCode());
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else if (obj == null) {
return false;
} else if (getClass() != obj.getClass()) {
return false;
} else {
KVObject<?, ?> other = (KVObject<?, ?>) obj;
if (key == other.key && value == other.value) {
return true;
} else if (key != null && value != null && key.equals(other.key)
&& value.equals(other.value)) {
return true;
} else {
return false;
}
}
}}
public class MapUtil { public static <K, V> Map<K, V> list2Map(List<KVObject<K, V>> list) {
if (list == null) {
return null;
}
Map<K, V> map = new HashMap<K, V>();
Iterator<KVObject<K, V>> it = list.iterator();
while (it.hasNext()) {
KVObject<K, V> kvObj = it.next();
K key = kvObj.getKey();
V value = kvObj.getValue();
if (map.containsKey(key)) {
throw new RuntimeException(
"Illegal List,one or more KVObect with the same key:"
+ key);
}
map.put(key, value);
}
return map;
} public static <K, V> List<KVObject<K, V>> map2List(Map<K, V> map) {
if (map == null) {
return null;
}
List<KVObject<K, V>> list = new ArrayList<KVObject<K, V>>();
Set<K> keys = map.keySet();
Iterator<K> it = keys.iterator();
while (it.hasNext()) {
K key = it.next();
V value = map.get(key);
KVObject<K, V> kvObj = new KVObject<K, V>(key, value);
list.add(kvObj);
}
return list;
} public static <K, V> Map<K, V> sortMap(Map<K, V> map,
Comparator<? super KVObject<K, V>> comparator) {
List<KVObject<K, V>> list = map2List(map);
Collections.sort(list, comparator);
return list2Map(list);
}
}

Answer 8

如果你的MAP读比较频繁的话，直接就用LZ第一个的方法，也就新增数据的时候，需要重新排序一下，删除则不需要
如果写比较频繁， 那么就直接用 HashMap(如果有并发安全等需求,用并发版本，避免LinkedHashMap,因为没有官方并发版本)。 然后只在循环读取的时候，排一下序。

Answer 9

为什么不使用ConcurrentSkipListMap?支持comparator.....

Answer 10

因为不能根据 VALUE 排序

Answer 11

使用Map赋值,然后map转成arraylist,arraylist通过Comparator排序

Answer 12

ArrayList即可，遍历，找到其中符合条件的元素，改变它的age.