集合（四）-白红宇

集合（四）

阅读量：6831 次

发布时间：2019-06-26

本文共 23928 字，大约阅读时间需要 79 分钟。

1:Map(掌握)

(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

(2)Map和Collection的区别?

A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对

B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍

(3)Map接口功能概述(自己补齐)

A:添加功能

B:删除功能

C:判断功能

D:获取功能

E:长度功能

(4)Map集合的遍历

A:键找值

a:获取所有键的集合

b:遍历键的集合,得到每一个键

c:根据键到集合中去找值

B:键值对对象找键和值

a:获取所有的键值对对象的集合

b:遍历键值对对象的集合，获取每一个键值对对象

c:根据键值对对象去获取键和值

代码体现：

Map<String,String> hm = new HashMap<String,String>();

hm.put("it002","hello");

hm.put("it003","world");

hm.put("it001","java");

//方式1 键找值

//获取所有键

Set<String> set = hm.keySet();

//遍历获取每一个键

for(String key : set) {

//根据每一个键获取对应的值

String value = hm.get(key);

System.out.println(key+"---"+value);

}

//方式2 键值对对象找键和值

Set<Map.Entry<String,String>> set2 = hm.entrySet();

for(Map.Entry<String,String> me : set2) {

String key = me.getKey();

String value = me.getValue();

System.out.println(key+"---"+value);

}

(5)HashMap集合的练习

A:HashMap<String,String>

import java.util.HashMap;import java.util.Set;/* * HashMap:是基于哈希表的Map接口实现。 * 哈希表的作用是用来保证键的唯一性的。 *  * HashMap
     
       * 键：String * 值：String */public class HashMapDemo {	public static void main(String[] args) {		// 创建集合对象		HashMap
      
        hm = new HashMap
       
        ();		// 创建元素并添加元素		// String key1 = "it001";		// String value1 = "马云";		// hm.put(key1, value1);		hm.put("it001", "马云");		hm.put("it003", "马化腾");		hm.put("it004", "乔布斯");		hm.put("it005", "张朝阳");		hm.put("it002", "裘伯君"); // wps		hm.put("it001", "比尔盖茨");		// 遍历		Set
        
          set = hm.keySet();		for (String key : set) {			String value = hm.get(key);			System.out.println(key + "---" + value);		}	}}

B:HashMap<Integer,String>

import java.util.HashMap;import java.util.Set;/* * HashMap
     
       * 键：Integer * 值：String */public class HashMapDemo2 {	public static void main(String[] args) {		// 创建集合对象		HashMap
      
        hm = new HashMap
       
        ();		// 创建元素并添加元素		// Integer i = new Integer(27);		// Integer i = 27;		// String s = "林青霞";		// hm.put(i, s);		hm.put(27, "林青霞");		hm.put(30, "风清扬");		hm.put(28, "刘意");		hm.put(29, "林青霞");		// 下面的写法是八进制，但是不能出现8以上的单个数据		// hm.put(003, "hello");		// hm.put(006, "hello");		// hm.put(007, "hello");		// hm.put(008, "hello");		// 遍历		Set
        
          set = hm.keySet();		for (Integer key : set) {			String value = hm.get(key);			System.out.println(key + "---" + value);		}		// 下面这种方式仅仅是集合的元素的字符串表示		// System.out.println("hm:" + hm);	}}

C:HashMap<String,Student>

import java.util.HashMap;import java.util.Set;/* * HashMap
     
       * 键：String	学号 * 值：Student 学生对象 */public class HashMapDemo3 {	public static void main(String[] args) {		// 创建集合对象		HashMap
      
        hm = new HashMap
       
        ();		// 创建学生对象		Student s1 = new Student("周星驰", 58);		Student s2 = new Student("刘德华", 55);		Student s3 = new Student("梁朝伟", 54);		Student s4 = new Student("刘嘉玲", 50);		// 添加元素		hm.put("9527", s1);		hm.put("9522", s2);		hm.put("9524", s3);		hm.put("9529", s4);		// 遍历		Set
        
          set = hm.keySet();		for (String key : set) {			// 注意了：这次值不是字符串了			// String value = hm.get(key);			Student value = hm.get(key);			System.out.println(key + "---" + value.getName() + "---"					+ value.getAge());		}	}}

D:HashMap<Student,String>

import java.util.HashMap;import java.util.Set;/* * HashMap
     
       * 键：Student * 		要求：如果两个对象的成员变量值都相同，则为同一个对象。 * 值：String */public class HashMapDemo4 {	public static void main(String[] args) {		// 创建集合对象		HashMap
      
        hm = new HashMap
       
        ();		// 创建学生对象		Student s1 = new Student("貂蝉", 27);		Student s2 = new Student("王昭君", 30);		Student s3 = new Student("西施", 33);		Student s4 = new Student("杨玉环", 35);		Student s5 = new Student("貂蝉", 27);		// 添加元素		hm.put(s1, "8888");		hm.put(s2, "6666");		hm.put(s3, "5555");		hm.put(s4, "7777");		hm.put(s5, "9999");		// 遍历		Set
        
          set = hm.keySet();		for (Student key : set) {			String value = hm.get(key);			System.out.println(key.getName() + "---" + key.getAge() + "---"					+ value);		}	}}

LinkHashMap集合练习

import java.util.LinkedHashMap;import java.util.Set;/* * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。 * 由哈希表保证键的唯一性 * 由链表保证键盘的有序(存储和取出的顺序一致) */public class LinkedHashMapDemo {	public static void main(String[] args) {		// 创建集合对象		LinkedHashMap
     
       hm = new LinkedHashMap
      
       ();		// 创建并添加元素		hm.put("2345", "hello");		hm.put("1234", "world");		hm.put("3456", "java");		hm.put("1234", "javaee");		hm.put("3456", "android");		// 遍历		Set
       
         set = hm.keySet();		for (String key : set) {			String value = hm.get(key);			System.out.println(key + "---" + value);		}	}}

(6)TreeMap集合的练习

A:TreeMap<String,String>

import java.util.Set;import java.util.TreeMap;/* * TreeMap:是基于红黑树的Map接口的实现。 *  * HashMap
     
       * 键：String * 值：String */public class TreeMapDemo {	public static void main(String[] args) {		// 创建集合对象		TreeMap
      
        tm = new TreeMap
       
        ();		// 创建元素并添加元素		tm.put("hello", "你好");		tm.put("world", "世界");		tm.put("java", "爪哇");		tm.put("world", "世界2");		tm.put("javaee", "爪哇EE");		// 遍历集合		Set
        
          set = tm.keySet();		for (String key : set) {			String value = tm.get(key);			System.out.println(key + "---" + value);		}	}}

B:TreeMap<Student,String>

import java.util.Comparator;import java.util.Set;import java.util.TreeMap;/* * TreeMap
     
       * 键:Student * 值：String */public class TreeMapDemo2 {	public static void main(String[] args) {		// 创建集合对象		TreeMap
      
        tm = new TreeMap
       
        (				new Comparator
        
         () {					@Override					public int compare(Student s1, Student s2) {						// 主要条件						int num = s1.getAge() - s2.getAge();						// 次要条件						int num2 = num == 0 ? s1.getName().compareTo(								s2.getName()) : num;						return num2;					}				});		// 创建学生对象		Student s1 = new Student("潘安", 30);		Student s2 = new Student("柳下惠", 35);		Student s3 = new Student("唐伯虎", 33);		Student s4 = new Student("燕青", 32);		Student s5 = new Student("唐伯虎", 33);		// 存储元素		tm.put(s1, "宋朝");		tm.put(s2, "元朝");		tm.put(s3, "明朝");		tm.put(s4, "清朝");		tm.put(s5, "汉朝");		// 遍历		Set
         
           set = tm.keySet();		for (Student key : set) {			String value = tm.get(key);			System.out.println(key.getName() + "---" + key.getAge() + "---"					+ value);		}	}}

(7)案例

A:统计一个字符串中每个字符出现的次数

Demo：

import java.util.Scanner;import java.util.Set;import java.util.TreeMap;/* * 需求 ："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1) *  * 分析： * 		A:定义一个字符串(可以改进为键盘录入) * 		B:定义一个TreeMap集合 * 			键:Character * 			值：Integer * 		C:把字符串转换为字符数组 * 		D:遍历字符数组，得到每一个字符 * 		E:拿刚才得到的字符作为键到集合中去找值，看返回值 * 			是null:说明该键不存在，就把该字符作为键，1作为值存储 * 			不是null:说明该键存在，就把值加1，然后重写存储该键和值 * 		F:定义字符串缓冲区变量 * 		G:遍历集合，得到键和值，进行按照要求拼接 * 		H:把字符串缓冲区转换为字符串输出 *  * 录入：linqingxia * 结果：result:a(1)g(1)i(3)l(1)n(2)q(1)x(1) */public class TreeMapDemo {	public static void main(String[] args) {		// 定义一个字符串(可以改进为键盘录入)		Scanner sc = new Scanner(System.in);		System.out.println("请输入一个字符串：");		String line = sc.nextLine();		// 定义一个TreeMap集合		TreeMap
     
       tm = new TreeMap
      
       ();				//把字符串转换为字符数组		char[] chs = line.toCharArray();				//遍历字符数组，得到每一个字符		for(char ch : chs){			//拿刚才得到的字符作为键到集合中去找值，看返回值			Integer i =  tm.get(ch);						//是null:说明该键不存在，就把该字符作为键，1作为值存储			if(i == null){				tm.put(ch, 1);			}else {				//不是null:说明该键存在，就把值加1，然后重写存储该键和值				i++;				tm.put(ch,i);			}		}				//定义字符串缓冲区变量		StringBuilder sb=  new StringBuilder();				//遍历集合，得到键和值，进行按照要求拼接		Set
       
         set = tm.keySet();		for(Character key : set){			Integer value = tm.get(key);			sb.append(key).append("(").append(value).append(")");		}				//把字符串缓冲区转换为字符串输出		String result = sb.toString();		System.out.println("result:"+result);	}}

B:集合的嵌套遍历

a:HashMap嵌套HashMap

Demo：

import java.util.HashMap;import java.util.Set;/* * HashMap嵌套HashMap *  * 传智播客 * 		jc	基础班 * 				陈玉楼		20 * 				高跃		22 * 		jy	就业班 * 				李杰		21 * 				曹石磊		23 *  * 先存储元素，然后遍历元素 */public class HashMapDemo2 {	public static void main(String[] args) {		// 创建集合对象		HashMap
     
      
       > czbkMap = new HashMap
       
        
         >();		// 创建基础班集合对象		HashMap
         
           jcMap = new HashMap
          
           (); // 添加元素 jcMap.put("陈玉楼", 20); jcMap.put("高跃", 22); // 把基础班添加到大集合 czbkMap.put("jc", jcMap); // 创建就业班集合对象 HashMap
           
             jyMap = new HashMap
            
             (); // 添加元素 jyMap.put("李杰", 21); jyMap.put("曹石磊", 23); // 把基础班添加到大集合 czbkMap.put("jy", jyMap); //遍历集合 Set
             
               czbkMapSet = czbkMap.keySet(); for(String czbkMapKey : czbkMapSet){ System.out.println(czbkMapKey); HashMap
              
                czbkMapValue = czbkMap.get(czbkMapKey); Set
               
                 czbkMapValueSet = czbkMapValue.keySet(); for(String czbkMapValueKey : czbkMapValueSet){ Integer czbkMapValueValue = czbkMapValue.get(czbkMapValueKey); System.out.println("\t"+czbkMapValueKey+"---"+czbkMapValueValue); } } }}

Test：

import java.util.Set;import java.util.TreeMap;public class Test10 {	public static void main(String[] args) {		// 新建第一个班		TreeMap
     
       Fmap = new TreeMap<>();		Fmap.put("AAA", 111);		Fmap.put("BBB", 222);		Fmap.put("CCC", 333);		// 第二个班		TreeMap
      
        Fmap2 = new TreeMap<>();		Fmap2.put("DDD", 444);		Fmap2.put("EEE", 555);		Fmap2.put("FFF", 666);		// 年级		TreeMap
       
        
         > Zmap = new TreeMap<>();		Zmap.put("001", Fmap);		Zmap.put("002", Fmap2);		// 获取年级的Key		Set
         
           set = Zmap.keySet();		// 遍历得到的是各个班级的集合		for (String tm : set) {			// 年级Key，即班级名称			System.out.println(tm);			// 将遍历到的值，即各个班级向下转型为原格式TreeMap
          
            TreeMap
           
             tmz = Zmap.get(tm); // 获取遍历到的班级的所有Key Set
            
              set2 = tmz.keySet(); // 遍历各个班级 for (String tm2 : set2) { // 将遍历到的学生年龄转换为原Integer类型 Integer fmapvalue = tmz.get(tm2); System.out.println(tm2 + "\t" + fmapvalue); } } }}

输出：

001

AAA 111

BBB 222

CCC 333

002

DDD 444

EEE 555

FFF 666

b:HashMap嵌套ArrayList

Demo：

import java.util.ArrayList;import java.util.HashMap;import java.util.Set;/* *需求： *假设HashMap集合的元素是ArrayList。有3个。 *每一个ArrayList集合的值是字符串。 *元素我已经完成，请遍历。 *结果： *		 三国演义 *		 	吕布 *		 	周瑜 *		 笑傲江湖 *		 	令狐冲 *		 	林平之 *		 神雕侠侣 *		 	郭靖 *		 	杨过   */public class HashMapIncludeArrayListDemo {	public static void main(String[] args) {		// 创建集合对象		HashMap
     
      
       > hm = new HashMap
       
        
         >();		// 创建元素集合1		ArrayList
         
           array1 = new ArrayList
          
           (); array1.add("吕布"); array1.add("周瑜"); hm.put("三国演义", array1); // 创建元素集合2 ArrayList
           
             array2 = new ArrayList
            
             (); array2.add("令狐冲"); array2.add("林平之"); hm.put("笑傲江湖", array2); // 创建元素集合3 ArrayList
             
               array3 = new ArrayList
              
               (); array3.add("郭靖"); array3.add("杨过"); hm.put("神雕侠侣", array3); //遍历集合 Set
               
                 set = hm.keySet(); for(String key : set){ System.out.println(key); ArrayList
                
                  value = hm.get(key); for(String s : value){ System.out.println("\t"+s); } } }}

Test：

import java.util.ArrayList;import java.util.HashMap;import java.util.Set;public class HashMap_QianTao_ArrayList {	public static void main(String[] args) {		// new HashMap
     
      
       >		HashMap
       
        
         > hashmap = new HashMap
         
          
           >(); // new ArrayList1 ArrayList
           
             arraylist = new ArrayList
            
             (); arraylist.add("AAA"); arraylist.add("BBB"); arraylist.add("CCC"); // new ArrayList2 ArrayList
             
               arraylist2 = new ArrayList
              
               (); arraylist2.add("DDD"); arraylist2.add("EEE"); arraylist2.add("FFF"); hashmap.put("001", arraylist); hashmap.put("002", arraylist2); // 遍历 // 获取HashMap的所有键 Set
               
                 set = hashmap.keySet(); for (String key : set) { System.out.println(key); ArrayList
                
                  arr = hashmap.get(key); for (String s : arr) { System.out.println("\t" + s); } } }}

输出：

001

AAA

BBB

CCC

002

DDD

EEE

FFF

c:ArrayList嵌套HashMap

Demo：

import java.util.ArrayList;import java.util.HashMap;import java.util.Set;/* ArrayList集合嵌套HashMap集合并遍历。 需求： 假设ArrayList集合的元素是HashMap。有3个。 每一个HashMap集合的键和值都是字符串。 元素我已经完成，请遍历。 结果： 周瑜---小乔 吕布---貂蝉 郭靖---黄蓉 杨过---小龙女 令狐冲---任盈盈 林平之---岳灵珊 */public class ArrayListIncludeHashMapDemo {	public static void main(String[] args) {		// 创建集合对象		ArrayList
     
      
       > array = new ArrayList
       
        
         >();		// 创建元素1		HashMap
         
           hm1 = new HashMap
          
           (); hm1.put("周瑜", "小乔"); hm1.put("吕布", "貂蝉"); // 把元素添加到array里面 array.add(hm1); // 创建元素1 HashMap
           
             hm2 = new HashMap
            
             (); hm2.put("郭靖", "黄蓉"); hm2.put("杨过", "小龙女"); // 把元素添加到array里面 array.add(hm2); // 创建元素1 HashMap
             
               hm3 = new HashMap
              
               (); hm3.put("令狐冲", "任盈盈"); hm3.put("林平之", "岳灵珊"); // 把元素添加到array里面 array.add(hm3); // 遍历 for (HashMap
               
                 hm : array) { Set
                
                  set = hm.keySet(); for (String key : set) { String value = hm.get(key); System.out.println(key + "---" + value); } } }}

Test：

import java.util.ArrayList;import java.util.HashMap;import java.util.Set;public class ArrayList_QianTao_HashMap {	public static void main(String[] args) {		HashMap
     
       hash1 = new HashMap<>();		hash1.put("AAA", 111);		hash1.put("BBB", 222);		hash1.put("CCC", 333);		HashMap
      
        hash2 = new HashMap<>();		hash2.put("DDD", 444);		hash2.put("EEE", 555);		hash2.put("FFF", 666);		ArrayList
       
        
         > arrlist = new ArrayList<>();		arrlist.add(hash1);		arrlist.add(hash2);		for (HashMap
         
           hash : arrlist) {			Set
          
            set = hash.keySet(); for (String key : set) { Integer value = hash.get(key); System.out.println(key + "\t" + value); } System.out.println("++++++++++++++++++"); } }}

输出：

AAA 111

CCC 333

BBB 222

++++++++++++++++++

EEE 555

DDD 444

FFF 666

++++++++++++++++++

d:多层嵌套

Test1：

import java.util.ArrayList;import java.util.HashMap;import java.util.Set;import java.util.TreeMap;/** * 捋一捋，防止搞晕了 *  * @author super *  *         treemap hash1 hash2 array1 array2 array3 ·array4 * */public class DuoCengQianTao {	public static void main(String[] args) {		// TODO Auto-generated method stub		// new a TreeMap		TreeMap
     
      
       
        >> treemap = new TreeMap<>();		// new two HashMap		HashMap
        
         
          > hash1 = new HashMap<>();		HashMap
          
           
            > hash2 = new HashMap<>(); // new four ArrayList ArrayList
            
              array1 = new ArrayList<>(); ArrayList
             
               array2 = new ArrayList<>(); ArrayList
              
                array3 = new ArrayList<>(); ArrayList
               
                 array4 = new ArrayList<>(); array1.add("array1_1"); array1.add("array1_2"); array1.add("array1_3"); array2.add("array2_1"); array2.add("array2_2"); array2.add("array2_3"); hash1.put("hash1_1", array1); hash1.put("hash1_2", array2); array3.add("array3_1"); array3.add("array3_2"); array3.add("array3_3"); array4.add("array4_1"); array4.add("array4_2"); array4.add("array4_3"); hash2.put("hash2_1", array3); hash2.put("hash2_2", array4); treemap.put("treemap1", hash1); treemap.put("treemap2", hash2); Set
                
                  set = treemap.keySet(); for (String key : set) { HashMap
                 
                  
                   > hash = treemap.get(key); System.out.println(key); Set
                   
                     set2 = hash.keySet(); for (String keys : set2) { ArrayList
                    
                      arr = hash.get(keys); System.out.println("  " + keys); for (String keys2 : arr) { System.out.println("\t" + keys2); } } } }}

输出：

hash1_2

array2_1

array2_2

array2_3

hash1_1

array1_1

array1_2

array1_3

treemap2

hash2_1

array3_1

array3_2

array3_3

hash2_2

array4_1

array4_2

array4_3

Test2：

import java.util.HashMap;import java.util.Set;public class HashMap_SanCengQianTao {	public static void main(String[] args) {		// TODO Auto-generated method stub		HashMap
     
      
       
        >> hashWai = new HashMap<>();		HashMap
        
         
          > hashZhong1 = new HashMap<>();		HashMap
          
           
            > hashZhong2 = new HashMap<>(); HashMap
            
              hashNei1 = new HashMap<>(); HashMap
             
               hashNei2 = new HashMap<>(); HashMap
              
                hashNei3 = new HashMap<>(); HashMap
               
                 hashNei4 = new HashMap<>(); hashNei1.put("hashNei1_1", 111); hashNei1.put("hashNei1_2", 222); hashNei2.put("hashNei2_1", 333); hashNei2.put("hashNei2_2", 444); hashNei3.put("hashNei3_1", 555); hashNei3.put("hashNei3_2", 666); hashNei4.put("hashNei4_1", 777); hashNei4.put("hashNei4_2", 888); hashZhong1.put("hashZhong1_1", hashNei1); hashZhong1.put("hashZhong1_2", hashNei2); hashZhong2.put("hashZhong2_1", hashNei3); hashZhong2.put("hashZhong2_2", hashNei4); hashWai.put("hashWai1", hashZhong1); hashWai.put("hashWai2", hashZhong2); Set
                
                  setWai = hashWai.keySet(); for (String keyWai : setWai) { HashMap
                 
                  
                   > hashzhong = hashWai.get(keyWai); System.out.println(keyWai); Set
                   
                     setZhong = hashzhong.keySet(); for (String keyZhong : setZhong) { HashMap
                    
                      hashnei = hashzhong.get(keyZhong); System.out.println("  " + keyZhong); Set
                     
                       setNei = hashnei.keySet(); for (String keyNei : setNei) { System.out.println("    "+keyNei); System.out.println("      " + hashnei.get(keyNei)); } } } }}

输出：

hashWai1

hashZhong1_1

hashNei1_1

111

hashNei1_2

222

hashZhong1_2

hashNei2_2

444

hashNei2_1

333

hashWai2

hashZhong2_2

hashNei4_2

888

hashNei4_1

777

hashZhong2_1

hashNei3_1

555

hashNei3_2

666

Test3：

Student类

package Jihe;public class Student {	private String name;	private int age;	public Student() {		super();		// TODO Auto-generated constructor stub	}	public Student(String name, int age) {		super();		this.name = name;		this.age = age;	}	public String getName() {		return name;	}	public void setName(String name) {		this.name = name;	}	public int getAge() {		return age;	}	public void setAge(int age) {		this.age = age;	}	}

Test类

package Jihe;import java.util.ArrayList;import java.util.HashMap;import java.util.Set;public class DuoCengHashMap {	public static void main(String[] args) {		// TODO Auto-generated method stub		// new 总 HashMap		HashMap
     
      
       
        >> zongbu = new HashMap<>();		// new 中层 HashMap		HashMap
        
         
          > dongbu = new HashMap<>();		HashMap
          
           
            > xibu = new HashMap<>(); // 底层HashMap
            
              ArrayList
             
               dong1 = new ArrayList<>(); ArrayList
              
                dong2 = new ArrayList<>(); ArrayList
               
                 xi1 = new ArrayList<>(); ArrayList
                
                  xi2 = new ArrayList<>(); // 底层集合添加数据 dong1.add(new Student("如来", 933)); dong1.add(new Student("观音", 922)); dong1.add(new Student("李靖", 911)); dong2.add(new Student("八戒", 860)); dong2.add(new Student("沙僧", 870)); dong2.add(new Student("猴哥", 880)); xi1.add(new Student("波多野结衣", 27)); xi1.add(new Student("樱井亚莉", 28)); xi1.add(new Student("苍井空", 29)); xi2.add(new Student("韦德", 34)); xi2.add(new Student("科比", 38)); xi2.add(new Student("邓肯", 39)); xi2.add(new Student("诺维斯基", 37)); // 中层集合添加数据 dongbu.put("天庭", dong1); dongbu.put("地坑", dong2); xibu.put("日本", xi1); xibu.put("美国", xi2); // 顶层集合添加数据 zongbu.put("东部", dongbu); zongbu.put("西部", xibu); // 获取顶层集合的键 Set
                 
                   zongSet = zongbu.keySet(); // 遍历等层集合 for (String keyZong : zongSet) { // 转换为中层元素 HashMap
                  
                   
                    > fenbu = zongbu.get(keyZong); // 输出一行顶层集合的键标示 System.out.println(keyZong); // 获取中层集合的键 Set
                    
                      fenSet = fenbu.keySet(); // 遍历中层集合 for (String keyFen : fenSet) { // 将中层集合的元素转换为底层集合类型 ArrayList
                     
                       jiceng = fenbu.get(keyFen); // 输出一行中层集合标示 System.out.println("  " + keyFen); // 遍历底层集合 for (Student stu : jiceng) { // Student s=(Student)stu; // System.out.println(" "+s.getName()+"---"+s.getAge()); // 输出集合元素 System.out.println("    " + stu.getName() + "---" + stu.getAge()); } } } }}

输出：

东部

地坑

八戒---860

沙僧---870

猴哥---880

天庭

如来---933

观音---922

李靖---911

西部

美国

韦德---34

科比---38

邓肯---39

诺维斯基---37

日本

波多野结衣---27

樱井亚莉---28

苍井空---29

Demo：

import java.util.ArrayList;import java.util.HashMap;import java.util.Set;/* * 为了更符合要求： * 		这次的数据就看成是学生对象。 *  * 传智播客 * 		bj	北京校区 * 			jc	基础班 * 					林青霞		27 * 					风清扬		30 * 			jy	就业班	 * 					赵雅芝		28 * 					武鑫		29 * 		sh	上海校区 * 			jc	基础班 * 					郭美美		20 * 					犀利哥		22 * 			jy	就业班	 * 					罗玉凤		21 * 					马征		23 * 		gz	广州校区 * 			jc	基础班 * 					王力宏		30 * 					李静磊		32 * 			jy	就业班	 * 					郎朗		31 * 					柳岩		33 * 		xa	西安校区 * 			jc	基础班 * 					范冰冰		27 * 					刘意		30 * 			jy	就业班	 * 					李冰冰		28 * 					张志豪		29 */public class HashMapDemo {	public static void main(String[] args) {		// 创建大集合		HashMap
     
      
       
        >> czbkMap = new HashMap
        
         
          
           >>(); // 北京校区数据 HashMap
           
            
             > bjCzbkMap = new HashMap
             
              
               >(); ArrayList
               
                 array1 = new ArrayList
                
                 (); Student s1 = new Student("林青霞", 27); Student s2 = new Student("风清扬", 30); array1.add(s1); array1.add(s2); ArrayList
                 
                   array2 = new ArrayList
                  
                   (); Student s3 = new Student("赵雅芝", 28); Student s4 = new Student("武鑫", 29); array2.add(s3); array2.add(s4); bjCzbkMap.put("基础班", array1); bjCzbkMap.put("就业班", array2); czbkMap.put("北京校区", bjCzbkMap); // 晚上可以自己练习一下 // 上海校区数据自己做 // 广州校区数据自己做 // 西安校区数据 HashMap
                   
                    
                     > xaCzbkMap = new HashMap
                     
                      
                       >(); ArrayList
                       
                         array3 = new ArrayList
                        
                         (); Student s5 = new Student("范冰冰", 27); Student s6 = new Student("刘意", 30); array3.add(s5); array3.add(s6); ArrayList
                         
                           array4 = new ArrayList
                          
                           (); Student s7 = new Student("李冰冰", 28); Student s8 = new Student("张志豪", 29); array4.add(s7); array4.add(s8); xaCzbkMap.put("基础班", array3); xaCzbkMap.put("就业班", array4); czbkMap.put("西安校区", xaCzbkMap); // 遍历集合 Set
                           
                             czbkMapSet = czbkMap.keySet(); for (String czbkMapKey : czbkMapSet) { System.out.println(czbkMapKey); HashMap
                            
                             
                              > czbkMapValue = czbkMap .get(czbkMapKey); Set
                              
                                czbkMapValueSet = czbkMapValue.keySet(); for (String czbkMapValueKey : czbkMapValueSet) { System.out.println("\t" + czbkMapValueKey); ArrayList
                               
                                 czbkMapValueValue = czbkMapValue .get(czbkMapValueKey); for (Student s : czbkMapValueValue) { System.out.println("\t\t" + s.getName() + "---" + s.getAge()); } } } }}

* 1:Hashtable和HashMap的区别?

* Hashtable:线程安全，效率低。不允许null键和null值

* HashMap:线程不安全，效率高。允许null键和null值

* 2:List,Set,Map等接口是否都继承子Map接口?

* List，Set不是继承自Map接口，它们继承自Collection接口

* Map接口本身就是一个顶层接口

2:Collections(理解)

(1)是针对集合进行操作的工具类

(2)面试题：Collection和Collections的区别

A:Collection 是单列集合的顶层接口，有两个子接口List和Set

B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等

(3)常见的几个小方法：

A:public static <T> void sort(List<T> list)

B:public static <T> int binarySearch(List<?> list,T key)

C:public static <T> T max(Collection<?> coll)

D:public static void reverse(List<?> list)

E:public static void shuffle(List<?> list)

(4)案例

A:ArrayList集合存储自定义对象的排序

B:模拟斗地主洗牌和发牌

C:模拟斗地主洗牌和发牌并对牌进行排序

1:集合(自己补齐)

Collection(单列集合)

List(有序,可重复)

ArrayList

底层数据结构是数组,查询快,增删慢

线程不安全,效率高

Vector

底层数据结构是数组,查询快,增删慢

线程安全,效率低

LinkedList

底层数据结构是链表,查询慢,增删快

线程不安全,效率高

Set(无序,唯一)

HashSet

底层数据结构是哈希表。

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

LinkedHashSet

底层数据结构由链表和哈希表组成。

由链表保证元素有序。

由哈希表保证元素唯一。

TreeSet

底层数据结构是红黑树。(是一种自平衡的二叉树)

如何保证元素唯一性呢?

根据比较的返回值是否是0来决定

如何保证元素的排序呢?

两种方式

自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

让集合接收一个Comparator的实现类对象

Map(双列集合)

A:Map集合的数据结构仅仅针对键有效，与值无关。

B:存储的是键值对形式的元素，键唯一，值可重复。

HashMap

底层数据结构是哈希表。线程不安全，效率高

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

LinkedHashMap

底层数据结构由链表和哈希表组成。

由链表保证元素有序。

由哈希表保证元素唯一。

Hashtable

底层数据结构是哈希表。线程安全，效率低

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

TreeMap

底层数据结构是红黑树。(是一种自平衡的二叉树)

如何保证元素唯一性呢?

根据比较的返回值是否是0来决定

如何保证元素的排序呢?

两种方式

自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

让集合接收一个Comparator的实现类对象

2:到底使用那种集合(自己补齐)

看需求。

是否是键值对象形式:

是：Map

键是否需要排序:

是：TreeMap

否：HashMap

不知道，就使用HashMap。

否：Collection

元素是否唯一:

是：Set

元素是否需要排序:

是：TreeSet

否：HashSet

不知道，就使用HashSet

否：List

要安全吗:

是：Vector(其实我们也不用它,后面我们讲解了多线程以后，我在给你回顾用谁)

否：ArrayList或者LinkedList

增删多：LinkedList

查询多：ArrayList

不知道，就使用ArrayList

3:集合的常见方法及遍历方式

Collection:

add()

remove()

contains()

iterator()

size()

遍历：

增强for

迭代器

|--List

get()

遍历：

普通for

|--Set

Map:

put()

remove()

containskey(),containsValue()

keySet()

get()

value()

entrySet()

size()

遍历：

根据键找值

根据键值对对象分别找键和值

作业：

我讲解过的任意一个集合，我要求你存储什么，你就能够存储什么。

并且，还要能够遍历出来。

4:ArrayList,LinkedList,HashSet,HashMap(掌握)

存储字符串和自定义对象数据并遍历

5:集合的嵌套遍历(理解)

转载于:https://blog.51cto.com/yizhimayi/1759212

你可能感兴趣的文章

Hadoop 2.5.1学习笔记7: 计数器的使用

Oracle 学习之RAC(三) Grid Infrastructure 安装

查看>>

Android应用开发之使用PhoneGap实现位置上报功能

查看>>

多线程爬取都挺好链接并保存到mongodb

查看>>

SQL 中Exist 和In的用法

查看>>

pymysql取代MySQL-python

在CentOS6.8下用脚本安装SaltStack