pythonhashmap遍歷

㈠ 怎麼遍歷HashMap集合中的ArrayList集合對象

java">importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
importjava.util.Map.Entry;

publicclassStudent
{
privateStringname;
privateintage;

publicStudent(Stringname,intage){
this.name=name;
this.age=age;
}

publicstaticvoidmain(String[]args)
{
for(Entry<String,List<Student>>e:prepare().entrySet()){
System.out.println(String.format("%s學生列表如下",e.getKey()));
for(Students:e.getValue()){
System.out.println(String.format("%s%d歲",s.name,s.age));
}
}
}
/**
*准備一組測試數據
*@return
*/
publicstaticMap<String,List<Student>>prepare(){
finalList<Student>studentList1=newArrayList<Student>(){
{
this.add(newStudent("張三",7));
this.add(newStudent("李四",6));
this.add(newStudent("王二",5));
}
};

finalList<Student>studentList2=newArrayList<Student>(){
{
this.add(newStudent("趙",10));
this.add(newStudent("錢",9));
this.add(newStudent("孫",8));
}
};
returnnewHashMap(){
{
this.put("一年級一班",studentList1);
this.put("一年級二班",studentList2);
}
};
}
}

寫個簡單的小例子，應該能看明白吧

列印結果

一年級二班學生列表如下
趙 10歲
錢 9歲
孫 8歲
一年級一班學生列表如下
張三 7歲
李四 6歲
王二 5歲

㈡ hashmap的遍歷

方式1
Iterator iterator = hm.keySet().iterator();
while(iterator.hasNext()) {
System.out.println(hm.get(iterator.next()));
}
方式2
Set set = hm.entrySet() ;
java.util.Iterator it = hm.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());
}

比較建議方式一的做法

㈢ 關於hashmap遍歷問題

代碼解釋

```

` ````

// 一、第一種寫法

HashMap hashMap = new HashMap();

for (Map.Entry en : hashMap.entrySet()) {

}

// 由於HashMap沒加泛型，所以得到的Set也是沒有泛型的

Set set = hashMap.entrySet();

// 由於Set沒有泛型，程序不知道裡面的元素是Map.Entry，這樣寫當然會報錯

for (Map.Entry en : set) {

}

// 除非你這樣寫，將Set強轉為Set<Map.Entry>，告訴代碼Set裡面的元素是Map.Entry

for (Map.Entry en : (Set<Map.Entry>) set) {

}

// 二、第二種寫法

HashMap<String, String> hashMap2 = new HashMap();

// HashMap有泛型，因此調用entrySet()方法得到的Set也有泛型，泛型元素為Map.Entry

Set<Map.Entry<String, String>> entries = hashMap2.entrySet();

// 所以第二種寫法循環不會報錯

for (Map.Entry en : entries) {

}

` ````

```

㈣ 怎麼遍歷一個hashmap的鍵值對

for(Object obj:map.keySet()){
System.out.println(obj);
System.out.println(map.get(obj))
}

㈤ Hashmap遍歷查詢問題

