黑马程序员——JAVA基础------集合框架（四）----Map集合

时间：2023-02-18 15:10:46

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——

一、Map接口

public interface Map<K,V>

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

黑马程序员——JAVA基础------集合框架（四）----Map集合
黑马程序员——JAVA基础------集合框架（四）----Map集合

二、HashMap

public class HashMap<K,V>extends AbstractMap<K,V> implements Map<K,V>,Cloneable,Serializable

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外， HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

代码演示：

package com.joe.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 * Map集合：该结合存储键值对。一对一对往里存，而且要保证键的唯一性。
 * 1、添加
 * 2、删除
 * clear()
 * 3、判断
 * containsValue(Object value)
 * containsKey(Object key)
 * 
 * 4、获取
 * get(Object key)
 * size()
 * values()
 * 
 * entrySet()
 * keySet()
 * 
 * Map
 * |--Hashtable
 * |--HashMap
 * |--TreeMap
 */




/*
 * 例子：每个学生都由对应的归属地
 * 学生Student,地址String
 * 学生属性：姓名，年龄。
 * 注意：姓名和年龄相同的视为同一个学生
 * 保证学生的唯一性
 */
public class HashMapDemo {
public static void main(String[] args) {
        HashMap<Student, String> hm = new HashMap<Student, String>();

        hm.put(new Student("lisi1", 21), "beijing");
        hm.put(new Student("lisi2", 22), "guangzhou");
        hm.put(new Student("lisi3", 23), "shenzhen");
        hm.put(new Student("lisi4", 24), "shanghai");

// 第一种取出方式 keySet

        Set<Student> keySet = hm.keySet();

        Iterator<Student> it = keySet.iterator();

while (it.hasNext()) {
            Student stu = it.next();
            String addr = hm.get(stu);
            System.out.println(stu + ".." + addr);

        }

//第二种取出方式 entrySet
        Set<Map.Entry<Student,String>> entrySet = hm.entrySet();

        Iterator<Map.Entry<Student, String>> iter= entrySet.iterator();

while (iter.hasNext()) {
            Map.Entry<Student, String> me = iter.next();
            Student stu = me.getKey();
            String addr  = me.getValue();
            System.out.println(stu + ".." + addr);

        }

    }
}

class Student implements Comparable<Student> {
private String name;
private int age;

public Student() {
    }

public Student(String name, int age) {
this.name = name;
this.age = age;
    }
//重写比较方法，使他能够自然排序
public int compareTo(Student s) {
int num = new Integer(this.age).compareTo(new Integer(s.age));
if (num == 0)
return this.name.compareTo(s.name);
return num;
    }
//重写hashCode方法
@Override
public int hashCode() {
return name.hashCode() + age * 34;
    }
//重写equals方法，保证唯一性
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Student))
throw new ClassCastException("类型不匹配");

        Student s = (Student) obj;

return this.name.equals(s.name) && this.age == s.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;
    }

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

}

三、Hashtable

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

此类实现一个哈希表,该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
为了成功地在哈希表中存储和获取对象,用作键的对象必须实现hashCode 方法和 equals 方法.

代码演示：

package com.joe.map;

import java.util.Hashtable;

/**
 * Hashtable实现类 
 * 1、不允许键值为null 
 * 2、用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表 
 * 3、线程安全的,同步
 */

public class HashTableDemo {
public static void main(String[] args) {
        Hashtable<String, String> table = new Hashtable<String, String>();
        table.put("学", "JAVA");
        table.put("进", "黑马");
        System.out.println(table);
    }

}

四、TreeMap

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable

基于红黑树(Red-Black tree)的 NavigableMap 实现。该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。

代码演示：

package com.joe.map;

import java.util.Map;
import java.util.TreeMap;

import com.joe.dynaproxy.Person;

/**
 * TreeMap实现类 
 * 1、使用二叉树中的红黑树实现 
 * 2、以key对象的自然顺序构造映射树
 * 3、使用自定义对象作为Key值时，该对象的类必须实现Comparable/Comparator接口实现比较规则
 */

public class TreeMapDemo {
public static void main(String[] args) {
        Map<Integer, String> map = new TreeMap<Integer, String>();
        map.put(1, "学JAVA");
        map.put(2, "进黑马");
        System.out.println(map);

        Map<Student, String> map2 = new TreeMap<Student, String>();
        map2.put(new Student("张三", 20), "张三");
        map2.put(new Student("李四", 22), "李四");
        System.out.println(map2);
    }
}

// 创建 Student 类
class Student implements Comparable<Student> {
private String name;
private int age;

public Student() {
    }

public Student(String name, int age) {
this.name = name;
this.age = age;
    }

// 重写比较方法，使他能够自然排序
public int compareTo(Student s) {
int num = new Integer(this.age).compareTo(new Integer(s.age));
if (num == 0)
return this.name.compareTo(s.name);
return num;
    }

// 重写hashCode方法
@Override
public int hashCode() {
return name.hashCode() + age * 34;
    }

// 重写equals方法，保证唯一性
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Student))
throw new ClassCastException("类型不匹配");

        Student s = (Student) obj;

return this.name.equals(s.name) && this.age == s.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;
    }

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

五、LinkedHashMap

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

Map 接口的哈希表和链接列表实现,具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于,后者维护着一个运行于所有条目的双重链接列表。

package com.joe.map;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * LinkedHashMap实现类 1、Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
 */
public class LinkedHashMapDemo {
public static void main(String[] args) {
        Map<Integer, String> map = new LinkedHashMap<Integer, String>();
        map.put(1, "学JAVA");
        map.put(2, "去黑马");
        System.out.println(map);
    }

}
标签：

相关文章