黑马程序员--- 学习笔记(第十六天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
Map集合:
该集合存储键值对,一对一对往里存,而且要保证键的唯一性


Map
|--HashTable
|--HashMap
|--TreeMap


HashTable:
底层是哈希表数据结构,不可以存入null键和null值,该集合是线程同步的,JDK1.0,效率低


HashMap:
底层是哈希表数据结构,允许null键和null值,该集合是线程不同步的,JDK1.2,效率高


TreeMap
底层是二叉树数据结构,线程是不同步的,可以用于给Map集合中的键进行排序


和Set集合很像,其实Set底层就是使用了Map集合


可以通过get方法的返回值判断一个键是否存在通过返回null来判断


Map集合共性方法:
1.删除
clear();
remove();
2.判断
containsKey();
containsValue();
equals();
isEmpty();
3.获取
get();
size();
Values();
entrySet();
keySet();
4.添加
put();
putAll();

/*
Map共性方法

测试
*/
import java.util.*;
class Demo1 
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>();
//	 V put(K key, V value) 
//			  将指定的值与此映射中的指定键关联（可选操作）。 
		map.put("a1","11");
		map.put("a6","16");
		map.put("a3","13");
		TreeMap<String,String> treeMap=new TreeMap<String,String>();
		treeMap.put("a5","15");
		treeMap.put("a3","33");
//	 void putAll(Map<? extends K,? extends V> m) 
//			  从指定映射中将所有映射关系复制到此映射中（可选操作）。 
		map.putAll(treeMap);
//	 boolean containsKey(Object key) 
//			  如果此映射包含指定键的映射关系，则返回 true。
		sop(map.containsKey("a6"));
//	 boolean containsValue(Object value) 
//			  如果此映射将一个或多个键映射到指定值，则返回 true。 
		sop(map.containsValue("13"));
//	boolean equals(Object o) 
//			  比较指定的对象与此映射是否相等。 
		sop(map.equals("a1"));
//	 V get(Object key) 
//			  返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
	sop(map.get("a3"));
//	 boolean isEmpty() 
//			  如果此映射未包含键-值映射关系，则返回 true。  
	 sop(map.isEmpty());
//	 V remove(Object key) 
//			  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 
	 sop("remove:::"+map.remove("a3"));
//	 int size() 
//			  返回此映射中的键-值映射关系数。 
	 sop(map.size());
//		 void clear() 
//			  从此映射中移除所有映射关系（可选操作）。 
	//map.clear();
//	 Collection<V> values() 
//			  返回此映射中包含的值的 Collection 视图。
	Collection<String> al=new ArrayList<String>();
		al=map.values();
		//父类无法使用子类的方法
		//ListIterator<String> l=al.listIterator();
		Iterator<String> it=al.iterator();
		for (; it.hasNext(); )
		{		 
			sop(it.next());
		}
	}
	public static void sop(Object o){
		System.out.println(o);	
	}
}

Map集合中添加元素时,当有相同的键时,新增加的值会替换原有的值,通过get方法


keySet
将Map集合所有的键存入到Set集合,因为Set集合具有迭代器,所以可以
通过迭代方式取出所有值,通过值get方法

/*
keySet 测试
*/
import java.util.*;
class Demo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>(); 
		map.put("a1","11");
		map.put("a6","16");
		map.put("a3","13");
		/*返回set集合 字符串自身具备默认比较性*/
		Set<String> keySet=map.keySet();

		Iterator<String> it=keySet.iterator();
		/*遍历获取键 ,在获取值*/
		for (;it.hasNext() ; )
		{
			String key=it.next();
			String value=map.get(key);
			System.out.println(key+"::"+value);
		}
	}
}

entrySet
返回Set<Map.Entry<k,v>>,将Map集合的映射关系存入到了集合中,而这个关系
的数据类型是Map.Entry

/*
 Map.Entry
 测试
*/
import java.util.*;
class Demo3 
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>(); 
		map.put("a1","11");
		map.put("a6","16");
		map.put("a3","13");

		Set<Map.Entry<String,String>> s=map.entrySet();

		Iterator<Map.Entry<String,String>> it=s.iterator();

		for (;it.hasNext() ; )
		{
			/*it.next() 返回的是Map.Entry映射键值对*/
			Map.Entry<String,String> me=it.next();
			/*
				 K getKey() 
				  返回与此项对应的键。 
				 V getValue() 
				  返回与此项对应的值。 
			*/
			String key=me.getKey();
			String value=me.getValue();
			System.out.println(key+"::"+value);
		}
	}
}

