Day18_集合第四天

1、Map集合成员方法(掌握)


增加功能

V put(K key, V value)

当key在集合中不存在时，添加元素；当key在集合存在时候，替换元素

删除功能

void clear

清除所有键值对数据

V remove(Object key)

根据指定的键删除键值对

判断功能

boolean containsKey(Object key)

判断指定的键是否在集合中存在

boolean containsValue(Object value)

判断指定的值是否在集合中存在

boolean isEmpty

判断集合是否为空

获取功能

Set<Map.Entry<K,V>> entrySet()

键值对对象的集合

Object get(Object key)

根据键获取值

Set<K> keySet()

所有键的集合

Collection<V> values()

所有值的集合

长度

int size()

获取长度

 

 



2、Map集合的两种遍历方式(掌握)


创建

Map集合

  1. // 创建集合对象
  2. Map<String, String> map = new HashMap<String, String>();
  3. // 创建并添加元素
  4. map.put("杨过", "小龙女");
  5. map.put("郭靖", "黄蓉");
  6. map.put("梁山伯", "祝英台");
  7. map.put("牛郎", "织女");

第一种

遍历方式(通过keySet())

              

  1. Set<String> keySet = map.keySet();
  2. for(String key : keySet){
  3.     System.out.println("key:"+key+"  value"+map.get(key));
  4. }

第二种

遍历方式(通过entrySet())

当一个类或者一个接口被定义到类的成员位置的时候，在其他类中可以直接通过导入包名.外部类名.内部类名来使用。注意：这种方式只能创见引用，不能创建对象

