黑马程序员_【总结】_集合框架知识梳理2

集合框架知识梳理2

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

---------------------------------------------------------------------------------------------------------------------------------------------

-------------------------------------------------------
1、MAP 双列 集合 、Collection 单列集合

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

|--HashMap   :底层是哈希表数据结构，允许存入null键null值，该集合是不同步的     JDK1.2 效率高

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

2、需要注意的是 MAP是没有 迭代器的，想要迭代，必须通过创建一个Collection对象接收values的值再迭代
3、MAP 集合 存储键值对，一对一对的往里存，而且要保证键的唯一性。    键  是 不可重复的。
4、HashMap   作为升级版  可以把 null作为键或者值
5、map集合的两种取出方： entrySet()【重点】keySet()  【重点】
6、keySet()： 将map 中的所有键存入到set集合，因为set集合具备迭代器

用迭代器取出所有键，通过get方法，取出键对应的 值

7、entrySet(): 在set集合中存储的是映射关系。

该映射关系是以Map.Entry接口的 对象形式存在的，所以set的泛型就是该接口

调用 set集合的迭代器 ，将一个个Map.Entry 对象取出

然后调用该对象自带方法，取出 键和值 

8、Entry ：其实也是一个接口，MAP的子接口，可以用类实现接口，用类的内部类子接口
9、HashMap 不能进行比较排序不论是 implements Comparator 还是 implements Comparable 
10、Map 集合被使用是因为具备映射关系。 
-------------------------------------------------------
Map   集合    【   Map(K,V)    】   

该集合存储键值对，一对一对的往里存，而且要保证键的唯一性。
(看API的时候，可以先罗列出这个集合可能拥有的功能，然后对应去看)

Map

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

|--HashMap   :底层是哈希表数据结构，允许存入null键null值，该集合是不同步的     JDK1.2 效率高

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

Map 和Set很像
其实，Set底层就是使用了Map集合。
（Collection 单列集合，Map 双列集合）

Map 集合和 基本方法

class  MapDemo1{
	public static void main(String[] args) {
		Map<String,String>  mss = new HashMap<String,String>();
		mss.put("01","huan1");
		mss.put("01","huan99");//当存入相同键的时候，新的值会覆盖原有值
		mss.put("02","huan2");
		mss.put("03","huan3");
		System.out.println("打印出集合："+mss);
		System.out.println("有huan值吗？"+mss.containsValue("huan"));
		System.out.println("有03编号吗？"+mss.containsKey("03"));
		System.out.println("删除03编号"+mss.remove("03"));
		System.out.println("打印出集合："+mss);
		System.out.println("有03编号吗？"+mss.containsKey("03"));
		System.out.println("集合为空吗"+mss.isEmpty());
		//System.out.println(mss.clear());
		System.out.println("集合为空吗"+mss.isEmpty());
		System.out.println("获取值"+mss.get("01"));
		System.out.println("获取值"+mss.get("011"));//其实可以使用get方法判断某一个建存不存在
		System.out.println("获取长度"+mss.size());		
		mss.put(null,"我是空键的值");
		mss.put("05",null);
		System.out.println("------------------------------------------------\n"+
							"要注意，HashMap是可以将null作为键，或者值的");
		System.out.println("获取值空键：："+mss.get(null)+"\n\tnull键并不多见，可以使用get进行判断，查看是否存在null的键");
		System.out.println("\n------------------------------------------------");
		Collection<String> coll=mss.values();
		//由于MAP没有迭代器，所以：通过创建一个Collection对象接收values的值再输出
		System.out.print("迭代器输出：");
		for(Iterator<String> it=coll.iterator();it.hasNext(); ){
			System.out.print(it.next()+" ");
		}
		System.out.println("\n打印出集合："+mss);
		System.out.println(mss.put("09","-0-"));
		System.out.println(mss.put("09","9999999"));//当存入相同键的时候，新的值会覆盖原有值
	}
}

例子中，罗列出 各种基本方法。
1、需要注意的是 MAP是没有 迭代器的，想要迭代，必须通过创建一个Collection对象接收values的值再迭代
2、MAP集合 键  是 不可重复的。
3、HashMap   作为升级版  可以把 null作为键或者值
1、添加

put(K key, V value)

putAll(Map< ? extends K,  ? extends v>M)

2、删除

clear()

remove(Object key)

3、判断

containsValue(Object value)

containsKey(Object kay)

isEmpty()

4、获取

get(Object key)

size()

values()

【2】
map集合的两种取出方式：

entrySet()【重点】

keySet()  【重点】

keySet()： 将map 中的所有键存入到set集合，因为set集合具备迭代器

用迭代器取出所有键，通过get方法，取出键对应的 值

