JAVA学习笔记16_Java语言基础(集合框架4)

18.01_集合框架(Map集合概述和特点)

  • A:Map接口概述
    • 查看API可以知道:
      • 将键映射到值的对象
      • 一个映射不能包含重复的键
      • 每个键最多只能映射到一个值
  • B:Map接口和Collection接口的不同
    • Map是双列的,Collection是单列的
    • Map的键唯一,Collection的子体系Set是唯一的
    • Map集合的数据结构值针对键有效,跟值无关;Collection集合的数据结构是针对元素有效

18.02_集合框架(Map集合的功能概述)

  • A:Map集合的功能概述
    • a:添加功能
      • V put(K key,V value):添加元素。
        • 如果键是第一次存储,就直接存储元素,返回null
        • 如果键不是第一次存在,就用值把以前的值替换掉,返回以前的值
    • b:删除功能
      • void clear():移除所有的键值对元素
      • V remove(Object key):根据键删除键值对元素,并把值返回
    • c:判断功能
      • boolean containsKey(Object key):判断集合是否包含指定的键,包含返回true
      • boolean containsValue(Object value):判断集合是否包含指定的值
      • boolean isEmpty():判断集合是否为空
    • d:获取功能
      • Set<Map.Entry<K,V>> entrySet():
      • V get(Object key):根据键获取值
      • Set keySet():获取集合中所有键的集合
      • Collection values():获取集合中所有值的集合
    • e:长度功能
      • int size():返回集合中的键值对的个数

18.03_集合框架(Map集合的遍历之键找值)

  • A:键找值思路:
    • 获取所有键的集合
    • 遍历键的集合,获取到每一个键 ,HashMap没有迭代器I.但是HashSet有,通过keyset()方法返回Set,再利用迭代器就可以了
    • 根据键找值
  • B:案例演示

    • Map集合的遍历之键找值

      HashMap<String, Integer> hm = new HashMap<>();
      hm.put("张三", 23);
      hm.put("李四", 24);
      hm.put("王五", 25);
      hm.put("赵六", 26);
      //方法一
      Set<String> keySet = hm.keySet();           //获取集合中所有的键
      Iterator<String> it = keySet.iterator();    //获取迭代器
      while(it.hasNext()) {                       //判断单列集合中是否有元素
          String key = it.next();                 //获取集合中的每一个元素,其实就是双列集合中的键
          Integer value = hm.get(key);            //根据键获取值
          System.out.println(key + "=" + value);  //打印键值对
      }*/
      //方法二,更简单
      for(String key : hm.keySet()) {             //增强for循环迭代双列集合第一种方式
          System.out.println(key + "=" + hm.get(key));
      }
      

18.04_集合框架(Map集合的遍历之键值对对象找键和值)

  • A:键值对对象找键和值思路:
    • 获取所有键值对对象的集合
    • 遍历键值对对象的集合,获取到每一个键值对对象
    • 根据键值对对象找键和值

  • B:案例演示

    • Map集合的遍历之键值对对象找键和值

      
      import java.util.HashMap;
      import java.util.Map;
      import java.util.Map.Entry;
      
      
      public class Demo3_Iterator {
      	public static void main(String[] args) {
      		Map<String, Integer> map = new HashMap<>();
      		map.put("张三", 23);
      		map.put("李四", 24);
      		map.put("王五", 25);
      		map.put("赵六", 26);
      		
      		//Map.Entry说明Entry是Map的内部接口,将键和值封装成了Entry对象,并存储在Set集合中
      		/*Set<Entry<String, Integer>> entrySet = map.entrySet();
      		//获取每一个对象
      		Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
      		while(it.hasNext()) {
      			//获取每一个Entry对象
      			Map.Entry<String, Integer> en = it.next();	//父类引用指向子类对象
      			//Entry<String, Integer> en = it.next();	//直接获取的是子类对象
      			String key = en.getKey();			//根据键值对对象获取键
      			Integer value = en.getValue();			//根据键值对对象获取值
      			System.out.println(key + "=" + value);
      		}*/
      	//简单代码	
      	for(Entry<String, Integer> en : map.entrySet()) {
      			System.out.println(en.getKey() + "=" + en.getValue());
      		}
      	}
      
      
      }

18.05_集合框架(HashMap集合键是Student值是String的案例)

  • A:案例演示
    • HashMap集合键是Student值是String的案例
    • 	public static void main(String[] args) {
      		HashMap<Student, String> hm = new HashMap<>();
      		hm.put(new Student("张三", 23), "北京");
      		hm.put(new Student("张三", 23), "上海");
      		hm.put(new Student("李四", 24), "广州");
      		hm.put(new Student("王五", 25), "深圳");
      		
      		System.out.println(hm);
      	}
      如果想第二个张三 23覆盖掉第一个,需要在Student里重写equals方法和hashcode方法

18.06_集合框架(LinkedHashMap的概述和使用)

  • A:案例演示
    • LinkedHashMap的特点
      • 底层是链表实现的可以保证怎么存就怎么取