Map.Entry其实Entry也是一个接口,它是Map接口中的内部接口
/*原理如下*/
interface Map
{
public static interface Entry
{
/*定义一些方法例如getKey,getValue*/
public abstract Object getKey();
public abstract Object getValue();
}
}


class HashMap implements Map
{
class Hash implements Map.Entry
{
  public Object getKey(){}
  public Object getValue(){}
}

}

/*
Map.Entry 

有Map才有Entry关系,
能直接使用外部类的成员
*/
class Demo4 
{
	public static void main(String[] args) 
	{
		new HM();
	}
}
/*
Map=M
Entry=E
*/
interface M
{
	public static interface E
	{
		public abstract void show();
	}
}
/*
HM=HashMap

H内部类实现M.E既是Map.Entry接口
*/
class HM implements M
{
	class H implements M.E
	{
		 public void show(){
			System.out.println("原理便是如此");
		 }
	}
}

练习 

/*
每个学生都有对应的家庭住址
学生都有姓名,年龄属性

对学生姓名进行升序排序,
*/
import java.util.*;
class Demo5 
{
	public static void main(String[] args) 
	{
		HashMap<Student,String> map=new HashMap<Student,String>();
		map.put(new Student("azhangsan",15),"北京");
		map.put(new Student("dlisi",19),"深圳");
		map.put(new Student("cwangwu",25),"东莞");
		//同一个键,新值会覆盖旧值
		//map.put(new Student("cwangwu",25),"伤害");

		Iterator<Map.Entry<Student,String>> it=map.entrySet().iterator();

		for (;it.hasNext() ; )
		{
			Map.Entry<Student,String> me=it.next();
			Student s=me.getKey();
			String value=me.getValue();

			System.out.println(s.getName()+"-"+value);
		}
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	public void setName(String name){
		 this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Student(String name, int age){
		this.name=name;
		this.age=age;
	}
	/*start 保证元素唯一性*/
	public int hashCode(){
		return (this.name.hashCode())+this.age*14;
	}

	public boolean equals(Object o){
		if(!(o instanceof Student))
			throw new ClassCastException();
		Student s=(Student)o;
		return this.name.equals(s.getName())&& this.age==s.getAge();
	}
	/*按照姓名排序 且保证元素唯一性*/
	public int compareTo(Student s1){
		int num=this.getName().compareTo(s1.getName());
		if(num==0)
			return new Integer(this.getAge()).compareTo(new Integer(s1.getAge()));

		return num;
	}
}

/*
使用TreeMap构造传入Comparator进行比较
*/
import java.util.*;
class Demo6 
{
	public static void main(String[] args) 
	{
		TreeMap<Student,String> ts=new TreeMap<Student,String>(new AgeSort());
		ts.put(new Student("azhangsan15",15),"北京");
		ts.put(new Student("dlisi19",19),"深圳");
		ts.put(new Student("cwangwu25",25),"东莞");

		Iterator<Map.Entry<Student,String>> it=ts.entrySet().iterator();

		for (;it.hasNext() ; )
		{
			Map.Entry<Student,String> me=it.next();
			Student s=me.getKey();
			String value=me.getValue();
			System.out.println(s.getName()+"=="+value);
		}
	}
}
/*学生类,自身具备年龄比较性*/
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	public void setName(String name){
		 this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Student(String name, int age){
		this.name=name;
		this.age=age;
	}
	/*start 保证元素唯一性*/
	public int hashCode(){
		return (this.name.hashCode())+this.age*14;
	}

	public boolean equals(Object o){
		if(!(o instanceof Student))
			throw new ClassCastException();
		Student s=(Student)o;
		return this.name.equals(s.getName())&& this.age==s.getAge();
	}
	/*按照姓名排序 且保证元素唯一性*/
	public int compareTo(Student s1){
		int num=this.getName().compareTo(s1.getName());
		if(num==0)
			return new Integer(this.getAge()).compareTo(new Integer(s1.getAge()));

		return num;
	}
}
/*
自定义比较器 按照年龄排序
*/
class AgeSort implements Comparator<Student>
{
	public int compare(Student s,Student s1){
		int num=new Integer(s.getAge()).compareTo(new Integer(s1.getAge()));
		if(num==0)
			return s.getName().compareTo(s1.getName());
		return num;
	}
}

/*
练习  输出字符串出现次数
adfkdjkncidksd
输出格式a(1)d(4)...
*/
import java.util.*;
class Demo7 
{
	public static void main(String[] args) 
	{
		String str=".adfkdjkncidks.d";
		/*
		
		 str=getResult(str);
		 System.out.println(str);
		  */
		 str=method(str);
		 System.out.println(str);
	}
	/*
	返回一个TreeMap集合
	*/
	private static TreeMap<Character,Integer>  getCount(String str){
		//字符串转数组
		char []ch=str.toCharArray();
		//TreeMap集合排序
		TreeMap<Character,Integer> map=new TreeMap<Character,Integer>();
		int count=0;
		for (int i=0;i<ch.length ;i++ )
		{	//如果不是大小写字母就不存进去集合
			if(!(ch[i]>='a' && ch[i]<='z')||(ch[i]>='A' && ch[i]<='Z'))
				continue;
			if(map.get(ch[i])!=null)
				count=map.get(ch[i]);
			count++;
			map.put(ch[i],count); //增加元素
			count=0;
		}
		return map;
	}
	/*
	返回结果
	*/
	public  static String getResult(String str){
		//TreeMap接收getCount的放回集合
		TreeMap<Character,Integer> map=getCount(str);
		//迭代器
		Iterator<Map.Entry<Character,Integer>> it=map.entrySet().iterator();
		//字符串缓冲区
		StringBuilder sb=new StringBuilder();
		for (;it.hasNext() ; )
		{
			//获取映射关系键值对
			Map.Entry<Character,Integer> me=it.next();
			//在字符串缓冲区后面追加
			sb.append(me.getKey()+"("+me.getValue()+")");
		}
		return sb.toString(); //返回结果
	}
	/*一个方法完成*/ 
	public static String method(String str){
		char []ch=str.toCharArray();

		TreeMap<Character,Integer> ts=new TreeMap<Character,Integer>();
		int count=0;
		StringBuilder sb=new StringBuilder();
		for (int i=0;i<ch.length;i++ )
		{
			if(!((ch[i]>='a' && ch[i]<='z')||(ch[i]>='A' && ch[i]<='Z')))
				continue;
			if(ts.get(ch[i])!=null)
				count=ts.get(ch[i]);
			count++;
			ts.put(ch[i],count);
			count=0;
			
		}
		Iterator<Map.Entry<Character,Integer>> it=ts.entrySet().iterator();
			while(it.hasNext()){
				Map.Entry<Character,Integer>  me=it.next();
				sb.append(me.getKey()+"("+me.getValue()+")");
		}
		return sb.toString();
	} 
	
}

Map扩展

/*
Map扩展部分
一个学校,有多个班级,每个班级有多个学生
*/
import java.util.*;
class Demo8 
{
	public static void main(String[] args) 
	{
		/*
		//第一种方式 Map嵌套List
		HashMap<String,List<Student>> school=new HashMap<String,List<Student>>();
		
		ArrayList<Student> dian1=new ArrayList<Student>();
		dian1.add(new Student("潇洒哥",18));
		dian1.add(new Student("潇洒弟",50));

		ArrayList<Student> dian2=new ArrayList<Student>();
		dian2.add(new Student("美丽",18));
		dian2.add(new Student("皮埃",55));

		 
		school.put("电子一班",dian1);
		school.put("电子二班",dian2);

		Set<String> set=school.keySet();
		Iterator<String> it=set.iterator();
		while(it.hasNext()){
			String className=it.next();
			List<Student> li =school.get(className);
			System.out.println("班级名称:"+className);
			Iterator<Student> its=li.iterator();
			while(its.hasNext()){
				Student s=its.next();
				System.out.println(s.getName()+"--"+s.getAge());
			}
		}
		 */
		/*Map嵌套Map*/
		HashMap<String,HashMap<String,Integer>> hm=new HashMap<String,HashMap<String,Integer>>();
		
		HashMap<String,Integer> h=new HashMap<String,Integer>();
		h.put("哎",11);
		h.put("呦",21);
		HashMap<String,Integer> m=new HashMap<String,Integer>();
		m.put("集",11);
		m.put("合",21);

		hm.put("计算机一班",h);
		hm.put("计算机二班",m);
		Iterator<String> it=hm.keySet().iterator();
		while(it.hasNext()){
		  String className=it.next();
		  System.out.println("班级"+className);
		  HashMap<String,Integer> hh=hm.get(className);
		  Iterator<String> its=hh.keySet().iterator();
		  while(its.hasNext()){
		  	String sName=its.next();
			Integer sAge=hh.get(sName);
			System.out.println(sName+" "+sAge);
		  }
		}
	}
}
class Student
{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
	  this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
}

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————