Java by API/java.util/Map
Содержание
- 1 implements Map
- 2 java.util.Map.Entry<K, V>
- 3 Map: clear()
- 4 Map: containsKey(Object key)
- 5 Map: containsValue(Object value)
- 6 Map.Entry: getKey()
- 7 Map.Entry: getValue()
- 8 Map: equals(Object o)
- 9 Map: get(Object key)
- 10 Map: keySet()
- 11 Map: putAll(Map<?, ?> m)
- 12 Map: put(T key, T value)
- 13 Map: remove(Object key)
- 14 Map: size()
- 15 Map: values()
implements Map
<source lang="java">
/* You asked about Google. They are located in: null Key Adobe; Value Mountain View, CA Key IBM; Value White Plains, NY Key Learning Tree; Value Los Angeles, CA entrySet() returns 3 Map.Entry"s*/ import java.util.AbstractSet; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.TreeSet; public class MainClass {
public static void main(String[] argv) { Map map = new MyMap(); map.put("Adobe", "Mountain View, CA"); map.put("Learning Tree", "Los Angeles, CA"); map.put("IBM", "White Plains, NY"); String queryString = "Google"; System.out.println("You asked about " + queryString + "."); String resultString = (String) map.get(queryString); System.out.println("They are located in: " + resultString); System.out.println(); Iterator k = map.keySet().iterator(); while (k.hasNext()) { String key = (String) k.next(); System.out.println("Key " + key + "; Value " + (String) map.get(key)); } Set es = map.entrySet(); System.out.println("entrySet() returns " + es.size() + " Map.Entry"s"); }
} class MyMap implements Map {
private ArrayList keys; private ArrayList values; public MyMap() { keys = new ArrayList(); values = new ArrayList(); } /** Return the number of mappings in this Map. */ public int size() { return keys.size(); } /** Return true if this map is empty. */ public boolean isEmpty() { return size() == 0; } /** Return true if o is contained as a Key in this Map. */ public boolean containsKey(Object o) { return keys.contains(o); } /** Return true if o is contained as a Value in this Map. */ public boolean containsValue(Object o) { return keys.contains(o); } /** Get the object value corresponding to key k. */ public Object get(Object k) { int i = keys.indexOf(k); if (i == -1) return null; return values.get(i); } /** * Put the given pair (k, v) into this map, by maintaining "keys" in sorted * order. */ public Object put(Object k, Object v) { for (int i = 0; i < keys.size(); i++) { Object old = keys.get(i); /* Does the key already exist? */ if (((Comparable) k).rupareTo(keys.get(i)) == 0) { keys.set(i, v); return old; } /* * Did we just go past where to put it? i.e., keep keys in sorted order. */ if (((Comparable) k).rupareTo(keys.get(i)) == +1) { int where = i > 0 ? i - 1 : 0; keys.add(where, k); values.add(where, v); return null; } } // Else it goes at the end. keys.add(k); values.add(v); return null; } /** Put all the pairs from oldMap into this map */ public void putAll(java.util.Map oldMap) { Iterator keysIter = oldMap.keySet().iterator(); while (keysIter.hasNext()) { Object k = keysIter.next(); Object v = oldMap.get(k); put(k, v); } } public Object remove(Object k) { int i = keys.indexOf(k); if (i == -1) return null; Object old = values.get(i); keys.remove(i); values.remove(i); return old; } public void clear() { keys.clear(); values.clear(); } public java.util.Set keySet() { return new TreeSet(keys); } public java.util.Collection values() { return values; } /** * The Map.Entry objects contained in the Set returned by entrySet(). */ private class MyMapEntry implements Map.Entry, Comparable { private Object key, value; MyMapEntry(Object k, Object v) { key = k; value = v; } public Object getKey() { return key; } public Object getValue() { return value; } public Object setValue(Object nv) { throw new UnsupportedOperationException("setValue"); } public int compareTo(Object o2) { if (!(o2 instanceof MyMapEntry)) throw new IllegalArgumentException("Huh? Not a MapEntry?"); Object otherKey = ((MyMapEntry) o2).getKey(); return ((Comparable) key).rupareTo((Comparable) otherKey); } } /** The set of Map.Entry objects returned from entrySet(). */ private class MyMapSet extends AbstractSet { List list; MyMapSet(ArrayList al) { list = al; } public Iterator iterator() { return list.iterator(); } public int size() { return list.size(); } } /** * Returns a set view of the mappings contained in this Map. Each element in * the returned set is a Map.Entry. NOT guaranteed fully to implement the * contract of entrySet declared in java.util.Map. */ public java.util.Set entrySet() { if (keys.size() != values.size()) throw new IllegalStateException("InternalError: keys and values out of sync"); ArrayList al = new ArrayList(); for (int i = 0; i < keys.size(); i++) { al.add(new MyMapEntry(keys.get(i), values.get(i))); } return new MyMapSet(al); }
}
</source>
java.util.Map.Entry<K, V>
<source lang="java">
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); Set set = map.entrySet(); Iterator iter = set.iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); System.out.println(entry.getKey() + " -- " + entry.getValue()); } }
}
</source>
Map: clear()
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); map.clear(); System.out.println(map); }
}
</source>
Map: containsKey(Object key)
<source lang="java">
import java.util.HashMap; import java.util.Map; class Counter {
int i = 1; public String toString() { return Integer.toString(i); }
} public class Main {
public static void main(String[] args) { Map hm = new HashMap(); for (int i = 0; i < 10; i++) { Integer r = new Integer(20); if (hm.containsKey(r)) ((Counter) hm.get(r)).i++; else hm.put(r, new Counter()); } System.out.println(hm); }
}
</source>
Map: containsValue(Object value)
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); System.out.println(map.containsKey("key1")); System.out.println(map.containsValue("value2")); }
}
</source>
Map.Entry: getKey()
<source lang="java">
import java.util.Iterator; import java.util.Map; import java.util.Properties; public class Main {
public static void main(String[] a) { Properties props = System.getProperties(); Iterator iter = props.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); System.out.println(entry.getKey() + " -- " + entry.getValue()); } }
}
</source>
Map.Entry: getValue()
<source lang="java">
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); Set set = map.entrySet(); Iterator iter = set.iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); System.out.println(entry.getKey() + " -- " + entry.getValue()); } }
}
</source>
Map: equals(Object o)
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); Map<String,String> map2 = new HashMap<String,String>(); map2.put("key2", "value2"); map2.put("key1", "value1"); map2.put("key3", "value3"); System.out.println(map2.equals(map2)); }
}
</source>
Map: get(Object key)
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main{
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); System.out.println(map.get("key2")); }
}
</source>
Map: keySet()
<source lang="java">
/* Key Adobe; Value Mountain View, CA Key IBM; Value White Plains, NY Key Learning Tree; Value Los Angeles, CA
- /
import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class MainClass {
public static void main(String[] argv) { Map map = new HashMap(); map.put("Adobe", "Mountain View, CA"); map.put("IBM", "White Plains, NY"); map.put("Learning Tree", "Los Angeles, CA"); Iterator k = map.keySet().iterator(); while (k.hasNext()) { String key = (String) k.next(); System.out.println("Key " + key + "; Value " + (String) map.get(key)); } }
}
</source>
Map: putAll(Map<?, ?> m)
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); map.put(null, null); Map<String,String> map2 = new HashMap<String,String>(); map2.put("key4", "value4"); map2.put("key5", "value5"); map2.put("key6", "value6"); map.putAll(map2); System.out.println(map); }
}
</source>
Map: put(T key, T value)
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String, String> map = new HashMap<String, String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); System.out.println(map); }
}
</source>
Map: remove(Object key)
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); map.remove("key3"); System.out.println(map); }
}
</source>
Map: size()
<source lang="java">
import java.util.HashMap; import java.util.Map; public class Main{
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); System.out.println(map.size()); }
}
</source>
Map: values()
<source lang="java">
import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class Main {
public static void main(String[] a) { Map<String,String> map = new HashMap<String,String>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); Collection set = map.values(); Iterator iter = set.iterator(); while (iter.hasNext()) { System.out.println(iter.next()); } }
}
</source>