package cn.itcast;
import cn.itcast.Outer.InnerClass;
public class Test {
    public static void main(String[] args) {
        InnerClass in = new Outer().new InnerClass();
        
    }
}

  1. Set<Entry<String,String>> entrySet = map.entrySet();
  2. for(Map.Entry<String, String> entry : entrySet){
  3.      System.out.println("key"+entry.getKey()+"
  4. value"+entry.getValue());
  5. }




3、HashMap存储自定义对象实现去重 (将自定义对象存储到Key的位置)(掌握)

需求：需要将自定义对象存储到key的位置，并实现去重功能，怎么办？

解决方案1:使用HashMap(建议)
     自定义对象重写hashCode()和equals()方法,并且使用HashMap

解决方案2:使用TreeMap(详见)
     方案1：自定义对象实现Comparable 接口,并且重写compareTo方法
     方案2：创建TreeMap集合对象时通过TreeMap的构造方法传入一个Comparator对象


4、TreeMap存储自定义对象实现排序 (将自定义对象存储到Key的位置)(掌握)

1、方案1
     自定义对象实现Comparable 接口,并且重写compareTo方法

2、方案2
     创建TreeMap集合对象时通过TreeMap的构造方法传入一个Comparator对象


5、面试题：HashTable和HashMap区别(掌握)


Hashtable,ConCurrentHashMap
               线程安全，效率低，不允许null键和值
HashMap:
               线程不安全，效率高，允许null键和值

Hashtable和ConCurrentHashMap都是线程安全的，并且都不能存储null键和null值,ConCurrentHashMap效率更高，推荐在开发中面试中使用,Hashtable一般使用的比较少  

6、集合体系-总结(掌握)

注意：只有Vector和HashTable是线程安全的，效率低。

Collection(单列集合)Map(双列集合)
|--Collection(单列)
  |--List(有序,可重复)
          |--ArrayList
                         底层数据结构是数组，查询快，增删慢。
                         线程不安全，效率高。
          |--Vector
                         底层数据结构是数组，查询快，增删慢。
                         线程安全，效率低。
          |--LinkedList    
                         底层数据结构是链表，查询慢，增删快。
                         线程不安全，效率高。
  |--Set(可能无序,肯定唯一)
          |--HashSet
                         底层数据结构是哈希表。
                         线程不安全，效率高。

                         怎么保证唯一性的呢?
                         它依赖两个方法：hashCode()和equals()
                         顺序：
                              首先判断hashCode()值是否相同。
                              同：继续走equals()，看返回值
                                   如果true：就不添加到集合。
                                   如果false：就添加到集合。
                              不同：就添加到集合。
           |--TreeSet
                         底层数据结构是二叉树。
                         线程不安全，效率高。

                         怎么保证唯一性的呢?是根据返回是否是0。
                         怎么保证排序的呢?两种方式
                              自然排序(元素具备比较性)
                                   实现Comparable接口
                              比较器排序(集合具备比较性)
                                   实现Comparator接口		|--Map(双列 底层结构是针对键有效，跟值无关)
    |--HashMap
                    底层数据结构是哈希表。
                    线程不安全，效率高。允许null键和值

                    怎么保证唯一性的呢?
                    它依赖两个方法：hashCode()和equals()
                    顺序：
                         首先判断hashCode()值是否相同。
                         同：继续走equals()，看返回值
                              如果true：就不添加到集合。
                              如果false：就添加到集合。
                         不同：就添加到集合。
   |--Hashtable
                    底层数据结构是哈希表。
                    线程安全，效率低。不允许null键和值

                    怎么保证唯一性的呢?
                    它依赖两个方法：hashCode()和equals()
                    顺序：
                         首先判断hashCode()值是否相同。
                         同：继续走equals()，看返回值
                              如果true：就不添加到集合。
                              如果false：就添加到集合。
                         不同：就添加到集合。
   |--TreeMap
                    底层数据结构是二叉树。
                    线程不安全，效率高。

                    怎么保证唯一性的呢?是根据返回是否是0。
                    怎么保证排序的呢?两种方式
                         自然排序(元素具备比较性)
                              实现Comparable接口
                         比较器排序(集合具备比较性)
                              实现Comparator接口




7、案例(掌握)

1、HashMap集合键是Student值是String的案例
2、LinkedHashMap演示(LinkedHashMap特点：可以保证怎么存就怎么取)
3、TreeMap集合键是Student值是String的案例(按照姓名排序)
4、集合嵌套之HashMap嵌套HashMap
5、统计字符中每个字符出现的次数
6、模拟斗地主洗牌和发牌，牌没有排序(了解)
7、Collections案例演示


8、案例代码(掌握)

1、HashMap集合键是Student值是String的案例
  1. /**
  2. 学生类
  3. */
  4. public class Student implements Comparable<Student> {
  5. 	private String name;
  6. 	private int age;
  7. 	public Student() {
  8. 		super();
  9. 		
  10. 	}
  11. 	public Student(String name, int age) {
  12. 		super();
  13. 		this.name = name;
  14. 		this.age = age;
  15. 	}
  16. 	public String getName() {
  17. 		return name;
  18. 	}
  19. 	public void setName(String name) {
  20. 		this.name = name;
  21. 	}
  22. 	public int getAge() {
  23. 		return age;
  24. 	}
  25. 	public void setAge(int age) {
  26. 		this.age = age;
  27. 	}
  28. 	@Override
  29. 	public String toString() {
  30. 		return "Student [name=" + name + ", age=" + age + "]";
  31. 	}
  32. 	@Override
  33. 	public int hashCode() {
  34. 		final int prime = 31;
  35. 		int result = 1;
  36. 		result = prime * result + age;
  37. 		result = prime * result + ((name == null) ? 0 : name.hashCode());
  38. 		return result;
  39. 	}
  40. 	@Override
  41. 	public boolean equals(Object obj) {
  42. 		if (this == obj)
  43. 			return true;
  44. 		if (obj == null)
  45. 			return false;
  46. 		if (getClass() != obj.getClass())
  47. 			return false;
  48. 		Student other = (Student) obj;
  49. 		if (age != other.age)
  50. 			return false;
  51. 		if (name == null) {
  52. 			if (other.name != null)
  53. 				return false;
  54. 		} else if (!name.equals(other.name))
  55. 			return false;
  56. 		return true;
  57. 	}
  58. 	@Override
  59. 	public int compareTo(Student o) {
  60. 		int num = this.age - o.age;					//以年龄为主要条件
  61. 		return num == 0 ? this.name.compareTo(o.name) : num;
  62. 	}
  63. }
  69. /**
  70. 测试类
  71. */
  72. public class Demo5_HashMap {
  73. 	/*
  74. 	 * * A:案例演示
  75. 	 * HashMap集合键是Student值是String的案例
  76. 	 * 键是学生对象,代表每一个学生
  77. 	 * 值是字符串对象,代表学生归属地
  78. 	 */
  79. 	public static void main(String[] args) {
  80. 		HashMap<Student, String> hm = new HashMap<>();
  81. 		hm.put(new Student("张三", 23), "北京");
  82. 		hm.put(new Student("张三", 23), "上海");
  83. 		hm.put(new Student("李四", 24), "广州");
  84. 		hm.put(new Student("王五", 25), "深圳");
  85. 		
  86. 		System.out.println(hm);
  87. 	}
  88. }
2、LinkedHashMap演示(LinkedHashMap特点：可以保证怎么存就怎么取)
  1. package com.heima.map;
  3. import java.util.LinkedHashMap;
  5. public class Demo6_LinkedHashMap {
  7. 	/**
  8. 	 * @param args
  9. 	 * LinkedHashMap可以保证怎么存就怎么取
  10. 	 */
  11. 	public static void main(String[] args) {
  12. 		LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
  13. 		lhm.put("张三", 23);
  14. 		lhm.put("李四", 24);
  15. 		lhm.put("赵六", 26);
  16. 		lhm.put("王五", 25);
  17. 		
  18. 		System.out.println(lhm);
  19. 	}
  21. }

3、TreeMap集合键是Student值是String的案例(按照姓名排序)
  1. package com.heima.map;
  3. import java.util.Comparator;
  4. import java.util.TreeMap;
  6. import com.heima.bean.Student;
  8. public class Demo7_TreeMap {
  10. 	/**
  11. 	 * * A:案例演示
  12. 	 * TreeMap集合键是Student值是String的案例
  13. 	 */
  14. 	public static void main(String[] args) {
  15. 		//demo1();
  16. 		TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {
  18. 			@Override
  19. 			public int compare(Student s1, Student s2) {
  20. 				int num = s1.getName().compareTo(s2.getName());		//按照姓名比较
  21. 				return num == 0 ? s1.getAge() - s2.getAge() : num;
  22. 			}
  23. 		});
  24. 		tm.put(new Student("张三", 23), "北京");
  25. 		tm.put(new Student("李四", 13), "上海");
  26. 		tm.put(new Student("赵六", 43), "深圳");
  27. 		tm.put(new Student("王五", 33), "广州");
  28. 		
  29. 		System.out.println(tm);
  30. 	}
  32. 	public static void demo1() {
  33. 		TreeMap<Student, String> tm = new TreeMap<>();
  34. 		tm.put(new Student("张三", 23), "北京");
  35. 		tm.put(new Student("李四", 13), "上海");
  36. 		tm.put(new Student("王五", 33), "广州");
  37. 		tm.put(new Student("赵六", 43), "深圳");
  38. 		
  39. 		System.out.println(tm);
  40. 	}
  42. }

