Map、Debug追踪

Map集合

  概述

  现实生活中，我们常会看到这样一种集合：IP地址和主机名，身份证号和个人，系统用户名与系统用户对象等，这种一一对应的关系，我们把它称之为映射。Java当中提供了专门的集合类用来存放这种映射关系的对象。即java.util.Map接口。

通过如下图发现Collection接口集合和Map接口集合存储数据的方式不一样。

• Collection中的集合，元素是孤立存在的（单身），向集合中存储元素采用一个一个元素存储的方式进行存储。

• Map中的集合，元素是成对存在的(夫妻)，每个元素由键和值两部分组成。通过键可以找到对应的值。

• Collection中的集合我们称之为单列集合，Map中的集合我们称之为双列集合

• 注意：Map中的集合不能包含重复的键，值可以重复，每个键对应唯一一个值。

Map中的常用子类

  通过查看API帮助文档发现有很多个子类，我们主要介绍HashMap集合、LinkedHaspMap集合、HashTable集合

• HashMap：存储数据采用的哈希表结构，元素的存取顺序可能不一致，由于要保证键的唯一性，不重复，需要重写键的hashCode方法和equals方法。

• LinkedHashMap：HashMap下面有个子类LinkedHashMap，存储数据的方式是采用哈希表结构+链表结构，通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证键的唯一、不重复，需要重写键的hashCode方法和equals方法。

HashMap集合的特点：

1. HashMap集合底层是哈希表：查询的速度非常快
   
     JDK1.8之前：数组+链表结构
   
     JDK1.8之后：数组+链表/红黑树(当链表长度超过8)：提高查询性能

2. HashMap集合是一个无序集合，存取顺序可能不一致
   
    java.util.LinkedHashMap<K,V> extends HashMap<K,V>

LinkedHaspMap集合特点：

  1、LinkedHaspMap集合底层是哈希表+链表（保证迭代的顺序）

  2、LinkedHaspMap集合是一个有序的集合，存取元素的顺序是一致的。

备注：Map接口当中，含有两个泛型变量，在使用时，要为两个泛型变量赋予数据类型，两个泛型变量的数据类型可以相同，也可以不同。

Map接口当中的常用API方法Map<K,V>

常用方法如下：

• public V put(K key,V value)：把指定的键与指定的值添加到Map集合当中

• public V remove(Object key)：把指定的键所对应的键值对元素从Map集合当中删除，返回被删除元素的值

• public V get(Object key)：根据指定的键 获得在Map集合当中对应的值

• public Set keySet()： 获取Map集合当中的所有的key值，存储到Set集合当中

• public Set<Map.Entry<K,V>> entrySet()：获取到Map集合当中的所有的键值对对象的集合（Set集合）

示例代码

public class Demo01Map {

    public static void main(String[] args) {

        show03();
    }
    /*
        public V get(Object key)：根据指定的键 获得在Map集合当中对应的值
            返回值：
               key存在，返回对应的value值
               key不存在，返回null
     */
    public static void show03() {
        Map<String,Integer> map = new HashMap<>();
        map.put("小孙", 30);
        map.put("小王", 25);
        map.put("小赵", 18);
        map.put("小刘", 19);
        System.out.println("-----------------------");
        System.out.println(map);// {小孙=30, 小刘=19, 小王=25, 小赵=18}

        // 使用get方法
        Integer v1 = map.get("小孙");
        System.out.println(v1);// 30

        Integer v2 = map.get("老王");
        System.out.println(v2);// null

    }

    /*
         public V remove(Object key)：把指定的键所对应的键值对元素从Map集合当中删除，返回被删除元素的值
             返回值V
                key存在，返回的是删除的对应的value值
                key不存在,返回null
     */
    public static void show02() {
        Map<String,Integer> map = new HashMap<>();
        map.put("小孙", 30);
        map.put("小王", 25);
        map.put("小赵", 18);
        map.put("小刘", 19);
        System.out.println("-----------------------");
        System.out.println(map);// {小孙=30, 小刘=19, 小王=25, 小赵=18}

        // 使用remove方法
        int v01 = map.remove("小孙");// 自动拆箱
        System.out.println(v01);// 30
        System.out.println("---------------------------");
        System.out.println(map);

        int v02 = map.remove("小李"); // NullPointerException
        System.out.println(v02);//null
        Integer int01 = 30;
        // int num01 = 30
        //int i = int01.intValue();
        // 建议使用包装类型  整数 浮点数 字符 布尔
    }

    /*
        public  V  put(K key,V value)：把指定的键与指定的值添加到Map集合当中
           返回值是V
                存储键值对的时候，key不重复，返回值V是null
                存储键值对的时候，key重复，会使用新的value值替换掉Map集合中原来的value值，返回的是被替换的value值
     */
    public static void show01() {
        //使用多态
        Map<String,String> map = new HashMap<>();
        String v01 = map.put("小孙", "小丽");
        System.out.println(v01);// null

        String v02 = map.put("小孙", "小花");
        System.out.println(v02);// 小丽
        System.out.println("==================");

        System.out.println(map);// {小孙=小花}
        map.put("小王", "小丽");
        map.put("小赵", "小美");
        map.put("小刘", "小芳");
        System.out.println("-----------------------");

        System.out.println(map);// {小孙=小花, 小刘=小芳, 小王=小丽, 小赵=小美}
    }
}

