Map

HashMap 

Map 是键值对集合。其中key列就是一个集合，key不能重复，但是value可以重复。 HashMap、TreeMap和Hashtable是Map的三个主要的实现类。 HashTable 是线程安全的，不能存储 null 值 HashMap 不是线程安全的，可以存储 null 值


HashMap 的父类是AbstractMap    并且不能包含重复键，但可以包含重复值
允许键值都为null，方法允许key==null,     方法并没有对value进行任何调用，所以允许为null  ，并且还是无序   方法是非同步的
非线程安全的    执行效率比hashtable快


Hashtable
 继承Dictiionary     方法是同步的      方法不允许value==null      方法调用了key的hashCode方法，如果key==null,会抛出空指针异常
线程安全的   无序






hashmap hashtable
线程不安全 线程安全
允许有null的键和值 不允许有null的键和值
效率高一点、 效率稍低
方法不是Synchronize的要提供外同步 方法是是Synchronize的
有containsvalue和containsKey方法 有contains方法方法
HashMap 是Java1.2 引进的Map interface 的一个实现 Hashtable 继承于Dictionary 类
HashMap是Hashtable的轻量级实现 Hashtable 比HashMap 要旧




ConcurrentHashMap  是线程安全的，并且是无序的


ConcurrentSkipListMap是线程安全的，并且是有序的


所有键值对 — 参见 entrySet()
所有键 — 参见 keySet()
有值 — 参见 values()

TreeMap

TreeMap  是有序的，非同步的     keyIterator()的作用是返回顺序的KEY的集合，descendingKeyIterator()的作用是返回逆序的KEY的集合。

TreeMap的默认是升序的，如果要降序就要改方法

实例

遍历Map的四种方法
public static void testMap(){

Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");

//第一种：普遍使用，二次取值
System.out.println("通过Map.keySet遍历key和value：");
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
}

通过Map.keySet遍历key和value：
key= 3 and value= value3
key= 2 and value= value2
key= 1 and value= value1




//第二种
System.out.println("通过Map.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}


通过Map.entrySet使用iterator遍历key和value：
key= 3 and value= value3
key= 2 and value= value2
key= 1 and value= value1



/ /第三种：推荐，尤其是容量大时
System.out.println("通过Map.entrySet遍历key和value");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

通过Map.entrySet遍历key和value
key= 3 and value= value3
key= 2 and value= value2
key= 1 and value= value1




//第四种
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
for (String v : map.values()) {
System.out.println("value= " + v);
}


通过Map.values()遍历所有的value，但不能遍历key
value= value3
value= value2
value= value1
}


测试HashMap
public static void testHashMap(){
HashMap<String, String> hashmap=new HashMap<String, String>();
hashmap.put("张三", "value1");
hashmap.put("李四", "value3");
hashmap.put("哈哈", "value2");
for (String key : hashmap.keySet()) {
System.out.println("key= "+ key + " and value= " + hashmap.get(key));
}
}
key= 哈哈 and value= value2
key= 张三 and value= value1
key= 李四 and value= value3   （无序）







对map排序时用 
实例如下
ArrayList<RankingData> sortList=new ArrayList<RankingData>();
sortList.addAll(typeMap.values());
//给排行榜做排序
 Collections.sort(sortList,     new RankCompartor()（这个里面写下面的方法）       ); @Override
 for (int i = 0; i < sortList.size(); i++) {
RankingData rankBean = sortList.get(i);    
if(rankBean==null)
{
 continue;
}
  rankBean.setState((byte)1);
ankBean.setRankNum(i+1);
 }




就是这个方法//new RankCompartor()
public class RankCompartor implements Comparator<RankingData>{


@Override
/**传入俩个玩家的信息进行比较*/
public int compare(RankingData o1, RankingData o2) {
//降序排列
if(o2.getRankingCount()>o1.getRankingCount()){
return 1;
}

return 0;
}


}


使用 Map按key进行排序    还要在声明一个类
public static void main(String[] args) {


Map<String, String> map = new TreeMap<String, String>();


map.put("a", "kfc");
map.put("g", "wnba");
map.put("c", "nba");
map.put("z", "cba");


Map<String, String> resultMap = sortMapByKey(map); //按Key进行排序


for (Map.Entry<String, String> entry : resultMap.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());      a kfc        c nba       g wnba          z cba
}
}

/**
* 使用 Map按key进行排序
* @param map
* @return
*/
public static Map<String, String> sortMapByKey(Map<String, String> map) {
if (map == null || map.isEmpty()) {
return null;
}


Map<String, String> sortMap = new TreeMap<String, String>(
new MapKeyComparator());


sortMap.putAll(map);


return sortMap;
}
这个就是上面要声明的类
public class MapKeyComparator implements Comparator<String> {



@Override
public int compare(String str1, String str2) {

return str1.compareTo(str2);
}
}










按照value进行排序
public class Testing {  
  
    public static void main(String[] args) {  
  
        HashMap<String,Double> map = new HashMap<String,Double>();  
        ValueComparator bvc =  new ValueComparator(map);  
        TreeMap<String,Double> sorted_map = new TreeMap<String,Double>(bvc);  
  
        map.put("A",99.5);  
        map.put("B",67.4);  
        map.put("C",67.4);  
        map.put("D",67.3);  
  
        System.out.println("unsorted map: "+map);  
  
        sorted_map.putAll(map);  
  
        System.out.println("results: "+sorted_map);  
    }  
}  
  
class ValueComparator implements Comparator<String> {  
  
    Map<String, Double> base;  
    public ValueComparator(Map<String, Double> base) {  
        this.base = base;  
    }  
  


    public int compare(String a, String b) {  
        if (base.get(a) >= base.get(b)) {  
            return -1;  
        } else {  
            return 1;  
        } 
    }  
}

map排序

String 是字符串,它的比较用compareTo方法,它从第一位开始比较,如果遇到不同的字符,则马上返回这两个字符的ascii值差值..返回值是int类型


int跟int的比较不能用compareTo方法,直接用大于(>) 小于(<) 或者 等于(==) 不等于(!=)来比较即可


compare to 方法比较的是两个字符串的大小，先把int型变量转换成String再进行比较  String.valueOf（）方法








package test;


import java.util.Comparator;
import java.util.Map;


/**
 * 按照value进行排序
 * xutengteng
 * 2016-9-22
 */
public class ValueComparator implements Comparator<String>{




    Map<String, Double> base;  
    public ValueComparator(Map<String, Double> base) {  
        this.base = base;  
    }  
  
//    /**按照降序排序*/
//    public int compare(String a, String b) {  
//        if (base.get(a) >= base.get(b)) {  
//            return -1;  
//        } else {  
//            return 1;  
//        } 
//    } 
排序前: {D=67.3, A=99.5, B=67.4, C=67.4}
排序后{A=99.5, C=67.4, B=67.4, D=67.3}


    /**按照升序排序*/
    public int compare(String a, String b) {  
        if (base.get(a) <= base.get(b)) {  
            return -1;  
        } else {  
            return 1;  
        } 
    } 
排序前: {D=67.3, A=99.5, B=67.4, C=67.4}
排序后{D=67.3, C=67.4, B=67.4, A=99.5}
}