java基础笔记--Map

Map
    |--Hashtable:底层是哈希表数据结构，不可以存入null键或null值。该集合是线程同步的。
    |--HashMap:底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。
    |--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Set底层就是使用了Map集合。

import java.util.*;

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

	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>();

		sop(map.put("01","lisi01"));//null
		sop(map.put("01","lisi001"));//lisi01
		sop(map.put("01","lisi0001"));//lisi001
		//第一次打印某一键对应的值时(即sop(put))，值为空。第二次打印同一键对应值时为前一次对应的值。
		//但后面put进去的值会覆盖前面的值，所以sop(map)时是打印最新的值。

		map.put("02","lisi02");
		map.put("03","lisi03");
		//sop(map);//{01=lisi0001,02=lisi02,03=lisi03}

		//sop("containsKey:"+map.containsKey("02"));//true
		//sop("remove:"+map.remove("02"));//remove:lisi02  remove找到键"02"，去掉键后返回对应的值。
		
		//sop("get:"+map.get("023"));//null

		map.put(null,"java");//HashMap集合中null可以作为键存在的。
		sop("get:"+map.get(null));//get:java
		map.put("04",null);
		sop("get:"+map.get("04"));//get:null
		//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

		Collection<String> coll = map.values();
		sop(coll);//[java,lisi0001,lisi02,lisi03,null]
		sop(map);
	}
}

map集合的两种取出方式:
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
    所以可以通过迭代方式取出所有的键，再根据get方法获取没一个键对应的值。

    Map集合的取出原理：将map集合转成Set集合。再通过迭代器取出。

2，Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中，
    而这个关系的数据类型就是Map.Entry。

Map.Entry  其实Entry也是一个接口，它是Map接口中的一个内部接口。
interface Map {
    public static interface Entry {
        public abstract Object getKey();
        public abstract Object getValue();
    }
}
class HashMap implements Map {
    class Hash implements Map.Entry {
        public Object getKey() {}
        public Object getValue() {}
    }
}

import java.util.*;

class MapDemo {
	public static void sop(Object obj) {
		System.out.println(obj);
	}
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String,String>();

		map.put("01","lili01");
		map.put("02","lili02");
		map.put("03","lili03");
		map.put("04","lili04");
		
		/*一、
		//先获取map集合的所有键的Set集合，keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合便可以获取其迭代器。
		//注意：迭代器的泛型类型与传来的一致
		Iterator<String> it = keySet.iterator();

		while(it.hasNext()) {
			String key = it.next();
			//有了键可以通过map集合的get方法获取其对应值。
			String value = map.get(key);
			sop("key:"+key+",value:"+value);
		}
		*/
		//二、
		//将Map集合中的映射关系取出。存入到Set集合。
		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();

			sop(key+"::"+value);
		}
	}
}

import java.util.*;

/*
*每一个学生都有对应的归属地。
*学生Student，地址String。(Student作为键，不能*重复。String作为值，可以重复)
*学生属性：姓名，年龄。
*注意：姓名和年龄相同的视为同一学生。
*保证学生的唯一性。
*1.描述学生。
*	定义name和age，通过构造函数(Student)传*值.实际开发时需要写setName和setAge.
*	复写toString建立学生对象自定义的字符串表现形式。
*	此Student类虽然没写hashCode和equals，但仍有。此类对象可能会存到哈希表中，因此要判断是否重复的条件。
*	判断obj是否是Student类，若是便可强转。
*	因为Student可能产生很多对象，因此应该需要比较性，那些对象应该要有自然顺序，因此要实现Comparable。
*2.定义map容器，将学生作为键，地址作为值存入。
*3.获取map集合中的元素。
*/

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*23;
	}
	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:"+name+":"+"age:"+age;
	}
}

class MapTest {
	public static void sop(Object obj) {
		System.out.println(obj);
	}
	public static void main(String[] args) {
		HashMap<Student,String> hm = new HashMap<Student,String>();

		hm.put(new Student("lisi01",21),"beijing");
		hm.put(new Student("lisi02",22),"hubei");
		hm.put(new Student("lisi03",23),"nanjing");
		hm.put(new Student("lisi04",24),"shanghai");

		/*
		//1.keySet
		Set<Student> keySet = hm.keySet();

		Iterator<Student> it = keySet.iterator();

		while(it.hasNext()) {
			Student stu = it.next();
			String addr = hm.get(stu);
			sop(stu+"..."+addr);
		}
		*/
		//2.entrySet
		Set<Map.Entry<Student,String>> entrySet = hm.entrySet();

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

		while(it.hasNext()) {
			Map.Entry<Student,String> me = it.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			sop(stu+"....."+addr);
		}
	}
}

import java.util.*;

/*
*"sd1fg-zxc,vasdf.xcvdf"获取该字符串中的字母出现的次数。
*打印结果为：a(1)c(2)...
*想要打印成如此结果，可以使用缓冲区
*
*每个字母都有对应的次数。字母与次数之间都有映射关系。
*可使用map集合，因map集合中存放的就是映射关系。
*
*何时使用map集合：当数据之间存在着映射关系时就应该考虑使用map集合。
*
*思路：
*1.将字符串转换成字符数组，因要对每一个字母进行操作。
*2.定义一个map集合，因打印结果的字母顺序，所以使用TreeMap集合。
*3.遍历字符数组。
*  将没一个字母作为键去查map集合。
*  若返回null，将该字母和1存入map集合中。
*  若不是返回null，即该字母在map集合中已经存在并有对应次数。
*  将该次数进行自增，然后将该字母和自增后的次数存到map集合中，覆盖掉原来键所对应的值。
*4.将map集合中的数据变成指定的字符串形式返回。
*/

class MapTest {
	public static void sop(Object obj) {
		System.out.println(obj);
	}
	public static void main(String[] args) {
		String s = charCount("sdfgzxcvasdfxcvdf");
		sop(s);
	}

	public static String charCount(String str) {
		char[] chs = str.toCharArray();

		//TreeMap<char,int> tm = new TreeMap<>();Error
		//注意：字母做键，次数为值。泛型中接收的是应用数据类型，需找到其对应的基本数据类型包装类。
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();

		int count = 0;

		for(int x=0;x<chs.length;x++) {
			//int count = 0;//若定义在里面，则即是在内存中不断开辟空间。
			if(!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]<='Z'));
			continue;

			Integer value = tm.get(chs[x]);

			
			if(value!=null)
				count = value;
			count++;
			tm.put(chs[x],count);
			count = 0;

			/*
			if(value==null) {
				tm.put(chs[x],1);
			} else {
				tm.put(chs[x],++value);
			}*/
		}
		//System.out.println(tm);

		StringBuilder sb = new StringBuilder();

		Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();

		while(it.hasNext()) {
			Map.Entry<Character,Integer> me = it.next();
			Character ch = me.getKey();
			Integer value = me.getValue();
			sb.append(ch+"("+value+")");
		}

		return sb.toString();
	}
}