首先，map中是不能存key 相同的值，如果key相同，則key對應的value為最後一次存的值；
然後，遍歷map
Map root=new HashMap();
root.put("a", 1);
root.put("a", 100);
root.put("a", 2);
root.put("b", 3);
root.put("b", 44);
root.put("b", 5555);
root.put("c", 1111);
root.put("c", 9);
Iterator it=root.entrySet().iterator();
while(it.hasNext()){
Map.Entry<String, Integer> entry = (Entry<String, Integer>) it.next();
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
最後，按照你這種想法，可以將hashmap 換成 arrayList；

㈥ 提供一個方法用於遍歷獲取HashMap<String,String>中所有value並存放在List中返回考慮上集合中泛型的使用

public List<String> getValueList(HashMap<String,String> map){
ArrayList<String> valueList = new ArrayList<>():
Collection<String> values = map.values();
for(String value : values){
valueList.add(value);
}
return valueList;
}

㈦ HashMap和List遍歷方法總結及如何遍歷刪除

（一）List的遍歷方法及如何實現遍歷刪除
我們造一個list出來，接下來用不同方法遍歷刪除，如下代碼：
List<String> list= new ArrayList<String>();famous.add("zs");famous.add("ls");famous.add("ww");famous.add("dz");

1、for循環遍歷list：
for(int i=0;i<list.size();i++){if(list.get(i).equals("ls"))list.remove(i);}

這是一種很常見的遍歷方式，但是使用這種遍歷刪除元素會出現問題，原因在於刪除某個元素後，list的大小發生了變化，而你的索引
也在變化，所以會導致你在遍歷的時候漏掉某些元素。比如當你刪除第一個元素後，繼續根據索引訪問第二個元素後，因為刪除的原因，
後面的元素都往前移動了以為，所以實際訪問的是第三個元素。因此，這種遍歷方式可以用在讀取元素，而不適合刪除元素。
2、增強for循環：
for(String x:list){if(x.equals("ls"))list.remove(x);}

這也是一種很常見的遍歷方式，但是使用這種遍歷刪除元素也會出現問題，運行時會報異常
其實增強for循環是java語法糖的一種體現，如果大家通過反編譯得到位元組碼，那麼上面這段代碼的內部實現如下所示:

for(Iterator<String> it = list.iterator();it.hasNext();){String s = it.next();if(s.equals("madehua")){list.remove(s);}}

下面就解釋為什麼會報異常。分析Iterator的源代碼，重點分析整個調用該過程中的
函數（hasNext和remove）:

private class Itr implements Iterator<E> { int cursor; // index of next element to return int lastRet = -1; // index of last element returned; -1 if no such int expectedModCount = modCount; public boolean hasNext() { return cursor != size; // size為集合中元素的個數 } public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new (); cursor = i + 1; return (E) elementData[lastRet = i]; } /* 此方法並沒被調用，只是調用List.remove方法 public void remove() { checkForComodification(); try { ArrayList.this.remove(lastRet); // size欄位減1 cursor = lastRet; lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new (); } } */ final void checkForComodification() { // 檢查修改和當前版本號是否一致，不一致則拋出異常 if (modCount != expectedModCount) throw new (); } } // List.remove @Override public boolean remove(Object object) { Object[] a = array; int s = size; if (object != null) { for (int i = 0; i < s; i++) { if (object.equals(a[i])) { System.array(a, i + 1, a, i, --s - i); a[s] = null; // Prevent memory leak size = s; modCount++; // 核心代碼：修改了版本號。這樣當checkForComodification的時候，modCount值就和expectedModCount不同 return true; } } } else { for (int i = 0; i < s; i++) { if (a[i] == null) { System.array(a, i + 1, a, i, --s - i); a[s] = null; // Prevent memory leak size = s; modCount++; return true; } } } return false; }

接下來梳理一下流程，這時候你就會發現這個異常是在next方法的checkForComodification中拋出的。拋出的原因是
modCount !=expectedModCount。這里的modCount是指這個list對象從呢我出來到現在被修改的次數，當調用list
的add或者remove方法的時候，這個modCount都會自動增減；iterator創建的時候modCount被復制給了
expectedModcount，但是調用list的add和remove方法的時候不會同時自動增減expectedModcount，這樣就導致
兩個count不相等，從而拋出異常。大家如果理解了上面的執行流程，以後碰到類似這種問題，比如如果刪除的是倒數
第二個元素卻不會碰到異常。就會知道為什麼了。

3、iterator遍歷刪除：

Iterator<String> it = list.iterator();while(it.hasNext()){String x = it.next();if(x.equals("del")){it.remove();}}

這種方式是可以正常遍歷和刪除的。但是你可能看到上面代碼感覺和增強for循環內部實現的代碼差不多，其實差別就在於上面使用
一個使用list.remove(),一個使用it.remove()。

（二）HashMap的遍歷刪除及如何實現遍歷刪除
一樣我們先造一個hashmap出來，如下：

private static HashMap<Integer, String> map = new HashMap<Integer, String>();; public static void main(String[] args) { for(int i = 0; i < 10; i++){ map.put(i, "value" + i); } }

1、第一種遍歷刪除：

for(Map.Entry<Integer, String> entry : map.entrySet()){Integer key = entry.getKey();if(key % 2 == 0){System.out.println("To delete key " + key);map.remove(key);System.out.println("The key " + + key + " was deleted");}

這種遍歷刪除依舊會報異常，
2、第二種遍歷刪除：
Set<Integer> keySet = map.keySet(); for(Integer key : keySet){ if(key % 2 == 0){ System.out.println("To delete key " + key); keySet.remove(key); System.out.println("The key " + + key + " was deleted"); } }

這種遍歷刪除依舊會報異常，
3、第三種遍歷刪除：
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();while(it.hasNext()){Map.Entry<Integer, String> entry = it.next();Integer key = entry.getKey();if(key % 2 == 0){ System.out.println("To delete key " + key); it.remove(); System.out.println("The key " + + key + " was deleted");}}

這種遍歷是OK的
分析上述原因，如果大家理解了List的遍歷刪除，那麼感覺HashMap的遍歷刪除是不是有類似之處啊。下面就分析一下原因：
如果查詢源代碼以上的三種的刪除方式都是通過調用HashMap.removeEntryForKey方法來實現刪除key的操作。
在removeEntryForKey方法內知識一場了key modCount就會執行一次自增操作，此時modCount就與expectedModCOunt不一致了
，上面三種remove實現中，只有第三種iterator的remove方法在調用完removeEntryForKey方法後同步了expectedModCount值與
modCount相同，所以iterator方式不會拋出異常。最後希望大家遇到問題到查詢源代碼，它會給你最好的解釋！

㈧ 使用python遍歷文件夾將文件夾中所有的txt文本轉為html連接形式。

importos
defgetalltxtfilename(path):
txtfilenames=[]
fordirpath,dirnames,filenamesinos.walk(path):
filenames=filter(lambdafilename:filename[-4:]=='.txt',filenames)
filenames=map(lambdafilename:os.path.join(dirpath,filename),filenames)
txtfilenames.extend(filenames)
returntxtfilenames
deftxttohtmllink(path):
filenames=getalltxtfilename(path)
htmllink=[]
forfilenameinfilenames:
ifos.path.isfile(filename):
htmllinktext=''
myfile=open(filename)
firstline=myfile.readline()
whilefirstlineandlen(firstline)<2:
firstline=myfile.readline()
ifnotfirstline:
firstline=''*2
else:
firstline=firstline.strip('
')
htmllinktext+=firstline[0]+'<ahref="'+
filename+'">'+
firstline[1:]+'</a><br>'
htmllink.append(htmllinktext)
myfile.close()
returnhtmllink
path=r"文件夾路徑"#將此處替換為實際文件夾的路徑
htmllinks=txttohtmllink(path)
forhtmllinkinhtmllinks:
printhtmllink

在html標記前加上一個字元,這就不是合法的html文本形式,還是按照要求做了,如果輸入到html文件肯定會出錯

㈨ HashMap的幾種遍歷方式

有兩種第一種: Map map = new HashMap(); Iterator iter = map.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); Object key = entry.getKey(); Object val = entry.getValue(); } 效率高,以後一定要使用此種方式！第二種: Map map = new HashMap(); Iterator iter = map.keySet().iterator(); while (iter.hasNext()) { Object key = iter.next(); Object val = map.get(key); } 效率低,以後盡量少使用！ HashMap的遍歷有兩種常用的方法，那就是使用keyset及entryset來進行遍歷，但兩者的遍歷速度是有差別的，下面請看實例： public class HashMapTest { public static void main(String[] args) ...{ HashMap hashmap = new HashMap(); for (int i = 0; i < 1000; i ) ...{ hashmap.put("" i, "thanks"); } long bs = Calendar.getInstance().getTimeInMillis(); Iterator iterator = hashmap.keySet().iterator(); while (iterator.hasNext()) ...{ System.out.print(hashmap.get(iterator.next())); } System.out.println(); 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, "thanks"); } long bs = Calendar.getInstance().getTimeInMillis(); 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.print(entry.getValue()); } System.out.println(); System.out.println(Calendar.getInstance().getTimeInMillis() - bs); } } 對於keySet其實是遍歷了2次，一次是轉為iterator，一次就從hashmap中取出key所對於的value。而entryset只是遍歷了第一次，他把key和value都放到了entry中，所以就快了。還是第一種好，簡單。。。

㈩ HashMap 遍歷問題

HashMap map2 = (HashMap) map1.get(it1);
改成
HashMap map2 = (HashMap) map1.get(str1);

對了給我加分