HashMap存储自定义类型键值

  练习：每位学生(姓名，年龄) 都有自己的家庭地址，学生作为键key值，家庭地址作为value值

    注意：同名同年龄的学生为同一学生

示例代码：

public class Student {

	private String name;
	private Integer age;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Student() {
		super();
	}
	public Student(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

public class Demo01HaspMap {

	public static void main(String[] args) {
		show02();

	}

	/*
	 * key:String类型
	 * 	  String类重写hashCode和equals方法，保证key唯一
	 * value: Student类型
	 * 		  value值允许重复的(同名同年龄为同一个人)
	 */
	public static void show02() {
		// 构建一个map集合
		HashMap<String, Student> map = new HashMap<>();
		map.put("洛阳市", new Student("范秀媛", 18));
		map.put("平顶山市", new Student("范秀媛", 18));
		map.put("南阳市", new Student("范秀媛", 18));
		map.put("郑州市", new Student("范秀媛", 18));
		// 查看下存储的元素情况
		// 使用keyset方法
		Set<String> set = map.keySet();
		// 使用迭代器进行遍历
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String key = iterator.next();
			Student student = map.get(key);
			System.out.println(key + "---->" + student);
		}
		/*
		 *  平顶山市---->Student [name=范秀媛, age=18]
			洛阳市---->Student [name=范秀媛, age=18]
			南阳市---->Student [name=范秀媛, age=18]
			郑州市---->Student [name=范秀媛, age=18]
		 */
	}	

	/*
	 * key:Student类型 不允许重复(同名同年龄的人为同一个人)
	 * value:String类型
	 *  Student [name=小丽, age=20]---->八大街
		Student [name=小孙, age=20]---->六大街
		Student [name=小王, age=22]---->八大街
	 */
	public static void show01() {
		// 构建一个HashMap集合
		HashMap<Student,String> map = new HashMap<>();
		map.put(new Student("小孙", 20), "六大街");
		map.put(new Student("小孙", 20), "六大街");
		map.put(new Student("小王", 22), "八大街");
		map.put(new Student("小丽", 20), "八大街");

		// 展示map中存储的元素
		// 使用Entry来进行遍历
		Set<Entry<Student,String>> set = map.entrySet();
		// 增强for循环
		for (Entry<Student, String> entry : set) {
			Student key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + "---->" + value);
		}
	}
}

当给HashMap中存储自定义对象时，如果自定义对象作为key存在，这时要保证对象的唯一性，必须重写对象的hashCode和equals方法

如果要保证map中存储元素的顺序。主要体现在key值，可以使用java.util.LinkedHashMap集合来存放

LinkedHashMap

  咱们知道HashMap保证成对元素的唯一，并且查询速度相对较快，但是成对元素存放进去无法保证顺序，既要保证有序，又要保证速度快可以使用LinkedHashMap

示例代码：

HashTable

java.util.Hashtable<K,V> implements Map<K,V>接口

• Hashtable:底层是一个哈希表，是一个线程安全的集合，是单线程的集合，速度慢

• HashMap: 底层也是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

• HashMap集合：可以存储null key值，null value值

• Hashtable集合：不可以存储null值，null键

• Hashtable 和 Vector集合一样，在JDK1.2版本之后被更先进的集合(HashMap,ArrayList)取代了

• Hashtable有一个子类Properties依然活跃在历史的舞台上

• Properties集合是一个唯一和IO流相结合的集合

练习：计算一个字符串中每个字符出现的次数

示例代码：

public static void show05() {
        LinkedHashMap<Character, Integer> map = new LinkedHashMap<>();
        String s = "hellowordhelloword";
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (map.get(c) == null) {
                map.put(c, 1);
            } else {
                map.put(c, map.get(c) + 1);
            }
        }
        System.out.println(map);
    }

Debug追踪

  在Eclipse中断点调试功能，查看程序的运行过程

Debug调试程序:

• 可以让代码逐行执行，查看代码的执行过程，调试程序中出现的bug

• 使用方式:

• 在行号的左边，鼠标左键双击，添加断点(添加到方法的首行，哪里有bug添加到哪里)

• 右键，选择Debug as --->Run Application 启动debug程序

• 执行程序：

• F8: 当前的程序执行到下一个断点处,如果没有下一个断点，那么程序就结束了

• Terminate：打断整个进程

• Step into(F5):进入到当前的方法

• Step Return(F7):退出当前执行的方法

• Step Over(F6):运行下一行代码,不进方法，但是有断点必须进来