黑马程序员—集合

------- android培训、java培训、期待与您交流！ ----------

集合
Map<K,V>接口
该集合存储键值对，而且要保证键的唯一性
常见方法
1.添加
put(K key, V value);
putAll(Map<? extends K,? extends V> m)
2.删除
clear();
remove(Object key);
3.判断
containsKey(Object key);
containsValue(Object value);
isEmpty();
4.获取
get(Object key);
size();
values();


Map
--Hashtable :底层是哈希表数据结构，不可以存入NULL作为键或者值得情况。该集合是线程同步的。JDK1.0，效率低
--HashMap :底层是哈希表数据结构，允许使用NULL键，NULL值，该集合是不同步的。JDK1.2，效率高
--TreeMap :底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序


和Set很像，Set底层就是使用了Map集合


eg:
class MapDemo
{
public static void main(String[] args){
Map<String,String> map = new HashMap<String, String>();
// 添加元素时，如果出现相同的键，后添加的值会覆盖原有键对应值，并且put方法会返回被覆盖的值
System.out.println(map.put("01","zhangsan1")); // 返回null
System.out.println(map.put("01","wangwu")); // 返回zhangsan1
map.put("02","zhangsan2");
map.put("03","zhangsan3");
System.out.println("containsKey:"+map.containsKey("02"));// containsKey:true
System.out.println("remove:"+map.remove("02"));// remove:zhangsan2
System.out.println(map); //{01=wangwu, 03=zhangsan3}


System.out.println("get:"+map.get("02")); //get:null


Collection<String> coll = map.values();
System.out.println(coll); // [wangwu, zhangsan3]


}
}


Map集合的两种取出方式
1).Set<k> :将map中所有的键存入到Set集合，因为Set具备迭代器,再根据get方法，获取每个键对应的值
Map集合取出原理，将map集合转成set集合，通过迭代器取出
2).Set<Map.EntrySet<k,v>> :将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是，Map.Entry


eg:
Map<String,String> map = new HashMap<String, String>();
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("04","zhangsan4");


//第一种方式
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while(it.hasNext()){
String key = it.next();
String value = map.get(key);
System.out.println(key+"="+value);
}


//第二种方式
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"="+value);
}


Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口
interface Map
{
public static interface Entry// 对外暴露的内部静态接口(只有放在成员位置，才能被static修饰)
{
public abstract Object getKey();
public abstract Object getValue();
}
}


TreeMap的练习题
练习1：
每一个学生都有对应的归属地
学生Student,地址String
学生属性：姓名，年龄
注意：姓名年龄相同的视为同一个学生，保证学生的唯一性


1.描述学生
2.定义map容器，将学生作为键，地址作为值，存入
3.获取map集合中的元素


class Student implements Comparable<Student>{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}


public int hashCode(){
return this.name.hashCode()+this.age*39 ;
}
public boolean equals(Object obj){
if(!(obj instanceof Student))
throw new ClassCastException("引用数据类型错误");
Student s = (Student)obj;
return this.name.equals(s.name) && this.age==s.age;
}

public int compareTo(Student o) {
int num = new Integer(this.age).compareTo(new Integer(o.age));
if(num==0)
return this.name.compareTo(o.name);
return num;
}
}


class comp implements Comparator<Student>{
public int compare(Student o1, Student o2){
int num = o1.getName().compareTo(o2.getName());
if(num==0)
return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
return num;
}
}


练习2：
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数
希望打印结果：a[1]c[2]....


通过结果发现，每个字母都对应一个次数
public static String getCharCount(String str){
TreeMap<Character, Integer> hm = new TreeMap<Character, Integer>();


char[] ch = str.toCharArray();
for(int x = 0; x < ch.length; x++){
if(!hm.containsKey(ch[x])){
hm.put(ch[x], new Integer(1));
}else{
hm.put(ch[x], hm.get(ch[x])+1);
}
}

StringBuilder strB = new StringBuilder();
Set<Character> keySet = hm.keySet();
Iterator<Character> it = keySet.iterator();
while(it.hasNext()){
char c = it.next();
strB.append(c+"["+hm.get(c)+"]");
}
return strB.toString();
}
Character 实现了Comparable接口，所以不需要再写排序