java----集合类

集合类

一、Map集合

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

1.添加

V put(K key, V value);将指定的值与此映射中的指定键关联（可选操作）。

void putAll(Map<? extends K,? extends V> m);从指定映射中将所有映射关系复制到此映射中（可选操作）。

2.删除

void clear();从此映射中移除所有映射关系（可选操作）。 

V remove(Object key);如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 

3.判断

boolean containsKey(Object key);如果此映射包含指定键的映射关系，则返回 true。 

boolean containsValue(Object value);如果此映射将一个或多个键映射到指定值，则返回 true。

boolean isEmpty();如果此映射未包含键-值映射关系，则返回 true。 

4.获取

V get(Object key);返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 

int size();返回此映射中的键-值映射关系数。 

Collection<V> values();返回此映射中包含的值的 Collection 视图。 

Set<Map.Entry<K,V>> entrySet();返回此映射中包含的映射关系的 Set 视图。 

Set<K> keySet();返回此映射中包含的键的 Set 视图。

Map

|——Hashtable：底层是哈希表数据结构，不可以存入null键和null值，该集合是线程同步的，效率低。

|——HashMap：底层是哈希表数据结构，可以使用null键null值。该集合是线程不同步的。效率高。

|——TreeSet：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序。

发现：和Set集合很像。其实Set底层就是使用了Map集合。

例：

import java.util.*;
class Demo
{
	public static void main(String []args){
		HashMap<String,String> map = new HashMap<String,String>();
		//添加元素，如果出现相同键，那么后添加的值会覆盖掉原有键所对应的值，并put方法会返回被覆盖

的值
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		//判断
		System.out.println("containsKey : "+map.containsKey("02"));
		//删除
		System.out.println("remove : "+map.remove("02"));
		//获取
		System.out.println("get : "+map.get("023"));//可以通过get方法的返回值判断一个键是否存在
		map.put(null,"haha");//hashMap中允许使用null键null值
		System.out.println("get : "+map.get(null));
		//获取集合中所以的值
		Collection<String> coll = map.values();
		System.out.println(coll);
	}
}

Map集合的两种取出方式：

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

例：

import java.util.*;
class Demo
{
	public static void main(String []args){
		HashMap<String,String> map = new HashMap<String,String>();
		map.put("01","java01");
		map.put("02","java02");
		map.put("03","java03");
		map.put("04","java04");
		//先获取map集合的所以键的Set集合
		Set<String> set = map.keySet();
		//有了Set集合，就可以获取其迭代器
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			String key = it.next();
			//有了键，就可以通过map集合的get方法获取对应的值
			String value = map.get(key);
			System.out.println(key+"..."+value);
		}
	}
}

取出原理：图解

用keySet取出Map的键的Set集合，再通过Set集合的迭代器，取出Set集合中的键。通过Map的get(key)方法获取键的对应值。

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

import java.util.*;
class Demo
{
	public static void main(String []args){
		HashMap<String,String> map = new HashMap<String,String>();
		map.put("01","java01");
		map.put("02","java02");
		map.put("03","java03");
		map.put("04","java04");
		//将Map集合中的映射关系取出，存入到Set集合中
		Set<Map.Entry<String,String>> set = map.entrySet();
		Iterator<Map.Entry<String,String>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<String,String> me = it.next();
			System.out.println(me.getKey()+"..."+me.getValue());
		}
	}
}

取出原理：图解

关系对象Map.Entry获取到后，就可以通过Map.Entry中的getKey和getValue方法获取关系中的键和值。Map.Entry其实是一个接口，它是Map接口中的一个内部接口。

练习：每个学生都有对应的归属地。

学生Student，地址String。

学生属性：姓名，年龄。

注：姓名年龄相同的视为同一个学生。保证学生的唯一性。

1.描述学生。

2.定义map容器。将学生作为键，地址作为值存入map。

3.获取map集合中的元素。

