① java map如何存放重復元素
map的要求是key不能重復，但是value可以重復，所以存放重復元素，只要key不相同即可。
比如有兩個人的名字相同：
都叫做LiuDeHua
Map<String,String> map = new HashMap<String,String>();
map.put("p1",「LiuDeHua」);
map.put(「p2「,"LiuDeHua");
這樣既可
② javaweb 中怎樣利用hashmap 怎樣實現用戶不重復注冊 （最好有具體實例）
是可以的，順便B視一下樓上說的要遍歷MAP的說法。那樣是誤導。哈希表的優勢是快速定位和查找，缺點就是遍歷，所以一般情況下要避免對哈希表進行遍歷。
哈希表最重要的原理就是採用鍵－值對存儲。值是對象，鍵就是給這個對象取個名字。然後存起來。
這種存儲是唯一並排它的。 比方說第一次你存了一個對象取個鍵名為「AAA」，下次你又想存一個對象也取名為「AAA」，那麼成功後，原來那個對象將會被新的對象替換。
換言之，表中永遠只會有一個以「AAA」命名的對象存在。 新存一個，舊的那個就丟了。
當客戶端發來注冊請求時，會發過來想要取的名字，後台得到這個名字後從資料庫中進行SQL查詢利用Like語法，查出所有類似這個名字的所有用戶。 這些用戶將會以一個集合的形式存在。
你可以將集合轉存在於哈希表中， 該哈希表以用戶名為鍵值，以用戶本身為對象存在。
Hashtable table = XXX;//你己經得到的用戶表
boolean hasContainsName= table.containsKey("youname");
if(hasContainsName == true){
//注冊失敗，己存在用戶
}
③ 對Java如何判斷HashSet和HashMap中相同元素的研究
在Java中任何一個對象都具備equals(Object obj)和hashcode()這兩個方法，因為他們是在Object類中定義的。 equals(Object obj)方法用來判斷兩個對象是否「相同」，如果「相同」則返回true，否則返回false。 hashcode()方法返回一個int數，在Object類中的默認實現是「將該對象的內部地址轉換成一個整數返回」。 接下來有兩個個關於這兩個方法的重要規范(我只是抽取了最重要的兩個,其實不止兩個)： 規范1：若重寫equals(Object obj)方法，有必要重寫hashcode()方法，確保通過equals(Object obj)方法判斷結果為true的兩個對象具備相等的hashcode()返回值。說得簡單點就是：「如果兩個對象相同，那麼他們的hashcode應該 相等」。不過請注意：這個只是規范，如果你非要寫一個類讓equals(Object obj)返回true而hashcode()返回兩個不相等的值，編譯和運行都是不會報錯的。不過這樣違反了Java規范，程序也就埋下了BUG。 規范2：如果equals(Object obj)返回false，即兩個對象「不相同」，並不要求對這兩個對象調用hashcode()方法得到兩個不相同的數。說的簡單點就是：「如果兩個對象不相同，他們的hashcode可能相同」。 1、如果兩個對象equals，Java運行時環境會認為他們的hashcode一定相等。 2、如果兩個對象不equals，他們的hashcode有可能相等。 3、如果兩個對象hashcode相等，他們不一定equals。 測試程序如下：首先我們定義一個類，重寫hashCode()和equals(Object obj)方法Java代碼class�0�2A�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2@Override�0�2�0�2�0�2�0�2�0�2�0�2public�0�2boolean�0�2equals(Object�0�2obj)�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2System.out.println("判斷equals");�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2return�0�2false;�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2@Override�0�2�0�2�0�2�0�2�0�2�0�2public�0�2int�0�2hashCode()�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2System.out.println("判斷hashcode");�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2return�0�21;�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2}�0�2�0�2class A { @Override public boolean equals(Object obj) { System.out.println("判斷equals"); return false; } @Override public int hashCode() { System.out.println("判斷hashcode"); return 1; } } Java代碼 public�0�2class�0�2Test�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2public�0�2static�0�2void�0�2main(String[]�0�2args)�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2Map<A,Object>�0�2map�0�2=�0�2new�0�2HashMap<A,�0�2Object>();�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2map.put(new�0�2A(),�0�2new�0�2Object());�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2map.put(new�0�2A(),�0�2new�0�2Object());�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2System.out.println(map.size());�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2public class Test { public static void main(String[] args) { Map<A,Object> map = new HashMap<A, Object>(); map.put(new A(), new Object()); map.put(new A(), new Object()); System.out.println(map.size()); } } 運行之後列印結果是： 判斷hashcode 判斷hashcode判斷equals2 可以看出，Java運行時環境會調用new A()這個對象的hashcode()方法。其中： 列印出的第一行「判斷hashcode」是第一次map.put(new A(), new Object())所列印出的。 1、當第一次map.put(new A(), new Object())的時候，Java運行時環境就會判斷這個map裡面有沒有和現在添加的 new A()對象相同的鍵，判斷方法：調用new A()對象的hashcode()方法，判斷map中當前是不是存在和new A()對象相同的HashCode。顯然，這時候沒有相同的，因為這個map中都還沒有東西。所以這時候hashcode不相等，則沒有必要再調用 equals(Object obj)方法了。參見推論4（如果兩個對象hashcode不相等，他們一定不equals） 2、當第二次map.put(new A(), new Object())的時候，Java運行時環境再次判斷，這時候發現了map中有兩個相同的hashcode（因為我重寫了A類的hashcode()方 法永遠都返回1），所以有必要調用equals(Object obj)方法進行判斷了。參見推論3（如果兩個對象hashcode相等，他們不一定equals），然後發現兩個對象不equals（因為我重寫了equals(Object obj)方法，永遠都返回false）。 3、這時候判斷結束，判斷結果：兩次存入的對象不是相同的對象。所以最後列印map的長度的時候顯示結果是：2。 改寫程序如下：Java代碼import�0�2java.util.HashMap;�0�2�0�2import�0�2java.util.Map;�0�2�0�2�0�2�0�2�0�2�0�2class�0�2A�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2@Override�0�2�0�2�0�2�0�2�0�2�0�2public�0�2boolean�0�2equals(Object�0�2obj)�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2System.out.println("判斷equals");�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2return�0�2true;�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2@Override�0�2�0�2�0�2�0�2�0�2�0�2public�0�2int�0�2hashCode()�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2System.out.println("判斷hashcode");�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2return�0�21;�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2}�0�2�0�2�0�2�0�2�0�2�0�2public�0�2class�0�2Test�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2public�0�2static�0�2void�0�2main(String[]�0�2args)�0�2{�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2Map<A,Object>�0�2map�0�2=�0�2new�0�2HashMap<A,�0�2Object>();�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2map.put(new�0�2A(),�0�2new�0�2Object());�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2map.put(new�0�2A(),�0�2new�0�2Object());�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2System.out.println(map.size());�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2�0�2�0�2�0�2�0�2�0�2�0�2}�0�2�0�2import java.util.HashMap; import java.util.Map; class A { @Override public boolean equals(Object obj) { System.out.println("判斷equals"); return true; } @Override public int hashCode() { System.out.println("判斷hashcode"); return 1; } } public class Test { public static void main(String[] args) { Map<A,Object> map = new HashMap<A, Object>(); map.put(new A(), new Object()); map.put(new A(), new Object()); System.out.println(map.size()); } } 運行之後列印結果是： 判斷hashcode 判斷hashcode判斷equals1顯然這時候map的長度已經變成1了，因為Java運行時環境認為存入了兩個相同的對象。原因可根據上述分析方式進行分析。 以上分析的是HashMap，其實HashSet的底層本身就是通過HashMap來實現的，所以他的判斷原理和HashMap是一樣的，也是先判斷hashcode再判斷equals。 所以：寫程序的時候應盡可能的按規范來，不然在不知不覺中就埋下了bug！
④ 求大神會java的hashmap的問題:如何刪掉Map中重復的值
importjava.util.HashSet;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.Map.Entry;
importjava.util.Set;
importorg.apache.commons.collections4.map.LinkedMap;
publicclassTest030{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Map<String,String>m=newLinkedMap<String,String>();
m.put("1","abc");
m.put("2","abc");
m.put("3","kjs");
m.put("4","abc");
m.put("5","kjs");
System.out.println("before:"+m);
removeDuplicate(m);
System.out.println("after:"+m);
}
(Map<String,String>m){
Set<String>values=newHashSet<String>();
for(Iterator<Entry<String,String>>it=m.entrySet().iterator();it
.hasNext();){
Entry<String,String>e=it.next();
if(values.contains(e.getValue())){
it.remove();
}else{
values.add(e.getValue());
}
}
}
}
寫的時候沒有注意, 如果jdk中沒有linkedMap, 那麼請引入commons的collections包
主要是HashMap不保證順序
⑤ java問題，我想在java中存儲鍵值對，以便使用，但是鍵值對的鍵和值都有重復元素，使用hashmap會產生覆蓋。
你這個是n vs n的情況，都不算算是鍵值對應關系了。所以不用考慮map了
鏈表和這個也沒有太大關系，主要有多對多的情況
不知道你那個
b 2
c 2是不是有序的，如果有序的話，用數組可以簡單實現
⑥ java List中的HashMap,去掉重復列。按json輸出
這個是JSON數據，定義好JAVA類，可以使用 json-lib或 GSON 轉成相應的集合，再去掉重復的行
~~~~~~
⑦ java中的HashMap類是做什麼用的
java中HashMap類是用來存儲具有鍵值對特徵的數據。例如現在需要按照員工號來存儲大量的員工信息，那麼就可以使用HashMap，將員工號作為鍵，員工對象作為值來存儲到HashMap中，其中使用HashMap時需要注意，HashMap是線程不同步的，多線程使用時，需要注意；並且HashMap允許null值作為鍵和值。
⑧ JAVA 關於 HashMap的
基於哈希表的 Map 介面的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。（除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證映射的順序，特別是它不保證該順序恆久不變。
public V put(K key, V value)
作為key的對象只能使用一個null，而value則可以保存多個null.在此映射中關聯指定值與指定鍵。如果該映射以前包含了一個該鍵的映射關系，則舊值被替換。
⑨ java hashmap怎麼遍歷沖突的部分
大家都知道map的key值是不可以重復的，重復會覆蓋哦。
不過你的問題有個取巧的方法，就是不用int數字做key，而是新建string對象做key，這樣內存地址不同的話，是可以重復的。
Map map = new IdentityHashMap();
map.put(new String("1"), "a");
map.put(new String("1"), "b");
System.out.println(map);
輸出{1=a, 1=b}。
補充，其實用 IdentityHashMap的話，不用string，new Integer新建對象也是可以的。
⑩ java中hashset和hashmap有什麼特點
HashSet：
HashSet實現了Set介面，它不允許集合中有重復的值。當我們提到HashSet時，第一件事情就是在將對象存儲在HashSet之前，要先確保對象重寫equals()和hashCode()方法，這樣才能比較對象的值是否相等，以確保set中沒有儲存相等的對象。
public boolean add(Object o)方法用來在Set中添加元素，當元素值重復時則會立即返回false，如果成功添加的話會返回true。
HashMap：
HashMap實現了Map介面，Map介面對鍵值對進行映射。Map中不允許重復的鍵。Map介面有兩個基本的實現，HashMap和TreeMap。TreeMap保存了對象的排列次序，而HashMap則不能。
HashMap允許鍵和值為null。HashMap是非synchronized的，但collection框架提供方法能保證HashMap synchronized，這樣多個線程同時訪問HashMap時，能保證只有一個線程更改Map。
public Object put(Object Key，Object value)方法用來將元素添加到map中。