import java util_import java.util.Map

import java.util.HashMap;

import java.util.Map;

/**

* java.util.Map

* Map看起来像是一个多行两列的表格。

* 以key-value对的形式存放元素。

* 在Map中key不允许重复(重复是依靠key的equals判断)

* 常用的实现类为HashMap

* @author LZQ

*

*/

public class MapDemo1 {

public static void main(String[] args) {

Map map = new HashMap();

/*

* V put(K k,V v)

* 将给定的key-value存入Map

* 由于Map要求key不允许重复，所以使用Map

* 已有的key存入一个新的value时的操作是

* 替换value，那么返回值为该key原来对应的

* value。若是一个新的key，则返回值为null。

*/

Integer value = map.put("语文", 99);

map.put("数学", 98);

map.put("英语", 97);

map.put("物理", 96);

map.put("化学", 99);

System.out.println(map);

value = map.put("语文", 98);

System.out.println(map);

System.out.println("old:"+value);

/*

* V get(K k)

* 根据给定的key获取对应的value，若当前

* Map中没有给定的key，则返回值为null

*/

value = map.get("数学");

System.out.println("数学:"+value);

value = map.get("体育");

System.out.println("体育："+value);

/*

* V remove(K k)

* 删除给定的key所对应的key-value对。

* 返回值为被删除的key-value对中的value。

*/

System.out.println("删除数学!");

value = map.remove("数学");

System.out.println(map);

System.out.println("old:"+value);

}

}

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

/**

* 遍历Map

* 遍历Map有三种方式:

* 遍历所有的key

* 遍历所有的key-value对

* 遍历所有的value(相对不常用)

* @author LZQ

*

*/

public class MapDemo2 {

public static void main(String[] args) {

Map map =

new HashMap();

map.put("语文", 99);

map.put("数学", 98);

map.put("英语", 97);

map.put("物理", 96);

map.put("化学", 99);

System.out.println(map);

/*

* 遍历所有的key

* Set keySet()

* 该方法会将当前Map中所有的key存入一个

* Set集合后返回。那么遍历该集合就等于遍历

* 了所有的key

*/

Set keySet = map.keySet();

for(String key:keySet) {

System.out.println("key:"+key);

}

/*

* 遍历每一组键值对

* Map中每一组键值对都是由Map的内部类：

* java.util.Map.Entry的一个实例表示的。

* Entry有两个方法：getKey,getValue,可以

* 分别获取这一组键值对中的key和value。

*

* Set entrySet

* 该方法会将Map中每一组键值对(Entry实例)

* 存入一个Set集合后返回。

*/

Set> entrySet =

map.entrySet();

for(Entry e:entrySet) {

String key = e.getKey();

Integer value = e.getValue();

System.out.println(key+":"+value);

}

/*

* 遍历所有的value

* Collection values()

* 该方法会将当前Map中所有的value存入一个

* 集合后返回。

*/

Collection values =

map.values();

for(Integer value:values) {

System.out.println("value:"+value);

}

}

}

/**

* 当一个类的实例作为HashMap的key时，它的

* equals方法与hashcode方法的重写直接影响着

* 散列表(HashMap)的查询性能。

* 在API文档中Object对这两个方法的重写做了说明：

* 当我们重写一个类的equals方法时，就应当连同重写

* hashcode方法。

* 这两个方法应当遵循：

* 1：一致性，当两个对象equals比较为true时，hashcode

* 方法返回的数字必须相等。反过来虽然不是必须的，但

* 也应当遵循，否则在HashMap中会形成链表影响查询性能。

* 所以两个对象hashcode值相同，equals比较也应当为true

* 2：稳定性：hashcode方法多次调用后返回的数字应当相同，不应

* 是一个变化的值，除非参与equals比较的属性值发生了改变。

* @author LZQ

*

*/

public class Key {

private int x;

private int y;

public Key(int x, int y) {

super();

this.x = x;

this.y = y;

}

public int getX() {

return x;

}

public void setX(int x) {

this.x = x;

}

public int getY() {

return y;

}

public void setY(int y) {

this.y = y;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + x;

result = prime * result + y;

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Key other = (Key) obj;

if (x != other.x)

return false;

if (y != other.y)

return false;

return true;

}

}