public static void main(String[] args) {
		HashMap<String,String>  hss = new HashMap<String,String>();
		hss.put("02","sm2");
		hss.put("01","sm1");
		hss.put("04","sm4");
		hss.put("03","sm3");
		//1 先获取map集合的所有键的Set集合，keySet()
		Set<String> keyset=hss.keySet();
		//有了Set集合，就可以获取迭代器。
		for(Iterator<String> it= keyset.iterator();it.hasNext() ; ){
			String key=it.next();
			//有了键可以通过map集合的get方法获取其对应的值
			String value=hss.get(key);
			System.out.println(key+"----"+value);
		}
	}

entrySet(): 在set集合中存储的是映射关系。

该映射关系是以Map.Entry接口的 对象形式存在的，所以set的泛型就是该接口

调用 set集合的迭代器 ，将一个个Map.Entry 对象取出

然后调用该对象自带方法，取出 键和值 

//2将map集合中的映射关系取出，存如到set集合中。

               Set<Map.Entry<String,String>> entryset =  hss.entrySet();
		for(Iterator<Map.Entry<String,String>> it = entryset.iterator(); it.hasNext(); ){
			Map.Entry<String,String> me=it.next();
			String key=me.getKey();
			String value=me.getValue();
			System.out.println(key+"--"+value);
		}

Entry ：其实也是一个接口，MAP的子接口，可以用类实现接口，用类的内部类子接口
模拟一下：

		interface Map{
			public static interface Entry{
				public abstract Object getKey();
				public abstract Object getValue();
			}
		}
		class HashMap implements Map.Entry
		{
			class Hahs implements Map.Entry{
				public abstract Object getKey();
				public abstract Object getValue();
			}
		}

//能加 static 修饰的接口，都是内部接口
【3】
1、HashMap 不具备 比较   TreeMap才具有

class MapTest6 {
	public static void main(String[] args) {
		//TreeMap<Student,String>  hss = new TreeMap<Student,String>(new MyCom());
		//TreeMap<Student,String>  hss = new TreeMap<Student,String>();
		//HashMap<Student,String>  hss = new HashMap<Student,String>(new MyCom());
		HashMap<Student,String>  hss = new HashMap<Student,String>();
		hss.put(new Student("xua",30),"tian");
		hss.put(new Student("fds",26),"sf");
		hss.put(new Student("afdsa",17),"tfff");
		hss.put(new Student("cfdsa",27),"tfff");
		hss.put(new Student("bfdsa",27),"tfff");
		hss.put(new Student("xua",24),"tfds");
		hss.put(new Student("dsua",18),"fdsfean");
		hss.put(new Student("zuf",20),"tsd");
		for(Iterator<Student> it = hss.keySet().iterator() ; it.hasNext() ; ){
			Student s = it.next();
			String addr = hss.get(s);
			System.out.println(s+"--"+addr);
		}
	}
}
//比较方式1:--implements Comparator--比较器
class MyCom implements Comparator<Person>{

