Map HashMap 排序 迭代循環 修改值

HashMap dgzhMap = Dict.getDict("dgzh");
Iterator it_d = dgzhMap.entrySet().iterator();    
    while (it_d.hasNext()) {    
        Map.Entry entry_d = (Map.Entry) it_d.next();    
        Object key = entry_d.getKey();    
        Object value = entry_d.getValue();
        value = value.toString().split("-")[0];
        dgzhMap.put(key, value);
    }

 

//hashmap是HashMap類型的對象

if(hashmap!=null || !hashmap.isEmpty())
{
    Set set = hashmap.keySet();
    Iterator it = set.iterator();
    while(it.hasNext())
    {
     String key = (String)it.next();
     Integer integer = (Integer)hashmap.get(key);
     }
}

HashMap attMap;
Iterator i = attMap.entrySet().iterator();
while(i.hasNext()){
    Object o = i.next();
    String key = o.toString();
   //這樣就可以遍歷該HashMap的key值了。
}

當然也可以遍歷Map.Entry項，值。方法類似。


也可以
Object [] obja=attmap.keySet().toArray();

聽我們的支持說遍歷hashmap使用entryset快些，因大部分都是用keyset遍歷的，也沒有去想那么多。今天研究了一下，果然差了很多。
見示例，只是簡單的hashmap信息。不多說了，大家把這個類在本地運行下，很容易看到結果。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Calendar;

public class HashMapTest {

public static void main(String[] args) {
HashMap hashmap = new HashMap();
for(int i=0;i<1000;i++){
hashmap.put(""+i,"hello");
}

long bs = Calendar.getInstance().getTimeInMillis();
Iterator iterator = hashmap.keySet().iterator();
//String value = "";
while(iterator.hasNext()) {
//value = hashmap.get(iterator.next());
System.out.println(hashmap.get(iterator.next()));
}
System.out.println(Calendar.getInstance().getTimeInMillis() - bs);
listHashMap();
}

public static void listHashMap(){
java.util.HashMap hashmap = new java.util.HashMap();
for(int i=0;i<1000;i++){
hashmap.put(""+i,"hello");
}
long bs = Calendar.getInstance().getTimeInMillis();
//Set set = hashmap.entrySet() ;
java.util.Iterator it = hashmap.entrySet().iterator();
while(it.hasNext()){
java.util.Map.Entry entry = (java.util.Map.Entry)it.next();
// entry.getKey() 返回與此項對應的鍵
// entry.getValue() 返回與此項對應的值
System.out.println(entry.getValue());
}
System.out.println(Calendar.getInstance().getTimeInMillis() - bs);
}

}

對於keySet其實是遍歷了2次，一次是轉為iterator，一次就從hashmap中取出key所對於的value。

而entryset只是遍歷了第一次，他把key和value都放到了entry中，所以就快了。


對於我們做web的，可能不部分都是用vo對象或是form封裝信息，所以用到hashmap時，其內存放的都是上面的對象。因此使用entryset遍歷性能會有所提高。

hashmap使用很多，比如導入信息時就要用到，因大部分導入的信息要去判斷是否有重復的信息，這樣就可以利用containsKey來進行處理了，而不用在插入的時候去進行處理。

 

 

Java中對Map(HashMap,TreeMap,Hashtable等)的排序時間 
首先簡單說一下他們之間的區別： 

HashMap: 最常用的Map,它根據鍵的HashCode 值存儲數據,根據鍵可以直接獲取它的值，具有很快的訪問速度。HashMap最多只允許一條記錄的鍵為Null(多條會覆蓋);允許多條記錄的值為 Null。非 
首先簡單說一下他們之間的區別： 

HashMap: 最常用的Map,它根據鍵的HashCode 值存儲數據,根據鍵可以直接獲取它的值，具有很快的訪問速度。HashMap最多只允許一條記錄的鍵為Null(多條會覆蓋);允許多條記錄的值為 Null。非同步的。 

TreeMap: 能夠把它保存的記錄根據鍵(key)排序,默認是按升序排序，也可以指定排序的比較器，當用Iterator 遍歷TreeMap時，得到的記錄是排過序的。TreeMap不允許key的值為null。非同步的。 

Hashtable: 與 HashMap類似,不同的是:key和value的值均不允許為null;它支持線程的同步，即任一時刻只有一個線程能寫Hashtable,因此也導致了Hashtale在寫入時會比較慢。 

LinkedHashMap: 保存了記錄的插入順序，在用Iterator遍歷LinkedHashMap時，先得到的記錄肯定是先插入的.在遍歷的時候會比HashMap慢。key和value均允許為空，非同步的。 


TreeMap默認按key進行升序排序，如果想改變默認的順序，可以使用比較器: 

Map<String,String> map = new TreeMap<String,String>(new Comparator<String>(){ 
   public int compare(String obj1,String obj2){ 
    //降序排序 
    return obj2.compareTo(obj1); 
   } 
  }); 
  map.put("month", "The month"); 
  map.put("bread", "The bread"); 
  map.put("attack", "The attack"); 
  
  Set<String> keySet = map.keySet(); 
  Iterator<String> iter = keySet.iterator(); 
  while(iter.hasNext()){ 
   String key = iter.next(); 
   System.out.println(key+":"+map.get(key)); 
  } 


如果要對TreeMap按照value的值進行排序，或者對HashMap,Hashtable,LinkedHashMap進行排序，則可以使用Map.Entry<K,V>接口結合List實現： 

eg.1 對TreeMap按照value值升序： 

