概述
0--星期日
1--星期一
...
有对应关系，对应关系的一方是有序的数字，可以将数字作为角标。
public String getWeek(int num){
if(num<0 || num>7)
throw new NoWeekException(num+"没有对应的星期");
String[] weeks = {"","星期一"...."星期日"};//一张表。记录对应关系。换成List集合。
return weeks[num];
}
新需求：
"星期一"--"Monday"
....
"星期日"--"Sunday"
也存在对应关系，没有一方是有序的数字，无法作为角标存在。咋办?
0--星期日
1--星期一
...
int index = listcn.indexOf("星期一")
listen.get(index);
0--Sunday
1--Monday
...
解决中英对应问题，可以通过两个List完成。
一个list中通过中文获取对应角标。在用角标到另一个英文list中获取对应的星期英文。
前提：必须保证中英文对应的角标是一致的。
麻烦！Collection集合一次只能存储一个元素。希望的将两个有对应关系的一次都存储进去。这样更便于操作。
集合框架中是否有提供解决方案？找到了Map集合。
Map
Map
|--Hashtable：数据结构：哈希表。是同步的，不允许null作为键和值。被hashMap替代。
|--Properties：属性集，键和值都是字符串，而且可以结合流进行键值的操作。
|--HashMap：数据结构：哈希表。不是同步的，允许null作为键和值。
|--LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。
|--TreeMap：数据结构：二叉树。不是同步的。可以对map集合中的键进行排序。
什么时候使用map集合呢？
分析问题时出现对应关系，毫不犹豫的想到map集合。
如果对应关系中出现了有序的数字，想到数组。
注意：如果对应关系个数不确定，还是以map为主。
Map集合特点
1，内部存储的都是键key值value对。
2，必须要保证的键的唯一性。
Map常见功能
1，存储。v put(k,v);
2，获取。v get(k);
3，移除。v remove(k);
4，Set<k> keySet();
5，Set<Map.Entry<k,v>> entrySet();
6，Collection<v> values();
Map基本使用
public static void main(String[] args) {
/*
* 存储中英文星期。
* 使用map集合。
*/
Map<String,String> map = new HashMap<String,String>();
//添加元素。
System.out.println(map.put("星期一", "Monday"));
// System.out.println(map.put("星期一", "Mon"));//如果键相同，值覆盖。并put方法会返回旧值。如果没有旧值就null。
//....
map.put("星期日", "Sunday");
//通过给定键获取值。
String value = map.get("星期二");//如果键 不存在，返回null，通过此判断键的是否存在。
System.out.println("value="+value);
//删除元素。根据键删除。
String s = map.remove("星期一");//获取给定键对应的值，并将该键值对从map集合删除。
System.out.println("s="+s);
System.out.println(map);
}
-
keySet()、entrySet()、values()
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("星期一", "Monday");
map.put("星期日", "Sunday");
System.out.println("------------keySet方法的获取---------------");
// System.out.println(map.get("星期一"));
//怎么获取到所有的键呢？既然是所有的键，应该是一个集合，而且是一个单列集合。
//list还是set呢？应该是set，因为map集合中键需要保证唯一性。
//找到一个方法 Set<k> keySet();获取map集合中的键的set集合。
Set<String> keySet = map.keySet();
for(Iterator<String> it= keySet.iterator(); it.hasNext() ; ){
String key = it.next();
String value = map.get(key);//通过键获取对应的值。
System.out.println(key+"::"+value);
}
//使用foreach循环，进行遍历。
for(String key : keySet){
System.out.println(key+":::::"+map.get(key));
}
System.out.println("-----------entrySet方法获取----------------");
/*
* Set entrySet():将map集合中映射关系存储到了Set集合中.
* 映射关系：其实就是指键和值的对应关系。其实就是夫妻的结婚证。
* 映射关系是什么类型的呢？ Map.Entry
*/
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
//遍历Set中的映射关系对象。
while(it.hasNext()){
Map.Entry<String, String> me = it.next();//取到了映射关系对象。
//获取键。
String key = me.getKey();
//获取值。
String value = me.getValue();
System.out.println(key+"-----"+value);
}
/*
* 总结：map集合没有迭代器，取出元素的方式：将map集合转成单列结合，在使用单列集合的迭代器就可以了。
* map集合也不能直接被foreach循环遍历。
*/
for(Map.Entry<String,String> me : map.entrySet()){
String key = me.getKey();
//获取值。
String value = me.getValue();
System.out.println(key+"--------"+value);
}
System.out.println("-----------获取所有值的方法 values()----------------");
/*
* 获取所有的值，因为值不需要保证唯一性。所以返回类型时Collection。
* 姓名--归属地。对应关系，获取所有的归属地。values();
*/
//所有的英文星期。
Collection<String> values = map.values();
for(String value : values){
System.out.println("value:"+value);
}
}
}
图解
HashMap存储自定义对象
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
public class HashMapTest {
public static void main(String[] args) {
/*
* 练习一：
* 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。
* 将学生对象和归属地存储到map集合中。
* 注意：同姓名同年龄视为重复的键。
*/
//1,创建hashmap集合对象。
Map<Student,String> map = new HashMap<Student,String>();
//2,添加元素。
map.put(new Student("lisi",28), "上海");
map.put(new Student("wangwu",22), "北京");
map.put(new Student("zhaoliu",24), "成都");
map.put(new Student("zhouqi",25), "广州");
map.put(new Student("wangwu",22), "南京");
//3,取出元素。keySet entrySet
// Set<Student> keySet = map.keySet();
// for(Student key : keySet){}
for(Student key : map.keySet()){
String value = map.get(key);
System.out.println(key.toString()+"....."+value);
}
}
}
TreeMap存储自定义对象
public class ComparatorByName implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0?o1.getAge() - o2.getAge() : temp;
}
}
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Student o) {
int temp = this.age - o.age;
return temp==0?this.name.compareTo(o.name):temp;
}
}
public class TreeMapTest {
/**
* @param args
*/
public static void main(String[] args) {
/*
* 练习二： 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。 将学生对象和归属地存储到map集合中。
* 注意：同姓名同年龄视为重复的键。 按照学生的年龄进行从小到大的排序。 TreeMap。
*
* 如果要对学生按照姓名排序呢？
*/
// 1,创建TreeMap集合对象。
Map<Student, String> map = new TreeMap<Student, String>(new ComparatorByName());
// 2,添加元素。
map.put(new Student("lisi", 28), "上海");
map.put(new Student("wangwu", 22), "北京");
map.put(new Student("zhaoliu", 24), "成都");
map.put(new Student("zhouqi", 25), "广州");
map.put(new Student("wangwu", 22), "南京");
//3,取出所有元素，entrySet()
for(Map.Entry<Student, String> me : map.entrySet()){
Student key = me.getKey();
String value = me.getValue();
System.out.println(key+"::"+value);
}
}
}