4、集合嵌套之HashMap嵌套HashMap
  1. package com.heima.map;
  3. import java.util.HashMap;
  5. import com.heima.bean.Student;
  7. public class Demo8_HashMapHashMap {
  9. 	/**
  10. 	 * * A:案例演示
  11. 	 * 集合嵌套之HashMap嵌套HashMap
  12. 	 * 
  13. 	 * 需求:
  14. 	 * 双元课堂有很多基础班
  15. 	 * 第88期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
  16. 	 * 第99期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
  17. 	 * 
  18. 	 * 无论88期还是99期都是班级对象,所以为了便于统一管理,把这些班级对象添加到双元课堂集合中
  19. 	 */
  20. 	public static void main(String[] args) {
  21. 		//定义88期基础班
  22. 		HashMap<Student, String> hm88 = new HashMap<>();
  23. 		hm88.put(new Student("张三", 23), "北京");
  24. 		hm88.put(new Student("李四", 24), "北京");
  25. 		hm88.put(new Student("王五", 25), "上海");
  26. 		hm88.put(new Student("赵六", 26), "广州");
  27. 		
  28. 		//定义99期基础班
  29. 		HashMap<Student, String> hm99 = new HashMap<>();
  30. 		hm99.put(new Student("唐僧", 1023), "北京");
  31. 		hm99.put(new Student("孙悟空",1024), "北京");
  32. 		hm99.put(new Student("猪八戒",1025), "上海");
  33. 		hm99.put(new Student("沙和尚",1026), "广州");
  34. 		
  35. 		//定义双元课堂
  36. 		HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
  37. 		hm.put(hm88, "第88期基础班");
  38. 		hm.put(hm99, "第99期基础班");
  39. 		
  40. 		//遍历双列集合
  41. 		for(HashMap<Student, String> h : hm.keySet()) {		//hm.keySet()代表的是双列集合中键的集合
  42. 			String value = hm.get(h);						//get(h)根据键对象获取值对象
  43. 			//遍历键的双列集合对象
  44. 			for(Student key : h.keySet()) {					//h.keySet()获取集合总所有的学生键对象
  45. 				String value2 = h.get(key);
  46. 				
  47. 				System.out.println(key + "=" + value2 + "=" + value);
  48. 			}
  49. 		}
  50. 		
  51. 	}
  53. }


