ืืื ืืืฉืง ืืคืช Java ืืืฉืง Java Map ืืื ืืืง ืืืกืืจืช Java Collection, ืื ืืื ืืื ื ืชืช-ืกืื ืฉื ืืืฉืง ืืืืกืฃ. ืื ืืื ืืชื ืื ืืฆืืจื ืฉืื ื ืืืฉืืืื ืืืฉื ืืจืฉืืืืช ืื ืืืืืืืงืื ืืืกืฃ ืืืจืื. ืื ืจืืื ืฉื Map<Key, Value> ืืืืฆื ืืื ืืคืชื-ืขืจื. ืื ืืคืชื ืืื ืขืจื ืื ืืื ืืืืืืงืืื. ืื ืืืคืชืืืช ืืืคื ืืกืืืืช ืื ืืืืืืืื, ืืขืื ืฉืืขืจืืื ืืื ื, ืื ืฉื ืืชื ืืฉืืคื ืืืชื. ืืชื ืขืฉืื ืืืฉืื ืขื ืืคื ื-Java ืืื ืกืื ืฉื ืืืืื ืื ืงืืืื ืื ืืช ืืงืืื ืช, ืฉืื ืืชื ืืืื ืืืฆืื ืื ืคืจืื ืืืืฆืขืืช ืืืื ืืงืก ืืืืืืื ืฉืื. ืืืคืชื ืืื ืืืื ืืืืืื ืฉื ืืขืจื ืืืคื. ืืืืืื ืืืคื<String, Item> String ืืื ืืืื ืฉื ืคืจืื ืืืฉืื ืืืื ืืช ืืืงืืื ืช.
ืขื ืคื ืืชืืขืื ืืืคื ืืฉ ืืช ืืืฉืงื ืืืฉื ื ืืืืื:
ืืจืืืืช ;
ConcurrentMap<K,V> ;
ConcurrentNavigableMap<K,V> ;
LogicalMessageContext ;
MessageContext ;
NavigableMap<K,V> ;
SOAPMessageContext ;
SortedMap<K,V> .
ืืืืืฉื ืฉืืขืืจืื:
ืืคื ืืืคืฉืืช
ืชืืื ืืช
AuthProvider
ConcurrentHashMap
ConcurrentSkipListMap
EnumMap
ืืคืช ืืืืื
ืืืืช ืืืืื
IdentityHashMap
LinkedHashMap
PrinterStateReasons
ื ืืกืื
ืกืคืง
ืจืืืื ืืขืืืื
SimpleBindings
TabularDataSupport
ืืคืช ืขืฅ
UIDfaults
WeakHashMap
Java AbstractMap ืืื ืืืืงื ืืืกืืจืงืืืช ืืืืืฉืืช ืืช ืจืื ืืืฉืง ืืืคื.
Java HashMap ืืื ืืื ื ื ืชืื ืื ืืืืกืื ืฆืืื ืืคืชื-ืขืจื ืืืืฆืขืืช ืืืืช Hash.
Java TreeMap ืืื ืืื ื ื ืชืื ืื ืืฉืืืืฉ ืืขืฅ, ืืืืืจ ืชืฆืืื ืขื ืืคืชืืืช ืืืืื ืื.
WeakHashMap ืืฉืืืืฉ ืืืืืช ืืืืื ืขื ืืคืชืืืช ืืืฉืื, ืชืฆืืื ืขื ืขืจืืื ืฉืืืืืื ืืืืืืง ืขื ืืื ืืกืคื ืืืฉืคื ืื ืื ืืื ื ืืฉืืืืฉ ืืืชืจ.
LinkedHashMap ืืื ืืคื ืขื ืกืืจ ืืืกืคืช ืืืืื ืืื, ืืืคืฉืจืช ืืืืจืฆืื ืืกืืจ ืืืื ืกื.
EnumMap ืืจืืืื ืืช ืืืืงืช AbstractMap ืืฉืืืืฉ ืขื ืืคืชืืืช enum.
IdentityHashMap ืืฉืชืืฉ ืืืืืงืช ืฉืืืืื ืืชืืืืกืืช ืืขืช ืืฉืืืืช ืืกืืืื, ืืืคืื ืขื ืืคืชืืืช ืืฉืืืื ืืืืฆืขืืช ืคืขืืืช
== ืืืงืื ืฉืืืช
equals()
ืืื ืื ื ืืขืื ืืื ืื ืืืืืขืืช ืืคืืคืืืจืืืช ืืืืชืจ ืฉื ืืืฉืง ืืคื: HashMap, TreeMap ื-LinkedHashMap. ืืื, ืกืืจ ืจืืืื ืืืคื ืชืืื ืืืืืขืืช ืกืคืฆืืคืืืช. ื ื ืื, ื-TreeMap ืื-LinkedHashMap ืืฉ ืกืืจ ืฆืคืื ืฉื ืืืืื ืืื, ืืขืื ืฉื-HashMap ืืื.
ืฉืืืืช ืืคื ืืคืขืืืืช ืืขืืงืจืืืช ืฉื ืื ืืคื ืื ืืื ืกื, ืืกืจื ืืืืคืืฉ ืฉื ืืืื ืืื.
public Object put (ืืคืชื ืืืืืืงื, ืขืจื ืืืืืืงื) ืืื ืืก ืืืื ื ืืืคื.
public void putAll(ืืคืช ืืคื) ืืืกืืฃ ืืช ืืืคื ืฉืฆืืื ื ืืชืื ืืืคื.
public Object remove(Object key) ืืืืง ืขืจื ืืคื ืืืคืชื ืฉืฆืืื.
public Object get(Object key) ืืืืืจ ืืช ืืขืจื ืขืืืจ ืืืคืชื ืฉืฆืืื.
public boolean containsKey(Object key) ืืืคืฉ ืืช ืืืคืชื ืฉืฆืืื ืืืคื ืื
public Set keySet() ืืืืืจ ืชืฆืืืช Set ืืืืืื ืืช ืื ืืืคืชืืืช
public Set entrySet() ืืืืืจ ืชืฆืืืช Set ืขื ืื ืืืคืชืืืช ืืืขืจืืื.
ืื ืื HashMap ืื ืื HashMap? ืืื ืืืืฉืื ืืคืืคืืืจื ืืืืชืจ ืฉื ืืืฉืง Map<Key,Value>. ืืื ื ื ืชืื ืื ืื ืืืืกืก ืขื ืขืงืจืื ืืืืืื.
ืืขืืงืจืื ืืขืืงืจื ืฉื ืขืืืืช HashMap: hashing ืืื ืืืืื ืืื hashmap ืืืืฆื ืืื ืคืืขืืช, ืืืื ื ืืืจ ืชืืืื ืขื ืคืื ืงืฆืืืช hash ื-hash. ืคืื ืงืฆืืืช Hash ืืื ืจืง ืคืื ืงืฆืื ืืืืื ืืชืืื. ืื ืืฉ ืขืจื ืงืื ืืืฉืื (ืืืืืืงื, ืคืืกืช ื ืชืื ืื) ืืคืื ืงืฆืื ืืืืจื ืืืชื ืืืืฆืขืืช ืืื ืืชืืื ืืขืจื ืคืื - hash. ืืจืื, hash ืืื ืืกืคืจ ืืงืกืืฆืืืื ืืืืจื ืืชืืื. ืืืืืื ืฉื ืชืืืืื ืืืจื ืขืฉืืืื ืืืืืช ืฉืื ืื, ืื ืื ืืคืืคืื ืืขืงืจืื ืืช ืืืืื:
ืืงืื ืืกืืื (ืืืืืืงื) ืืฉ ืงืื hash ืืกืืื.
ืื ืฉื ื ืืืืืืงืืื ืฉืืืื, ืื ืงืืื ื-hash ืฉืืื ืฉืืืื. ืืืืคื ืืื ื ื ืืื.
ืื ืงืืื ื-hash ืฉืื ืื, ืืืืืืืงืืื ืืืืื ืืื ื ืฉืืืื.
ืืคืขืืื ืืืืืืืงืืื ืฉืื ืื ืืืื ืืืืืช ืืืชื ืงืื hash. ืืื ืืืจืืข ืืืื ืื ืกืืืจ, ืฉืฉืื "ืืชื ืืฉืืช" ืืคืื ืงืฆืืืช Hash ืืืืืืช ืืืื ืืืืจื ืืืืขืจ ืืช ืืืกืชืืจืืช ืืืชื ืืฉืืืืช.
ื-Java, ืืื ืืืืืืงื ืืฉ ืงืื hash. ืื ืืืืฉื ืืฉืืืช hashCode ืฉื ืืืืงืช Object, ืืืืงื ืื ืฉื ืื ืืืืืืงืื Java. ืืืจื ืืื, ืืคืชืืื ืขืืงืคืื ืฉืืื ืื ืขืืืจ ืืืืืงืืช ืฉืืื, ืืื ืื
ืฉืืืื ืืฉืืืืช ืืงืฉืืจืืช ืืืื.
HashMap: ืืื ืื ืขืืื ืื Class HashMap<K,V> ืฉืื ืื ืืืฉืื ืืคื ืืืจืื ืืืคืชืืืช ืืขืจืืื. ืืื ืืืืกื ืืคืชืืืช ืืืืฆืขืืช ืขืงืจืื ืืช hashing. ืืชืื ื-HashMap ืฆืืื ืืคืชื-ืขืจื ืืืืืกื ืื ื"ืืืืื", ืืืืื ืืื ืืื ืื ืืื "ืืืื", ืืขืจื ืคื ืืื ืฉื ืจืฉืืืืช ืืงืืฉืจืืช ืืืืืื
ืืจืืฉืื ื ืืื 16 . HashMap ื-Java ืืฉืชืืฉ ืืงืื ื-hash ืฉื ืืืคืชื ืืื ืืงืืืข ืืื ืฉืื ืืื ืืืคืชื/ืขืจื ืฆืจืื ืืืคืืช: ืืชืืื ื ืืืกืืืืช ืฉื HashMap ืืื ืฉืื ืชื (ืืื) ืฉื ืืืืื [] ืฉืืืจ ืื ืจืง ืืื ืืื ืืื ืืื. ืื ืื ืืืืืกื ืื ืืืืืืืงื ืืคืืจืฉ (ืืื LinkedList), ืืื ืืฉืจืฉืจืช ืืจืืืืช. ืืจืฉืช ื ืืฆืจืช ืืฉื ืืขืืืื ืฉืื ืืื ืืืืกื ืงืืฉืืจ ืืืื ืืื. ืืืืืจ, ืื ืืืืืช ื-HashMap ืืคืืืจืื ืขื ืคื ื 16 ืฉืจืฉืจืืืช. ืืืฉืจ ืืชื ืืื ืืก ืืื ืืืฉ ืืืืื, ื-hash ืฉื ืืืคืชื ื ืืฉื. Hash ืื ืืื ื ืคืื ืงืฆืืืช Hashcode ืืืืื ืืช ืืืืืืืงื ืืืคืชื. ืื ื ืืฉื ืืืืื ืฉื 0-15. ืืืื ืืชืืืกืฃ ืืฉืจืฉืจืช ืืืืืืช ืืืืืืกื ืื ืืืื ืขื ืืื ืืงืก ื-hash. ืืืฉื ืื ืืขื ืืงื ืื ื ืืืฆืช ืืืคืืฉ. ืืืื ืืืคืืฉ ืืื ืืคื ืืคืชื, ืืื ืฆืืจื ืืขืืืจ ืขื ืื ืืืืื. ื-hash ืฉื ืืืคืชื ื ืืฉื ืืจืง ืืฉืจืฉืจืช ืืืืืืกื ืช ืืชื ืขื ืืื ืืงืก ื-hash ื ืืืงืช. ืื ืืฉ ืืืชืจ ืืื ืืืืืช ื-HashMap, ืืฉืจืฉืจืืืช ื ืขืฉืืช ืืจืืืืช ืืื. ืืื ืืืื ืืืขืจื ืืื, ื-hash ืฉื ืื ืืืืืืืงืืื ืืืืืืกื ืื ืืืืฉื ืืืืฉ, ืืื ืืคืืืจืื ืืืืจื ืฉืจืฉืจืืืช ืืืฉืืช.
ืืฆืืจืช HashMap ืื ืชืื ืืงืื HashMap ืฉื ืืืืชื ืชืืฆื ืืช ืืืฆืืจื ืืืื:
public class HashMap extends AbstractMap implements Map , Cloneable , Serializable
ืืืฉืจ
K ืืื ืกืื ืืืคืชืืืช ืืืชืืืืง ืขื ืืื ืืคื ืื ื-
V - ืกืื ืืขืจืืื ืืืืืคืื. ืืืื ืืืืื ืฉื ืืฆืืจืช HashMap ืขื ืืคืชื ืฉืื ืืขืจื ืืืจืืืช ืืงืื ืฉืื:
HashMap < Integer , String > myHashMap = new HashMap < Integer , String > ( ) ;
ืฉืืืืช HashMap ืืืื ืจืฉืืืช ืฉืืืืช HashMap.
Object get(Object key) ืืืืืจ ืืช ืืขืจื ืขืืืจ ืืืคืชื ืฉืฆืืื;
ืืืืืืงื put(Key k, Value v) ืืืกืืฃ ืืืคืื ืขืจื ืืคืชื ืืชืื ืืืคื;
Object remove(Object key) ืืกืืจ ืืช ืืืืคืื ืขืืืจ ืืืคืชื ืฉืฆืืื ืืืคื ืื ืื ืงืืื;
void clear() ืืกืืจ ืืช ืื ืฆืืื ืืืคืชื-ืขืจื ืื-HashMap;
Object clone() ืืืืืจ ืขืืชืง ืจืืื ืฉื ืืืคืข HashMap ืื ืืืื ืืฉืืคื ืืช ืืืคืชืืืช ืืืขืจืืื;
boolean containsKey(Object key) ืืืืืจื true ืื ืืืคืชื ืฉืฆืืื ื ืืฆื ืืืคื, false ืื ืื;
boolean containsValue(Object Value) ืืืืืจื true ืื ืืืคืชื ืฉืฆืืื ื ืืฆื ืืืคื, false ืื ืื;
boolean isEmpty() ืืืืืจื true ืื ืืืคื ืจืืงื, false ืื ืื;
Set keySet() ืืืืืจ ืืช ืขืจืืช ืืืคืชืืืช ืฉื ืืงืื ืืืืคื;
int size() ืืืืืจื ืืช ืืืืืช ืฉื ืืืคืื ืืคืชื-ืขืจื;
Collection values() ืืืืืจ ืืืกืฃ ืฉื ืขืจืื ืืืคื;
Object remove(Object key) ืืกืืจ ืืช ืฆืื ืืืคืชื-ืขืจื ืขืืืจ ืืืคืชื ืฉืฆืืื;
void putAll(Map m) ืืขืชืืง ืืช ืื ืืจืืืืื ืฉื ืืืคื ืืืคื ืืืืจืช.
ืืืืื ืฉื Java HashMap ืืืื ื ืืฆืืจ ืชืืื ืืช ืขื Java HashMap ืืืืืื ืืื ืืืืืื ืืื ืื ืขืืื:
import java. util. HashMap ;
import java. util. Map ;
import java. util. Iterator ;
import java. util. Set ;
public class HashMap {
public static void main ( String [ ] args) {
{
HashMap < Integer , String > myHashMap = new HashMap < Integer , String > ( ) ;
myHashMap. put ( 7 , "Johnny" ) ;
myHashMap. put ( 8 , "Ivy" ) ;
myHashMap. put ( 1 , "Rick" ) ;
myHashMap. put ( 4 , "Stan" ) ;
myHashMap. put ( 3 , "Kyle" ) ;
Set set = myHashMap. entrySet ( ) ;
Iterator iterator = set. iterator ( ) ;
while ( iterator. hasNext ( ) ) {
Map. Entry mapEntry = ( Map. Entry ) iterator. next ( ) ;
System . out. print ( "key: " + mapEntry. getKey ( ) + " value: " ) ;
System . out. println ( mapEntry. getValue ( ) ) ;
}
System . out. println ( "get an element from myHashMap via key and print the value out:" ) ;
System . out. println ( myHashMap. get ( 8 ) ) ;
System . out. println ( myHashMap) ;
String var = myHashMap. get ( 2 ) ;
System . out. println ( "Value with key 2: " + var ) ;
var = myHashMap. get ( 7 ) ;
System . out. println ( "Value with key 7: " + var ) ;
myHashMap. remove ( 4 ) ;
System . out. println ( "myHashMap after removing element:" ) ;
System . out. println ( myHashMap) ;
myHashMap. clear ( ) ;
System . out. println ( "myHashMap after total clearing:" ) ;
System . out. println ( myHashMap) ;
}
}
}
ืืชืืฆืื ืฉื ืืคืขืืช ืืชืืื ืืช:
key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}
ืืคืช ืขืฅ TreeMap ื-Java ืืืืฉื ืื ืืืฉืง Map<Key,Value>, ืื ืืื ืืืืกืก ืขื ืืื ื ื ืชืื ื ืขืฅ ืืืื-ืฉืืืจ. ืขืฅ ืืืจืื ื"ืฆืืชืื" ืืงืืืื ืืืืืจืื ืฆืืชืื - ืขื ืคืื. ืฆืืืช ื"ืฉืืจืฉ" ื ืืฆื ืืจืืฉ ืืขืฅ. ืืืฉืืจืฉ ืืืืืื ืืืืืช ืขื ืคืื ืืฆืืชืื. ืื ืืื ื ืืืจืจืื, ืืืื ืชืืฉืื ืขืืื ืฆืืชืื ืืื ื"ืืืืื" ืฉื ืืฉืืจืฉ. ืืฆืืืช ืืื ืืืืืื ืืืืืช ืืืืื ืืฉืื - ืฆืืชืื ื ืืืืื ืืืชืจ. ืฆืืชืื ืืื ืืืืื ื ืงืจืืื "ืฆืืชืื ืงืฆื" ืื "ืขืืื". ืขืฅ ืืื ืืจื ืืื ืขืฅ, ืฉืื ืืื ืฆืืืช ืืฉ ืืคืก, ืืื , ืื ืฉื ื ืืืืื. ืขืฅ ืืืืคืืฉ ืืืื ืืจื ืืื ืืื ื, ืฉืื ืื ืฆืืืช ืคื ืืื ืืืืกื ืืคืชื, ืืืคืขืืื ืขืจื ืืฉืืื, ืืืฉ ืื ืฉื ื ืชืชื-ืขืฆืื ื ืืืืื ("ืฉืืื" ื"ืืืื"). ืืืคืืฉ ืืื ืืจื ืืืืื ืืช ืขืฆืื ืขืฅ ืืื ืขืฅ ืืืคืืฉ ืืื ืืจื ืืืืกืก ืฆืืืช ืฉืฉืืืจ ืืืืืืืืช ืขื ืืืืื (ืืกืคืจ ืจืืืช ืืจืื ืืชืืช ืืฉืืจืฉ) ืงืื ืืื ืืืกืคืช ืคืจืืืื ืืืืืงืืช ืฉืจืืจืืชืืืช. ืขืฅ ืืืื-ืฉืืืจ ืืื ืขืฅ ืืื ืืจื ืืืืื ืขื ืืืืคืืื ืื:
ืื ืฆืืืช ืืื ืืืื ืื ืฉืืืจ
ืืฉืืจืฉ ืชืืื ืฉืืืจ
ืื ืขืื ืืื NIL (ืกืื ืฉื ืจืืง, null) ืฆืืืช ืืืื ืฉืืืจ
ืื ืฆืืืช ืืืื, ืืืืื ืื ืืืืื ืฉืืืจืื.
ืื ื ืชืื ืคืฉืื ืืฆืืช ืืขืื ืฆืืฆื ืืืื ืืช ืืืชื ืืกืคืจ ืฉื ืฆืืชืื ืฉืืืจืื.
ืชืืื ืืช ืฉื TreeMap TreeMap ืืฉืชืืฉ ืืืื ื ื ืชืื ื ืขืฅ ืืื ืืืืกื ืืช ืืืคืชืืืช ืืฆืืชืื ืืืืืื ืืช ืืืคืชืืืช ืืืืฆืขืืช ืืืืืจืืชื ืืขืฅ ืืืืื-ืฉืืืจ. ืื, TreeMap ืฉืืืจ ืืช ืืขืจืืื ืฉืื ืืืืื ืื ืืคื ืืกืืจ ืืืืขื ืฉื ืืืคืชืืืช ืฉืื. ืขืืืจ ืืกืคืจืื ืืืขื ืืื ืกืืจ ืขืืื, ืขืืืจ ืืืจืืืืช - ืกืืจ ืืืคืืืชื. ืืชื ืืืื ืืืฉืชืืฉ ืืืฉืืืื ืื โโืืชื ืฆืจืื ืืฉื ืืช ืืช ืืืืืืื ืฉื ืืืืื ื. ืืืื ืืืืืืงืืื ืืฆืืจื ืืืขืืช ืืื ืืชืจืื ืืืื ืฉื TreeMap, ืืื ืื ืืฆืืืช ืืืืืืงืืื ืืกืืืืื ืืืืฆืขืืช ืืกื ื ืื ืืชื ืืื ืฉืื ืื.
ืฉืืืืช TreeMap
Object get(Object key) ืืืืืจ ืืช ืืขืจื ืฉื ืืืคืชื ืืืชืืื;
Object put(Object key, Object value) ืืืกืืฃ ืืืคืื ืืืคื;
Object remove(Object key) ืืกืืจ ืืช ืืืืคืื ืขืืืจ ืืคืชื ืื ืื TreeMap ืืืื ืืืชื;
boolean containsKey(Object key) ืืืืืจื true ืื ืืืคื ืืื ืืืืื ืืืคืื ืขืืืจ ืืืคืชื ืฉืฆืืื;
boolean containsValue(Object value) ืืืืืจื true ืื TreeMap ืืืคื ืืคืชื ืืื ืื ืืืชืจ ืืขืจื ืฉืฆืืื;
ืืืืืืงื firstKey() ืืืืืจ ืืช ืืืคืชื ืืจืืฉืื ืฉื ืืฆื ืืขืช ืืืคื ืืืืืื ืช;
Object lastKey() ืืืืืจ ืืช ืืืคืชื ืืืืจืื ืฉื ืืฆื ืืขืช ืืืคื ืืืืืื ืช;
void putAll(ืืคืช ืืคื) ืืขืชืืง ืืช ืื ืืืืคืืืื ืืืืคื ืฉืฆืืื ื ืืืคื;
Set entrySet() ืืืืืจ ืชืฆืืื ืืืืืจืช ืฉื ืืืืคืืืื
int size() ืืืืืจื ืืช ืืืืืช ืฉื ืืืคืื ืืคืชื-ืขืจื
Collection values() ืืืืืจ ืชืฆืืืช ืืืกืฃ ืฉื ืืขืจืืื
Object clone() ืืืืืจ ืขืืชืง ืจืืื ืฉื TreeMap
void clear() ืืกืืจ ืืช ืื ืืืืคืืืื ื-TreeMap
SortedMap headMap(Object key_value) ืืืืืจ ืชืฆืืื ืฉื ืืืืง ืฉื ืืืคื ืืงืื ืืืคืจืืืจ key_value
Set keySet() ืืืืืจ ืชืฆืืืช Set ืฉื ืืืคืชืืืช ืืืืืืื ืืืคืช ืืขืฅ
SortedMap subMap(K fromKey, K toKey) ืืืืืจื ืชืฆืืื ืฉื ืืืืง ืฉื ืืืคื ืืื ืฉืืืคืชืืืช ืฉืื ื ืขืื ืืื fromKey, ืืืื, ื-toKey, ืืืขืื
ืืืืืืงื firstKey() ืืืืืจ ืืช ืืืคืชื ืืจืืฉืื ืืืคืช ืืขืฅ.
ืืืืื ืฉื TreeMap
import java. util. TreeMap ;
import java. util. Set ;
import java. util. Iterator ;
import java. util. Map ;
public class TreeMapExample {
public static void main ( String args[ ] ) {
TreeMap < Integer , String > myTreeMap = new TreeMap < Integer , String > ( ) ;
myTreeMap. put ( 1 , "Stuart" ) ;
myTreeMap. put ( 23 , "Michael" ) ;
myTreeMap. put ( 7 , "Johnny" ) ;
myTreeMap. put ( 5 , "Ivy" ) ;
myTreeMap. put ( 2 , "Alex" ) ;
Set set = myTreeMap. entrySet ( ) ;
Iterator iterator = set. iterator ( ) ;
while ( iterator. hasNext ( ) ) {
Map. Entry myEntry = ( Map. Entry ) iterator. next ( ) ;
System . out. print ( "key: " + myEntry. getKey ( ) + " value: " ) ;
System . out. println ( myEntry. getValue ( ) ) ;
}
System . out. println ( myTreeMap) ;
myTreeMap. remove ( 2 ) ;
System . out. println ( myTreeMap) ;
}
}
ืืชืืฆืื ืฉื ืืคืขืืช ืืชืืื ืืช:
key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}
LinkedHashMap LinkedHashMap ืืื ืืื ื ื ืชืื ืื ืืืฉืื ืจืฉืืืืช ืืงืืฉืจืืช ืืืคืืช ืืืืื. ืืื, LinkedHashMap ืืจืืื ืืช ืืืืงืช HashMap ืืืืืฉื ืืช ืืืฉืง Map, ืืื ืื ืื ืงืฉืืจ ืืจืฉืืืืช ืืงืืฉืจืืช? ืืืฆืืจื ืฉื LinkedHashMap:
Map < Integer , String > linkedHashMap = new LinkedHashMap < Integer , String > ( ) ;
LinkedHashMap ืืืืฉ ืืื ืืืจืฉ ืืืคืืื ืื ื-HashMap (ืืืื table, loadFactor, threshold, size, entrySet), ืืงืื ืื ืฉื ื ืืืคืืื ืื ืืืืืืื:
header ืืื ืจืืฉ ืจืฉืืื ืืงืืฉืจืช ืืคืื. ืืืืื ืืืชืืื, ืืื ืืฆืืื ืืช ืขืฆืื
accessOrder ืืฆืืื ืืืฆื ืืงืื ืืืฉื ืืืืื ืืื ืืืืฆืขืืช ืืืืจืืืจ. ืื ื ืืื, ืืคื ืกืืจ ืืืืฉื ืืืืจืื ื. ืื false, ืืืืฉื ืชืืื ืืกืืจ ืฉืื ืืจืืืืื ืืืื ืกื.
ืจืฉืืื ืืงืืฉืจืช ืื ืืืืืจื ืืช ืกืืจ ืืืืืจืฆืื. ืืืจื ืืื, ืืื ืกืืจ ืืื ืกืช ืืืคืชืืืช ืืืคื.
ืฉืืืืช LinkedHashMap
Object get(Object key) ืืืืืจ ืืช ืืขืจื ืฉืืืื ืืืืคื ืืืคืชื ืฉืฆืืื, ืื null ืื ืืืคื ืืื ืื ืืืืื ืืืคืื ืขืืืจ ืืืคืชื
void clear() ืืกืืจ ืืช ืื ืืืืคืืืื ืืืืคื.
boolean containsKey(Object key) ืืืืืจื true ืื ืืืืื ื ืฉืฆืืื ืืืืคื ืขื ืืื ืืคืชื ืืื ืื ืืืชืจ
ืืืืืื ื removeEldestEntry(Map.Entry eldest) ืืืืืจื true ืื ืืืคื ืืกืืจื ืืช ืืขืจื ืืืืืจ ืฉืื ืืืืคื
Set<Map.Entry<K,V>> entrySet() ืืืืืจ ืชืฆืืืช Set ืฉื ืืืืคืืืื ืืืืืืื ืืืคื ืื
void forEach(BiConsumer<? super K,? super V> action) ืืืฆืข ืืช ืืคืขืืื ืื ืชืื ื ืขืืืจ ืื ืขืจื ืืืคื ืื ืขื ืฉืื ืืขืจืืื ืขืืจื ืขืืืื ืื ืฉืืคืขืืื ืืืจืจืช ืืจืืื.
Object getOrDefault(Object key, V defaultValue) ืืืืืจ ืืช ืืขืจื ืฉืืืื ืืืืคื ืืืคืชื ืฉืฆืืื. ืื ืืืคื ืืื ื ืืืืื ืืืคืื ืขืืืจ ืืืคืชื ืืืืืจื defaultValue.
Set<K> keySet() ืืืืืจ ืชืฆืืืช Set ืฉื ืืืคืชืืืช ืืืืืืื ืืืคื
ืืืืืื ื removeEldestEntry(Map.Entry<K,V> eldest) ืืืืืจื true ืื ืืืคื ืืื ืฆืจืืื ืืืกืืจ ืืช ืืขืจื ืืืืืจ ืฉืื
void replaceAll(BiFunction<? super K,? super V,? ืืจืืื ืืช ืคืื ืงืฆืืืช V>) ืืืืืฃ ืื ืขืจื ืื ืืกื ืขื ืืชืืฆืื ืฉื ืืคืขืืช ืืคืื ืงืฆืื ืื ืชืื ื ืืืืชื ืขืจื ืขื ืฉืื ืืขืจืืื ืขืืจื ืขืืืื ืื ืฉืืคืื ืงืฆืื ืืืจืงืช ืืจืืื.
Collection<v>values() ืืืืืจ ืชืฆืืืช Collection ืฉื ืืขืจืืื ืืืืืืื ืืืคื
ืืืืื LinkedHashMap
import java. util. LinkedHashMap ;
import java. util. Set ;
import java. util. Iterator ;
import java. util. Map ;
public class HashLinkedListExample {
public static void main ( String args[ ] ) {
LinkedHashMap < Integer , String > myLinkedHashMap =
new LinkedHashMap < Integer , String > ( ) ;
myLinkedHashMap. put ( 7 , "Johnny" ) ;
myLinkedHashMap. put ( 12 , "Rick" ) ;
myLinkedHashMap. put ( 1 , "Kyle" ) ;
myLinkedHashMap. put ( 5 , "Percy" ) ;
myLinkedHashMap. put ( 85 , "Sebastian" ) ;
Set set = myLinkedHashMap. entrySet ( ) ;
Iterator iterator = set. iterator ( ) ;
while ( iterator. hasNext ( ) ) {
Map. Entry me = ( Map. Entry ) iterator. next ( ) ;
System . out. print ( "key: " + me. getKey ( ) +
" value: " + me. getValue ( ) + "\n" ) ;
}
System . out. println ( myLinkedHashMap) ;
myLinkedHashMap. put ( 21 , "Ivy" ) ;
System . out. println ( myLinkedHashMap) ;
myLinkedHashMap. remove ( 12 ) ;
System . out. println ( myLinkedHashMap) ;
myLinkedHashMap. put ( 12 , "Ronny" ) ;
System . out. println ( myLinkedHashMap) ;
myLinkedHashMap. put ( 1 , "Stan" ) ;
System . out. println ( myLinkedHashMap) ;
}
}
ืืื ืื ื ืืืฆืจืื LinkedHashMap ืืืฉ, ืืืกืืคืื ืืืืฉื ืืืื ืืื, ืืื ืืืคืืกืื ืืืชื ืืืืฆืขืืช ืืืืจืืืจ ืืืฆืืจื ืงืืืกืืช. ืืคื ืฉืืชื ืืืื ืืจืืืช, LinkedHashMap ืฉืืืจืช ืขื ืกืืจ ืืืื ืกื. ืืืจืื ืื ืื ื ืืืืงืื ืืืื ื ืืืืคื ืฉืื ื, ืืื ืืืกืืคืื ืืช ืืืืฉ ืืืืืืจ ืืืชืจ - ืขืื ืืืื ื ืืื ืขื ืืืคืชื, ืฉืืืจ ื ืืฆื ืืืคื. ืืื ืืืืืฃ ืืช ืืขืจื ืืืฉื ืฉืืืคื ืืืคืชื ืื.
ืืชืืฆืื ืฉื ืืคืขืืช ืืชืืื ืืช:
key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
HashMap, TreeMap, LinkedHashMap ืืฉืืืืช HashMap, TreeMap ื-LinkedHashMap ืื ืืืืืขืืช ืฉื ืืืฉืงื ืืคื. HashMap ื-LinkedHashMap ืื ืืื ื ื ืชืื ืื ืฉืืืืฉืื ืืคืชืืืช. TreeMap ืืฉืชืืฉ ืืกืืจ ืืืืขื ืฉื ืืืคืชืืืช ืฉืื ืืืจืืื ืขืฅ ืืืคืืฉ.
ืืืืืื:
HashMap ืื ืฉืืืจืช ืขื ืฉืื ืกืืจ.
TreeMap ืืืืื ืืช ืืขืจืืื ืืกืืจ ืขืืื ืฉื ืืืคืชืืืช.
LinkedHashMap ืฉืืืจืช ืขื ืกืืจ ืืืื ืกื.
ืืคืชืืืช ืืคืก:
HashMap ื-LinkedHashMap ืืืคืฉืจืื ืืืืืืง ืืคืชื null ืืื.
LinkedHashMap ืืื ื ืืืคืฉืจ ืืคืชืืืช null ืืืงืจื ืฉืืืคืชืืืช ืืฉืชืืฉืื ืืกืืจ ืืืขื ืื Comparator ืืื ื ืชืืื ืืืฉืืืื ืขื null leys.
ืืื ื ืงืื ืืืืื ืืืคืช Java ืืืืืืช ืืช ืื ืฉืืืฉืช ืืืืืืฉืื ืฉื ืกืงืจื ืืืืืจ ืื:
import java. util. HashMap ;
import java. util. LinkedHashMap ;
import java. util. TreeMap ;
public class CompMapImpl {
public static void main ( String [ ] args) {
HashMap < Integer , String > hashMap = new HashMap < > ( ) ;
TreeMap < Integer , String > treeMap = new TreeMap < > ( ) ;
LinkedHashMap < Integer , String > linkedHashMap = new LinkedHashMap < > ( ) ;
hashMap. put ( 5 , "Ivy" ) ;
hashMap. put ( null , "Joker" ) ;
hashMap. put ( 1 , "First" ) ;
hashMap. put ( 2 , "Kyle" ) ;
hashMap. put ( - 2 , "Paul" ) ;
hashMap. put ( 3 , "Sandy" ) ;
treeMap. put ( 5 , "Ivy" ) ;
treeMap. put ( 1 , "First" ) ;
treeMap. put ( 2 , "Kyle" ) ;
treeMap. put ( - 2 , "Paul" ) ;
treeMap. put ( 3 , "Sandy" ) ;
linkedHashMap. put ( 5 , "Ivy" ) ;
linkedHashMap. put ( null , "Joker" ) ;
linkedHashMap. put ( 1 , "First" ) ;
linkedHashMap. put ( 2 , "Kyle" ) ;
linkedHashMap. put ( - 2 , "Paul" ) ;
linkedHashMap. put ( 3 , "Sandy" ) ;
System . out. println ( "HashMap" ) ;
System . out. println ( hashMap) ;
System . out. println ( "TreeMap" ) ;
System . out. println ( treeMap) ;
System . out. println ( "LinkedHashMap" ) ;
System . out. println ( linkedHashMap) ;
LinkedHashMap < String , String > linkedHashMap1= new LinkedHashMap < > ( ) ;
linkedHashMap1. put ( null , "Andy" ) ;
System . out. println ( linkedHashMap1) ;
}
}
ืืืื ืืชืืฆืื ืฉื ืืคืขืืช ืชืืื ืืช ืื:
HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}
ืืคื ืฉืื ื ืืืืืื ืืจืืืช, ืกืืจ ืืืืื ืืื ื-HashMap ืืื ื ืืจืืจ, ื-treeMap ืื ืชืืื ืืืคืชืืืช, ื-LinkedHashMap ืืืืืจ ืขื ืกืืจ ืืื ืกื. ืื ื ื ืกื ืืืื ืืก ืืคืชื null ืืชืื linkedHashMap, ื ืงืื ืืช NullPointerException, ืืื ื-linkedHashMap1, ืืืฉืจ ืืืคืชืืืช ืื String, ื ืืื ืืขืฉืืช ืืืช. ืืคืช hash ืืื ืืืืืืฉ ืืืื ืืืืชืจ ืฉื ืืคื ืืฉืืืืฉ ืืืื. ืืื ืืกืคืง ืืืืจืืช ืืืคืืฉ ืืงืกืืืืืช, ืคืขืืืืช ืืืกืื ืืืืืืจ ืืืืจืืช, ืื ืืืื ืืืืืจ ืืช ืืกืืจ ืืืืืื ืฉืื. ืืคืช hash ืืงืืฉืจืช ืืืจืฉืช ืืช ืืชืจืื ืืช HashMap ืืืงืืืช ืืืื ื ืืืคืชืืืช. ืขื ืืืช, ืืื ืืืื linkedList, ืฉืืื ืืงืจ ืืืกืืช ืืืืื ืช ืืืืจืื. ืื ืืืื ืืืชืจ ื-HashMap ืืืืคืืฉ ืืงืฆืช ืืืชืจ ืืืื ืืืืกืคื/ืืกืจื ืืืื ืฉืืืจื ืขื ืจืฉืืื ืืงืืฉืจืช. ืืคืช ืขืฅ ืืืืกื ืช ืืคืชืืืช ืืืืื ืื ืืกืืจ ืขืืื. ืขื ืืืช, ืืื ืืฆืืข ืืืฆืืขืื ืืืืืื ืืจืืขืื ืืืชืจ ืืืฉืจ HashMap ื-LinkedHashMap.
ืืื ืืืืง ืืช ืื ืฉืืืืช, ืื ื ืืฆืืขืื ืื ืืฆืคืืช ืืฉืืขืืจ ืืืืื ืืงืืจืก Java ืฉืื ื
GO TO FULL VERSION