18.07_集合框架(TreeMap集合键是Student值是String的案例)

  • A:案例演示
    • TreeMap集合键是Student值是String的案例,需要重写
    • 比较器或者重写Student里的comparable方法

18.08_集合框架(统计字符串中每个字符出现的次数)

  • A:案例演示

    • 需求:统计字符串中每个字符出现的次数 String str = "aaaabbbcccccccccc"; 

      
      import java.util.HashMap;
      public class Test1 {
      	 * 分析:
      	 * 1,定义一个需要被统计字符的字符串
      	 * 2,将字符串转换为字符数组
      	 * 3,定义双列集合,存储字符串中字符以及字符出现的次数
      	 * 4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
      	 * 5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
      	 * 6,打印双列集合获取字符出现的次数
      	 */
      	public static void main(String[] args) {
      		//1,定义一个需要被统计字符的字符串
      		String s = "aaaabbbbbccccccccccccc";
      		//2,将字符串转换为字符数组
      		char[] arr = s.toCharArray();
      		//3,定义双列集合,存储字符串中字符以及字符出现的次数
      		HashMap<Character, Integer> hm = new HashMap<>();
      		//4,遍历字符数组获取每一个字符,并将字符存储在双列集合中
      		for(char c: arr) {
      			//5,存储过程中要做判断,如果集合中不包含这个键,就将该字符当作键,值为1存储,如果集合中包含这个键,就将值加1存储
      			/*if(!hm.containsKey(c)) {			//如果不包含这个键
      				hm.put(c, 1);
      			}else {
      				hm.put(c, hm.get(c) + 1);
      			}*/
      			hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
      		}
      		//6,打印双列集合获取字符出现的次数
      		
      		for (Character key : hm.keySet()) {				//hm.keySet()代表所有键的集合
      			System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值
      		}
      	}
      
      
      }
      

18.09_集合框架(集合嵌套之HashMap嵌套HashMap)

  • A:案例演示
    • 集合嵌套之HashMap嵌套HashMap
    • import java.util.HashMap;
      
      import com.heima.bean.Student;
      
      public class Demo8_HashMapHashMap {
      
      	/**
      	 * * A:案例演示
      	 * 集合嵌套之HashMap嵌套HashMap
      	 * 
      	 * 需求:
      	 * 双元课堂有很多基础班
      	 * 第88期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
      	 * 第99期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
      	 * 
      	 * 无论88期还是99期都是班级对象,所以为了便于统一管理,把这些班级对象添加到双元课堂集合中
      	 */
      	public static void main(String[] args) {
      		//定义88期基础班
      		HashMap<Student, String> hm88 = new HashMap<>();
      		hm88.put(new Student("张三", 23), "北京");
      		hm88.put(new Student("李四", 24), "北京");
      		hm88.put(new Student("王五", 25), "上海");
      		hm88.put(new Student("赵六", 26), "广州");
      		
      		//定义99期基础班
      		HashMap<Student, String> hm99 = new HashMap<>();
      		hm99.put(new Student("唐僧", 1023), "北京");
      		hm99.put(new Student("孙悟空",1024), "北京");
      		hm99.put(new Student("猪八戒",1025), "上海");
      		hm99.put(new Student("沙和尚",1026), "广州");
      		
      		//定义双元课堂
      		HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
      		hm.put(hm88, "第88期基础班");
      		hm.put(hm99, "第99期基础班");
      		
      		//遍历双列集合
      		for(HashMap<Student, String> h : hm.keySet()) {	//hm.keySet()代表的是双列集合中键的集合
      			String value = hm.get(h);		//get(h)根据键对象获取值对象
      			//遍历键的双列集合对象
      			for(Student key : h.keySet()) {		//h.keySet()获取集合总所有的学生键对象
      				String value2 = h.get(key);
      				
      				System.out.println(key + "=" + value2 + "=" + value);
      			}
      		}
      		
      	}
      
      }
      


18.10_集合框架(HashMap和Hashtable的区别)

  • A:面试题
    • HashMap和Hashtable的区别
      • Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高
      • Hashtable不可以存储null键和null值,HashMap可以存储null键和null值

18.11_集合框架(Collections工具类的概述和常见方法讲解)

  • A:Collections类概述
    • 针对集合操作 的工具类  类似于数组的Arrays类
    • 里面都是静态方法,直接类名.方法名调用即可
  • B:Collections成员方法
  • public static <T> void sort(List<T> list)
    public static <T> int binarySearch(List<?> list,T key)
    public static <T> T max(Collection<?> coll)
    public static void reverse(List<?> list)
    public static void shuffle(List<?> list)//随机置换,可以用来洗牌
    