5、统计字符串中每个字符出现的次数
  1. package com.heima.test;
  3. import java.util.HashMap;
  5. public class Test1 {
  7. 	/**
  8. 	 * * A:案例演示
  9. 	 * 需求：统计字符串中每个字符出现的次数
  10. 	 * 
  11. 	 * 分析:
  12. 	 * 1,定义一个需要被统计字符的字符串
  13. 	 * 2,将字符串转换为字符数组
  14. 	 * 3,定义双列集合,存储字符串中字符以及字符出现的次数
  15. 	 * 4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
  16. 	 * 5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
  17. 	 * 6,打印双列集合获取字符出现的次数
  18. 	 */
  19. 	public static void main(String[] args) {
  20. 		//1,定义一个需要被统计字符的字符串
  21. 		String s = "aaaabbbbbccccccccccccc";
  22. 		//2,将字符串转换为字符数组
  23. 		char[] arr = s.toCharArray();
  24. 		//3,定义双列集合,存储字符串中字符以及字符出现的次数
  25. 		HashMap<Character, Integer> hm = new HashMap<>();
  26. 		//4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
  27. 		for(char c: arr) {
  28. 			//5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
  29. 			/*if(!hm.containsKey(c)) {			//如果不包含这个键
  30. 				hm.put(c, 1);
  31. 			}else {
  32. 				hm.put(c, hm.get(c) + 1);
  33. 			}*/
  34. 			hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
  35. 		}
  36. 		//6,打印双列集合获取字符出现的次数
  37. 		
  38. 		for (Character key : hm.keySet()) {				//hm.keySet()代表所有键的集合
  39. 			System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值
  40. 		}
  41. 	}
  43. }

6、模拟斗地主洗牌和发牌，牌没有排序(了解)
  1. package com.heima.test;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.HashMap;
  6. import java.util.TreeSet;
  8. public class Test3 {
  10. 	/**
  11. 	 * * A:案例演示
  12. 	 * 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
  13. 	 * 
  14. 	 *  分析:
  15. 	 * 1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
  16. 	 * 2,洗牌
  17. 	 * 3,发牌
  18. 	 * 4,看牌
  19. 	 */
  20. 	public static void main(String[] args) {
  21. 		//1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
  22. 		String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
  23. 		String[] color = {"红桃","黑桃","方片","梅花"};
  24. 		HashMap<Integer, String> hm = new HashMap<>();					//存储索引和扑克牌
  25. 		ArrayList<Integer> list = new ArrayList<>();					//存储索引
  26. 		int index = 0;
  27. 		
  28. 		//拼接扑克牌并索引和扑克牌存储在hm中
  29. 		for(String s1 : num) {											//获取数字
  30. 			for(String s2 : color) {									//获取颜色
  31. 				hm.put(index, s2.concat(s1));
  32. 				list.add(index);										//将索引0到51添加到list集合中
  33. 				index++;
  34. 			}
  35. 		}
  36. 		//将小王添加到双列集合中
  37. 		hm.put(index, "小王");
  38. 		list.add(index);												//将52索引添加到集合中
  39. 		index++;
  40. 		hm.put(index, "大王");
  41. 		list.add(index);												//将52索引添加到集合中
  42. 		
  43. 		//2,洗牌
  44. 		Collections.shuffle(list);
  45. 		//3,发牌
  46. 		TreeSet<Integer> gaojin = new TreeSet<>();
  47. 		TreeSet<Integer> longwu = new TreeSet<>();
  48. 		TreeSet<Integer> me = new TreeSet<>();
  49. 		TreeSet<Integer> dipai = new TreeSet<>();
  50. 		
  51. 		for(int i = 0; i < list.size(); i++) {
  52. 			if(i >= list.size() - 3) {
  53. 				dipai.add(list.get(i));							//将三张底牌存储在底牌集合中
  54. 			}else if(i % 3 == 0) {
  55. 				gaojin.add(list.get(i));
  56. 			}else if(i % 3 == 1) {
  57. 				longwu.add(list.get(i));
  58. 			}else {
  59. 				me.add(list.get(i));
  60. 			}
  61. 		}
  62. 		
  63. 		//看牌
  64. 		lookPoker(hm, gaojin, "高进");
  65. 		lookPoker(hm, longwu, "龙五");
  66. 		lookPoker(hm, me, "冯佳");
  67. 		lookPoker(hm, dipai, "底牌");
  68. 	}
  69. 	/*
  70. 	 * 看牌
  71. 	 * 1,返回值类型void
  72. 	 * 2,参数列表HashMap,TreeSet,String name
  73. 	 */
  74. 	public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts ,String name) {
  75. 		System.out.print(name + "的牌是:");
  76. 		for(Integer i : ts) {						//i代表双列集合中的每一个键
  77. 			System.out.print(hm.get(i) + " ");
  78. 		}
  79. 		System.out.println();
  80. 	}
  81. }