List<Map.Entry<String,String>> mappingList = null; 
  Map<String,String> map = new TreeMap<String,String>(); 
  map.put("aaaa", "month"); 
  map.put("bbbb", "bread"); 
  map.put("ccccc", "attack"); 
  
  //通過ArrayList構造函數把map.entrySet()轉換成list 
  mappingList = new ArrayList<Map.Entry<String,String>>(map.entrySet()); 
  //通過比較器實現比較排序 
  Collections.sort(mappingList, new Comparator<Map.Entry<String,String>>(){ 
   public int compare(Map.Entry<String,String> mapping1,Map.Entry<String,String> mapping2){ 
    return mapping1.getValue().compareTo(mapping2.getValue()); 
   } 
  }); 
  
  for(Map.Entry<String,String> mapping:mappingList){ 
   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
  } 


eg.2 對HashMap(或Hashtable,LinkedHashMap)按照key的值升序: 

List<Map.Entry<String,String>> mappingList = null; 
  Map<String,String> map = new HashMap<String,String>(); 
  map.put("month", "month"); 
  map.put("bread", "bread"); 
  map.put("attack", "attack"); 
  
  //通過ArrayList構造函數把map.entrySet()轉換成list 
  mappingList = new ArrayList<Map.Entry<String,String>>(map.entrySet()); 
  //通過比較器實現比較排序 
  Collections.sort(mappingList, new Comparator<Map.Entry<String,String>>(){ 
   public int compare(Map.Entry<String,String> mapping1,Map.Entry<String,String> mapping2){ 
    return mapping1.getKey().compareTo(mapping2.getKey()); 
   } 
  }); 

 

說到遍歷，首先應該想到for循環，然而map集合的遍歷通常情況下是要這樣在的，先要獲得一個迭代器。

[java]
Map<Integer,String> map = new HashMap<>();    
   
    Iterator it = map.entrySet().iterator();    
   
    while (it.hasNext()) {    
   
        Map.Entry entry = (Map.Entry) it.next();    
   
        Object key = entry.getKey();    
   
        Object value = entry.getValue();   

Map<Integer,String> map = new HashMap<>();  
 
    Iterator it = map.entrySet().iterator();  
 
    while (it.hasNext()) {  
 
        Map.Entry entry = (Map.Entry) it.next();  
 
        Object key = entry.getKey();  
 
        Object value = entry.getValue(); 
實際上一個foreach循環也是可以的，很簡潔吧~

[java]
for(Map.Entry<Integer,Integer> m:map.entrySet()) 
                { 
                    if(arr[i]==(int)m.getKey()) 
                        map.put((int)m.getKey(),(int)m.getValue()+1); 
                } 

for(Map.Entry<Integer,Integer> m:map.entrySet())
    {
     if(arr[i]==(int)m.getKey())
      map.put((int)m.getKey(),(int)m.getValue()+1);
    }
附上一個完整的小程序例子。

隨機生成長度為100的數組，數組元素為1到10，統計出現次數最多和最少的元素

 

[java]
mport java.util.*; 
class   Count  
{ 
    public void count(int[] arr) 
    { 
        int num=0; 
        Map<Integer,Integer> map=new HashMap<Integer,Integer>(); 
        for(int i=1;i<=10;i++) 
        { 
            map.put(i,num); 
        } 
        for(int i=0;i<arr.length;i++) 
        { 
            /*Iterator it = map.entrySet().iterator();    
            while(it.hasNext())
                {     
                    Map.Entry m=(Map.Entry)it.next();
                    if(arr[i]==(int)m.getKey())
                        map.put((int)m.getKey(),(int)m.getValue()+1);
                }*/ 
                for(Map.Entry<Integer,Integer> m:map.entrySet()) 
                { 
                    if(arr[i]==(int)m.getKey()) 
                        map.put((int)m.getKey(),(int)m.getValue()+1); 
                } 
        } 
        for(Map.Entry<Integer,Integer> m:map.entrySet()) 
        { 
            System.out.println(""+m.getKey()+"出現的次數為："+m.getValue()+"次"); 
        } 
    } 
     
    public static void main(String[] args)  
    { 
        Random rd=new Random(); 
        int[] arr=new int[100]; 
        for(int i=0;i<100;i++) 
        { 
            arr[i]=rd.nextInt(10)+1; 
        } 
        new Count().count(arr); 
    } 
} 

import java.util.*;
class Count
{
 public void count(int[] arr)
 {
  int num=0;
  Map<Integer,Integer> map=new HashMap<Integer,Integer>();
  for(int i=1;i<=10;i++)
  {
   map.put(i,num);
  }
  for(int i=0;i<arr.length;i++)
  {
   /*Iterator it = map.entrySet().iterator();   
   while(it.hasNext())
    {    
     Map.Entry m=(Map.Entry)it.next();
     if(arr[i]==(int)m.getKey())
      map.put((int)m.getKey(),(int)m.getValue()+1);
    }*/
    for(Map.Entry<Integer,Integer> m:map.entrySet())
    {
     if(arr[i]==(int)m.getKey())
      map.put((int)m.getKey(),(int)m.getValue()+1);
    }
  }
  for(Map.Entry<Integer,Integer> m:map.entrySet())
  {
   System.out.println(""+m.getKey()+"出現的次數為："+m.getValue()+"次");
  }
 }
 
 public static void main(String[] args)
 {
  Random rd=new Random();
  int[] arr=new int[100];
  for(int i=0;i<100;i++)
  {
   arr[i]=rd.nextInt(10)+1;
  }
  new Count().count(arr);
 }
}

  
  for(Map.Entry<String,String> mapping:mappingList){ 
   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
  }