import java.util.*;
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public int compareTo(Student s){
		int num = name.compareTo(s.name);
		if(num==0)
			return new Integer(age).compareTo(new Integer(s.age));
		return num;
	}
	public int hashCode(){
		return name.hashCode()+age*11;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Student))
			throw new ClassCastException("不是学生类");
		Student s = (Student)obj;
		return name.equals(s.name)&&age==s.age;
	}
}
class Demo
{
	public static void main(String []args){
		TreeMap<Student,String> tm = new TreeMap<Student,String>();
		tm.put(new Student("lisi3",23),"nanjing");
		tm.put(new Student("lisi2",22),"shanghai");
		tm.put(new Student("lisi4",24),"wuhan");
		tm.put(new Student("lisi1",21),"beijing");
		
		//第一种取出方式
		method_01(tm);
		System.out.println("==========================================");
		//第二种取出方式
		method_01(tm);
	}
	public static void method_01(TreeMap<Student,String> tm){
		Set<Student> set = tm.keySet();
		Iterator<Student> it = set.iterator();
		while(it.hasNext()){
			Student s = it.next();
			String addr = tm.get(s);
			System.out.println("name："+s.getName()+",age："+s.getAge()+",addr："+addr);
		}
	}
	public static void method_02(TreeMap<Student,String> tm){
		Set<Map.Entry<Student,String>> set = tm.entrySet();
		Iterator<Map.Entry<Student,String>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<Student,String> me = it.next();
			Student s = me.getKey();
			String addr = me.getValue();
			System.out.println("name："+s.getName()+",age："+s.getAge()+",addr："+addr);
		}
	}
}

什么时候使用Map集合呢？

答：当数据之间存在着映射关系时，就要先想到Map集合。

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

通过结果发现，每一个字母都有对应的次数，说明字母和次数之间都有映射关系。

注：当发现有映射关系时，可以选择Map集合。因为Map集合中存放的就是映射关系。

分析：第一次字母a作为键去找集合，那么集合没有a这个键，就将a字母和1存入集合。如果指定的键已经存在，说明有对应的次数，就将对应的次数取出，并自增后再重新存入集合。

思路：

1.将字符串转换成字符数组，因为要对每一个字母进行操作。

2.定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。

3.遍历字符数组。将每一个字母作为键去查找Map集合。如果返回null就将该字母和1存入到Map集合中，如果返回的不是null，说明该字母在Map集合中已经存在，并有对应的次数，那么就获取该次数并进行自增，然后将该字母和自增后的次数存到Map集合中，覆盖掉原来键所对应的值。

4.将Map集合中的数据变成指定的字符串形式返回。

import java.util.*;
class Demo
{
	public static void main(String []args){
		String s = "sdfgzxcvasdfxcvdf";
		show(s);
		show(charCount(s));
	}
	public static String charCount(String s){
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
		char []chs = s.toCharArray();
		for(int x=0;x<chs.length;x++){
			Integer value = tm.get(chs[x]);
			if(value==null)
				tm.put(chs[x],1);
			else{
				tm.put(chs[x],value+1);
			}
		}
		StringBuilder sb = new StringBuilder();
		Set<Map.Entry<Character,Integer>> set = tm.entrySet();
		Iterator<Map.Entry<Character,Integer>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<Character,Integer> me = it.next();
			sb.append(me.getKey()+"("+me.getValue()+")");
		}
		return sb.toString();
	}
	public static void show(String str){
		System.out.println(str);
	}
}

扩展知识：描述复杂关系

图示：描述学校，教室，学生的关系。

import java.util.*;
class Demo
{
	public static void main(String []args){
		HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
		HashMap<String,String> jiuye = new HashMap<String,String>();
		HashMap<String,String> yure = new HashMap<String,String>();
		czbk.put("yureban",yure);
		czbk.put("jiuyeban",jiuye);

		yure.put("01","zhangsan");
		yure.put("02","lisi");

		jiuye.put("01","zhaoliu");
		jiuye.put("02","wangwu");
		
		showSchoolRoom(czbk);
	}
	public static void showRoomStu(HashMap<String,String> room){
		Set<Map.Entry<String,String>> set = room.entrySet();
		Iterator<Map.Entry<String,String>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<String,String> me = it.next();
			System.out.println("ID : "+me.getKey()+" , Name :"+me.getValue());
		}
	}
	
	public static void showSchoolRoom(HashMap<String,HashMap<String,String>> school){
		Set<Map.Entry<String,HashMap<String,String>>> set = school.entrySet();
		Iterator<Map.Entry<String,HashMap<String,String>>> it = set.iterator();
		while(it.hasNext()){
			Map.Entry<String,HashMap<String,String>> me = it.next();
			System.out.println("Class : "+me.getKey());
			showRoomStu(me.getValue());
		}
	}
}