18.12_集合框架(模拟斗地主洗牌和发牌)

  • A:案例演示

    • 模拟斗地主洗牌和发牌,牌没有排序

    • import java.util.ArrayList;
      import java.util.Collections;
      
      public class Test2 {
      
      	/**
      	 * * A:案例演示
      	 * 模拟斗地主洗牌和发牌,牌没有排序
      	 * 
      	 * 分析:
      	 * 1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
      	 * 2,洗牌
      	 * 3,发牌
      	 * 4,看牌
      	 */
      	public static void main(String[] args) {
      		//1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
      		String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
      		String[] color = {"红桃","黑桃","方片","梅花"};
      		ArrayList<String> poker = new ArrayList<>();
      		
      		//拼接花色和数字
      		for(String s1 : color) {
      			for(String s2 : num) {
      				poker.add(s1.concat(s2)); 			//concat连接两个字符串
      			}
      		}
      		poker.add("小王");
      		poker.add("大王");
      		//2,洗牌
      		Collections.shuffle(poker);
      		//3,发牌
      		ArrayList<String> gaojin = new ArrayList<>();
      		ArrayList<String> longwu = new ArrayList<>();
      		ArrayList<String> me = new ArrayList<>();
      		ArrayList<String> dipai = new ArrayList<>();
      		
      		for(int i = 0; i < poker.size(); i++) {
      			if(i >= poker.size() - 3) {
      				dipai.add(poker.get(i));					//将三张底牌存储在底牌集合中
      			} else if(i % 3 == 0) {
      				gaojin.add(poker.get(i));
      			} else if(i % 3 == 1) {
      				longwu.add(poker.get(i));
      			} else {
      				me.add(poker.get(i));
      			}
      		}
      		
      		//4,看牌
      		System.out.println(gaojin);
      		System.out.println(longwu);
      		System.out.println(me);
      		System.out.println(dipai);
      	}
      
      }
      

18.13_集合框架(模拟斗地主洗牌和发牌并对牌进行排序的原理图解)

  • A:画图演示
    • 画图说明排序原理

18.14_集合框架(模拟斗地主洗牌和发牌并对牌进行排序的代码实现)

  • A:案例演示
    • 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
    • 
      import java.util.ArrayList;
      import java.util.Collections;
      import java.util.HashMap;
      import java.util.TreeSet;
      
      public class Test3 {
      
      	/**
      	 * * A:案例演示
      	 * 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
      	 * 
      	 *  分析:
      	 * 1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
      	 * 2,洗牌
      	 * 3,发牌
      	 * 4,看牌
      	 */
      	public static void main(String[] args) {
      		//1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
      		String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
      		String[] color = {"红桃","黑桃","方片","梅花"};
      		HashMap<Integer, String> hm = new HashMap<>();					//存储索引和扑克牌
      		ArrayList<Integer> list = new ArrayList<>();					//存储索引
      		int index = 0; 
      		
      		//拼接扑克牌并索引和扑克牌存储在hm中
      		for(String s1 : num) {											//获取数字
      			for(String s2 : color) {									//获取颜色
      				hm.put(index, s2.concat(s1));
      				list.add(index);										//将索引0到51添加到list集合中
      				index++;
      			}
      		}
      		//将小王添加到双列集合中
      		hm.put(index, "小王");
      		list.add(index);												//将52索引添加到集合中
      		index++;
      		hm.put(index, "大王");
      		list.add(index);												//将52索引添加到集合中
      		
      		//2,洗牌
      		Collections.shuffle(list);
      		//3,发牌
      		TreeSet<Integer> gaojin = new TreeSet<>();
      		TreeSet<Integer> longwu = new TreeSet<>();
      		TreeSet<Integer> me = new TreeSet<>();
      		TreeSet<Integer> dipai = new TreeSet<>();
      		
      		for(int i = 0; i < list.size(); i++) {
      			if(i >= list.size() - 3) {
      				dipai.add(list.get(i));							//将三张底牌存储在底牌集合中
      			}else if(i % 3 == 0) {
      				gaojin.add(list.get(i));
      			}else if(i % 3 == 1) {
      				longwu.add(list.get(i));
      			}else {
      				me.add(list.get(i));
      			}
      		}
      		
      		//看牌
      		lookPoker(hm, gaojin, "高进");
      		lookPoker(hm, longwu, "龙五");
      		lookPoker(hm, me, "冯佳");
      		lookPoker(hm, dipai, "底牌");
      	}
      	/*
      	 * 看牌
      	 * 1,返回值类型void
      	 * 2,参数列表HashMap,TreeSet,String name
      	 */
      	public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts ,String name) {
      		System.out.print(name + "的牌是:");
      		for(Integer i : ts) {						//i代表双列集合中的每一个键
      			System.out.print(hm.get(i) + " ");
      		}
      		System.out.println();
      	}
      }
      


18.15_集合框架(泛型固定下边界)

  • ? super E


阅读更多
个人分类: JAVA
上一篇JAVA学习笔记15_Java语言基础(集合框架3)
下一篇JAVA学习笔记16_Java语言基础(集合练习题总结)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