黑马程序员_集合类

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

Map

   |--HashTable :底层数据结构为哈希表，不可以存入null键null值，该集合是线性同步；
   |--HashMap :底层是哈希表数据结构允许使用null键和null值，该集合是不同步的；
   |--TreeMap :底层是二叉树数据结构，线程不同步，可以给Map中的集合进行排序。
 
该集合存储键值对，一对一的往里存，而且保证键的唯一性；

Map集合常见操作：

添加：添加元素时，若出现相同的键，那么后边添加的值会覆盖原有键对应值。
put(K key,V value)
putAll(Map<? extends K,? extendsV> t)

删除：
clear()：从此映射中移除所有映射关系；
remove(Object key)：如果存在此键的映射关系，则将其从映射中移除；

判断：
containsValue(Object value)：  如果此映射为指定值映射一个或多个键，则返回true。
containsKey(Object key)：如果此映射包含指定键的映射关系，则返回true。
isEmpty()
获取：
get(Object key)：返回此映射中映射到指定键的值，可以通过get方法返回值判断一个键是否存在，能过返回NULL来判断；
size()： 返回此映射中的键-值映射关系数。
values()：返回此映射中包含的值的 collection视图。

JAVA代码实现如下：

package com.test.map;
import java.util.*;
public class MapDemo {

	public static void main(String[] args) {
		Map<String, String> param=new HashMap<String, String>();
		//添加元素，添加元素，若添加时出现相同的键，那么后添加的值会覆盖原有键对应的值，
		//并且put方法会返回被覆盖的值
		param.put("01", "java01");
		sop(param.put("01", "java"));
		param.put("02", "java02");
		sop(param);

		//删除元素
		//param.clear();
		param.remove("01");
		sop(param);
		//判断
		sop(param.containsKey("02"));
		sop(param.containsValue("java02"));
		sop(param.isEmpty());
		//获取
		param.put("03", null);
		sop(param.get("03"));//可以通过get方法的返回值来判断一个键是否存在，通过返回NULL来判断。
		

	}
	public static void sop(Object obj){
		System.out.println(obj);
	}

}

keySet()：返回此映射中包含的键的 set 视图；
 将map中所有的键存入到set集合，因为set具备迭代器，可以用迭代方式取出所有的键，再根据get方法获取每一个键对应的值.

JAVA代码示例如下：

package com.test.map;

import java.util.*;
public class MapDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String, String> param=new HashMap<String, String>();
		param.put("01", "java01");
		param.put("02", "java02");
		param.put("03", "java03");
		
		//使用Map集合中的keySet方法获取映射中包含的键的 set 视图。
		Set<String> set=param.keySet();
		//使用Set集合获取迭代器
		Iterator<String> it=set.iterator();
		while(it.hasNext()){
			String key=it.next();
			//有了键之后，就可以使用Map集合的get方法获取对应的值。
			String value=param.get(key);
			System.out.println("key:"+key+" value:::"+value);
		}
	}
}

entrySet()：返回此映射中包含的映射关系的 set 视图；
将Map集合中的映射关系存入到set集合中而这个关系的数据类型就是：Map.Entry,
Map.Entry中Entry也是一个接口，它是Map接口的一个内部接口。

package com.test.map;
/**
 * entrySet() 方法
 * @author jessiFan
 *
 */
import java.util.*;
public class MapDemo3 {

	public static void main(String[] args) {
		Map<String, String> param=new HashMap<String, String>();
		param.put("01", "java01");
		param.put("02", "java02");
		
	      Set<Map.Entry<String, String>>  entrySet=param.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::"+key+"value:::"+value);
	      }
	}
}

Map练习：

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

package com.test.map;

import java.util.*;
public class MapTest {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<Student, String> map=new HashMap<Student, String>();
		map.put(new Student("java01", 10), "武汉");
		map.put(new Student("java02", 20), "杭州");
		map.put(new Student("java03", 30), "上海");
		
		Set<Student> set=map.keySet();
		Iterator<Student> it=set.iterator();
		while(it.hasNext()){
			Student key=it.next();
			String value=map.get(key);
			System.out.println(key+"::"+value);
		}
	}
}


class Student implements Comparable<Student>{
	private String name;
	private int age;
	Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	public int compareTo(Student s){
	  int num=new Integer(this.age).compareTo(new Integer(s.age));
	  if(num==0)
		  return this.name.compareTo(s.name);
	return num;
	}
	
	public int  hashCode(){
		return name.hashCode()+age*34;
	}
	
	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 String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public String toString(){
		return name+":"+age; 
	}
}

2、 对学生对象姓名升序排序，因为键值对存储，所以要用TreeMap

JAVA代码实现如下：

package com.test.map;

import java.util.*;
/**
 * 按学生姓名排序
 * @author jessiFan
   *
 */
public class MapTest2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<Student, String> param=new TreeMap<Student, String>(new myComparator());
		param.put(new Student("lisi01",23), "shanghai");
		param.put(new Student("lisi022",22), "beijing");
		param.put(new Student("lisi03",18), "wuhan");
		param.put(new Student("lisi01", 40),"hangzhou");
		
		
		 Set<Map.Entry<Student, String>> entryset = param.entrySet();
		 Iterator<Map.Entry<Student, String>> it=entryset.iterator();
		 while(it.hasNext()){
			 Map.Entry<Student, String> me=it.next();
			 Student stu=me.getKey();
			 String adr=me.getValue();
			 System.out.println(stu+"::"+adr);
		 }
	}
}

class myComparator  implements Comparator<Student>{
	
	@Override
	public int compare(Student o1, Student o2) {
		// TODO Auto-generated method stub
		int num=o1.getName().compareTo(o2.getName());
		if(num==0)
			return new Integer(o1.getAge()).compareTo(o2.getAge());
		return num;
	}
	
}

3、  字母在字符串中出现的次数，打印格式为： a()b()c()

package com.test.map;
/**aabbccdd
 * 字母中字符串出现的次数。
 * @author jessiFan
 *
 */
import java.util.*;
public class MapTest3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		charCount("aabbccdd");

	}
	public static void charCount(String str){
		char[] ch=str.toCharArray();
		Map<Character,Integer> param=new TreeMap<Character, Integer>();

		for(int i=0;i<ch.length;i++){
			Integer value=param.get(ch[i]);
			if(value==null)
				param.put(ch[i], 1);
			else {
				value=value+1;
				param.put(ch[i], value);
			}
		}
		System.out.println(param);
		StringBuilder sb=new StringBuilder();
		Set<Character> keySet=param.keySet();
		Iterator<Character> it=keySet.iterator();
		while(it.hasNext()){
			Character key=it.next();
			Integer value=param.get(key);
			sb.append(key+"("+value+")");
		}
		
		System.out.println(sb.toString());
	}

}