	public int compare(Person s1,Person s2){
		int num=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		if(num==0){
			return s1.getName().compareTo(s2.getName());
		}
		return num;
	}
}
//比较方式2:--implements Comparable 
class Person implements Comparable<Person>{
	private String name;
	private int age;
	Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	//3
	public int compareTo(Person p){
		int num = this.getName().compareTo(p.getName());
		if(num == 0){
			return new Integer(this.getAge()).compareTo(new Integer(p.getAge()));
		}
		return num;
	}
	//1
	public int hashCode(){
		return name.hashCode()+age*17;
	}
	//2
	public boolean equals(Object obj){
		if(!(obj instanceof Student)){
			throw new ClassCastException("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
		}
		Person p = (Person) obj;
		return this.getName().equals(p.getName()) && this.age==p.age ;
	}
	public String toString(){
		return name+"+++++"+age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
}
class Student extends Person{
	Student(String name,int age){
		super(name,age);
	}
}

发现，不论是implements Comparator 还是 implements Comparable  都不能对HashMap 进行比较排序
 【4】
 Map 扩展知识。

Map 集合被使用是因为具备映射关系。

案例：
一个学校有很多班级，一个班级会有很多学生，
那么，，这学生，班级，和学校，该如何来存储，用什么来存储，呢

MapTest9  是一个方法 MapTest91  是另外一个方法

本方法中，因为班级里的学生具有名字，和学号这种映射关系，
所以我们用2个Map集合来 装学校， 而学校具有，班级名称，和具体班级，
也是一种映射关系，所以把学生集合作为值，班级名作为键，进行存储
HashMap<String,HashMap<String,String>> xuexiao = new HashMap<String,HashMap<String,String>>();
这样就搞定了。
1、创建 学校，班级，让学校跟班级有映射关系。
2、为班级添加学员。当需要我们获取某个班级的学员的时候

我们可以通过获取班级来实现

3、编写一个获取班级学员信息的方法

传入一某一个班级名称，因为其也是一个Map 集合，因为Map不具备迭代器

我们把所有键，装入一个collextion集合中，通过迭代器获得班级学员编号，和名字。

4、当我们要使用上诉方法时候，必须获取到该学校的班级。同理，使用collextion 集合来存储

键，通过键，来获取到所有班级， 通过在迭代器里，进行每一次班级的传入，而获取所有班级的学员信息。

"yurebao"    "01"  "zhangs"

"yurebao"    "02"  "zhans"

"jiuye"    "01"  "zhangdfs"

"jiuye"    "02"  "zhangs"

【4-1】
方式2看MapTest91
>>[2]
"jiuye"  Student("01","zhangs");    

import java.util.*;
class MapTest9 {
	public static void main(String[] args) {
		//创建一个学校 
		HashMap<String,HashMap<String,String>> xuexiao = new HashMap<String,HashMap<String,String>>();
		//创建一个班级
		HashMap<String,String> yure =new HashMap<String,String>();	
		//创建一个班级
		HashMap<String,String> jiuye =new HashMap<String,String>();
		//这个时候，两个班级和学校是没有关系的。:
		xuexiao.put("预热班",yure);
		xuexiao.put("就业班",jiuye);
		// 有关系后，给每个班级添加学生
		yure.put("y01","zhangs");
		yure.put("y02","lisi");
		yure.put("y03","wangw");
		jiuye.put("j01","liming");
		jiuye.put("j02","huangy");
		jiuye.put("j03","huangl");
		jiuye.put("jo4","jiangx");
		//如何获取学校所有的学生？  提示，通过遍历学校，获取到所有的教室，然后。。。。
		Set<String> keyset = xuexiao.keySet();//使用一个Collection集合来把所有的键装在一起。
		for(Iterator<String> it = keyset.iterator() ; it.hasNext() ;  ){
			String key = it.next(); //获取键
			HashMap<String,String>  jiaoshi = xuexiao.get(key);	//注意班级的类型 获取班级		
            System.out.println("输出看看获取的班级："+key+"\n\n");
			ShowBanji(jiaoshi);//获取班级具体信息
		}	
	}
	//获取指定某个班级的学生信息。
	public static void ShowBanji(HashMap<String,String> roommap){
		Set<String> keyset=roommap.keySet();//使用一个Collection集合来把所有的键装在一起。
		for(Iterator<String> it = keyset.iterator() ; it.hasNext() ; ){
			String id = it.next();
			String name = roommap.get(id);
			System.out.println(id+"----"+name);
		}
	}
}

【4-2】
方式二   -------对比
"jiuye"  Student("01","zhangs");    
上诉方法是通过班级创建学生的方式来完成的，
因为万物皆对象，其实学生也是一个对象，
那么我们接下来的方法就是把学生信息直接封装为对象进行操作。

当把学生信息封装为一个对象，这个时候，就不存在映射关系，
那么就不用map集合了，那么用什么集合了，collcetion 里有两个集合，一个list,set 集合
如果不考虑重复性，我们就用list 集合
1、创建学校集合，班级集合，学生。
2、获取班级
3、根据班级获取学生。

class MapTest91 {
	public static void main(String[] args) {
		//同样创建一个学校，只是HashMap变为了list
		HashMap<String,List<Student>> xuex = new HashMap<String,List<Student>>();
		//创建2个班级
		List yure = new ArrayList<Student>();
		List jiuye = new ArrayList<Student>();
		//创建关系
		xuex.put("预热班级",yure);
		xuex.put("就业班级",jiuye);
		yure.add(new Student("yy1","zzz"));
		yure.add(new Student("yy2","zfdszz"));
		jiuye.add(new Student("jj1","azzez"));
		jiuye.add(new Student("yjj2","zdszz"));
		for(Iterator<String> it = xuex.keySet().iterator() ; it.hasNext() ; ){
			//Iterator<String> it = xuex.keySet().iterator();
			//while(it.hasNext()){  //两种循环方式。
				String key =it.next();//班级名称
				List<Student> room = xuex.get(key);
				System.out.println(key+"|");
				getInfo(room);
			}
	}
	public static void getInfo(List<Student> stu){
		//循环方式2    切记collcetion集合中都是单列没有get方法，不要和Map集合搞混淆了。
		//Iterator<Student> it = stu.iterator();
		//while(it.hasNext()){
		//	Student no = it.next();
		//	System.out.println(no);
		//}
		//
		for(Iterator<Student> it = stu.iterator() ; it.hasNext() ; ){
			Student key = it.next();
			System.out.println(key+"---");//因为覆盖了toString方法，所以这里可以直接输出。
			}			
	}
}
//学生类
class Student{
	private String no;
	private String name;
	Student(String no,String name){
		this.no = no;
		this.name = name;
	}
	public String getNo(){
		return no;
	}
	public String getName(){
		return name;
	}
	public String toString(){
		return no+"=-"+name;
	}
}

充分利用万物皆对象，就是说，尽量进行封装。方便操作。

---------------------------------------------------------------------------------------------------------------------------------------------

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

黑马官网