7、Collections案例演示
  1. package com.heima.collections;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  6. public class Demo1_Collecitons {
  8. 	/**
  9. 	 * 	Collecitons中的常见方法
  10. 	 * 	public static <T> void sort(List<T> list)
  11. 		public static <T> int binarySearch(List<?> list,T key)
  12. 		public static <T> T max(Collection<?> coll)
  13. 		public static void reverse(List<?> list)
  14. 		public static void shuffle(List<?> list)
  15. 	 */
  16. 	public static void main(String[] args) {
  17. 		//demo1();
  18. 		//demo2();
  19. 		ArrayList<String> list = new ArrayList<>();
  20. 		list.add("a");
  21. 		list.add("c");
  22. 		list.add("d");
  23. 		list.add("g");
  24. 		list.add("f");
  25. 		//System.out.println(Collections.max(list)); 			//根据默认排序结果获取集合中的最大值
  26. 		//Collections.reverse(list);							//反转集合
  27. 		Collections.shuffle(list);								//随机置换,可以用来洗牌
  28. 		System.out.println(list);
  29. 	}
  31. 	public static void demo2() {
  32. 		ArrayList<String> list = new ArrayList<>();
  33. 		list.add("a");
  34. 		list.add("c");
  35. 		list.add("d");
  36. 		list.add("f");
  37. 		list.add("g");
  38. 		
  39. 		System.out.println(Collections.binarySearch(list, "c"));
  40. 		System.out.println(Collections.binarySearch(list, "b"));
  41. 	}
  43. 	public static void demo1() {
  44. 		ArrayList<String> list = new ArrayList<>();
  45. 		list.add("c");
  46. 		list.add("a");
  47. 		list.add("a");
  48. 		list.add("b");
  49. 		list.add("d");
  50. 		
  51. 		System.out.println(list);
  52. 		Collections.sort(list);						//将集合排序
  53. 		System.out.println(list);
  54. 	}
  56. }



9、今天必须掌握的内容，面试题，笔试题。

1、HashMap中添加学生，姓名作为键，学生对象作为值，使用两种方式遍历
2、Hashtable和HashMap的区别
3、说说集合体系，最后那个大的总结背回
4、统计字符串中每个字符出现的次数
5、定义map<String,Integer>集合，集合中存储的元素：{"zhangsan",23}{"lisi",24}遍历集合中的元素，将key="张三"
6、有类似这样的字符串："1.2,3.4,5.6,7.8,5.56,44.55,5.4"请按照要求，依次完成以下试题。
* (1)以逗号作为分隔符，把已知的字符串分成一个String类型的数组，数组中的每一个元素类似于"1.2","3.4"这样的字符串
* (2)把数组中的每一个元素以
* "."作为分隔符，把"."左边的元素作为key，右边的元素作为value，封装到Map中，Map中的key和value都是Object类型。
* (3)把map中的key封装的Set中，并把Set中的元素输出。
* (4)把map中的value封装到Collection中，把Collection中的元素输出。




posted on 2016-12-23 09:51  虫虫爬啊爬  阅读(216)  评论(0)    收藏  举报

导航