Map、HashMap、HashTable、SortedMap

最新推荐文章于 2025-05-10 14:36:42 发布

原创最新推荐文章于 2025-05-10 14:36:42 发布

· 912 阅读

1 ·

版权

文章标签：

#java

面向对象专栏收录该内容

9 篇文章

订阅专栏

本文介绍了Java集合框架中的Map接口及其常见实现类HashMap、HashTable和SortedMap。HashMap是基于哈希表的数据结构，提供快速查询，非线程安全；HashTable是线程安全但效率较低；SortedMap接口表示有序的键值对集合，TreeMap是其实现类，底层采用二叉树。此外，文章还对比了它们的特点和使用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、Map
1.解释：和Collection没有关系，Map是一个双列集合，是按照键值对的形式存储的，Map集合中键不可以重复，值可以重复，
2.Map集合下主要集合有HashMap和LinedHashMap这两个集合，
3.注：Map和Collection没有关系；Map集合的存储方式是Key和Value键值对的方式存储的；key和value都是存储java对象的内存地址，所有的Map集合中的key都是无序不可重复；Map<K,V>，双列集合，一个元素有两个值，k、v值数据类型可以相同，可以不同，k、v值一一对应，k值不可以重复，v值可以
4.Map常用方法：
put：添加元素
remove：删除
get：获取
keySet：获取集合的key值
Set：获取Map集合中所有的元素，存储到Set中
Set<Map.Entry<K,V>> entry 找到Map集合中所有的键值对对象的集合

二、HashMap集合
1.底层是哈希表=数组+链表+红黑树，属于非线程安全，在jdk1.8之后，哈希表的单向链表存储的长度超过八位，自动转化为红黑树，提高查询速度，当长度低于六位的时候，自动转化为单向链表，目的是提高检索速度，二叉树的目的是未来减少检索范围；
注：HashMap<K,V>按照键值对的方式存储，底层哈希表，查询速度特别快，jdk1.8之后，哈希表=数组+链表+红黑树，元素无序不重复，存储和取出元素的顺序可能不一样，，默认加载因子16，扩容原来的2倍，HashMap集合中元素可以为null，k值不允许重复，v值可以重复

三、HashTable集合
HashTable属于线程安全，其中所有的方法都是包含synchronized关键字修饰，线程安全，效率低，很少使用，
properties类：属于HashTable集合下的类，线程安全，继承了HashTable，特殊的是在存储键值对时，只能存储String类型的不支持其他类型properties被叫做属性类
注：jdk1.2之后，如果不需要实现线程安全的话，使用HashMap代替HashTable类，如果需要实现线程安全的话，使用ConcurrentHashMap代替HashTable,HashTable在开发中一般不用，但是其下的实现类properties是唯一一个和io有关系的类

四、SortedMap
特点：集合无序不重复，部分key值会自动排序，成为可排序的集合
五、TreeMap
特点：底层：二叉树

五、前次答案

一、请简述List接口的特点。
List集合存储和取出元素的顺序是相同的，集合有索引，可以用for循环遍历，可以有重复元素，有三个实现类，分别是ArrayList、LinedList、Vector三个，首先ArrayList底层是数组，查询快，原因是数组是连续存储，可以根据首地址，查询所有元素，增删慢，数组长度固定，每增加或者删除一个元素，都需要创建一个数组，把原来的数组放入新数组里面，LinedList底层是链表，查询速度慢：链表存储元素是不连续的，每次查找都需要从头开始，增删快，存储和取出数据对链表没有影响,Vector底层数组，线程安全，效率低，很少用。
二、请简述HashSet去除重复元素的原理。
首先HashSet集合的特点就是无序，不重复元素，没有索引，for循环无法遍历，HashSet内有hashCode和equals方法，调用被添加元素的hashCode与HasSet里面的值进行比较，不相同存储，调用equals比较元素是否相同相不同直接存储元素，相同则认为时同一元素，不存储，底层是哈希表，哈希表=数组+链表+红黑树，数组的作用是将集合中元素数据类型相同的放在一个数组里面，链表和红黑树是将数组连接起来，当链表存储的长度超过八位时，会自动转化为红黑树，当红黑树存储的长度低于六位时，转化为链表。
三、简述常见的数据结构中元素的存取特点。
栈(stack)：先进后出，进出口在同一侧
队列(queue)：先进先出,
数组(Array)：有序序列，存储特点：查询快，根据索引，快速查到到对应元素，增删慢，数组长度固定，存取都需要新建一个数组，把原来的舒张压放进去
链表：多个节点之间，通过地址链接，存储特点：查找慢，每次查找都需要从头开始，增删快，链表存储都是无序的，增加或者删除一个元素，对链表没有影响
四、简述Comparable和Comparator两个接口的区别。
首先：他们都是用来作为比较器使用，作为两个集合元素比较大小的接口，前者如果需要使用，必修重写接口里面的比较方法CompareTo，重新编写比较规则，格式：this.变量名 = o.变量名，前者减去后者，升序排列，后者减去前者，降序排列，对于Comparator接口，需要在实现类里面重写Compare方法，需要重写比较规则，只需要修改的比较的是什么即可，o1-o2升序，o2-o1降序。
五、根据要求练习LinkedList方法：
（1）基本方法：add, set, get, remove, clear, size等方法；
（2）特有方法：addFirst, addLast, getFirst, getLast, removeFirst,removeLast, push, pop, clear等方法。
package Week8;

import java.util.LinkedList;

public class demo5 {
public static void main(String[] args) {
LinkedList list = new LinkedList<>();
list.add(2);
list.add(3);
list.add(1);
list.add(4);
list.add(5);
System.out.println(“集合元素：”+list);
System.out.println(“插入元素：”+list.set(2,9));
System.out.println(“获取元素：”+list.get(4));
System.out.println(“清空集合：”);
list.clear();
System.out.println(“返回集合长度：”+list.size());

    list.addFirst(99);
    System.out.println("首部添加元素："+list);

    list.addLast(88);
    System.out.println("尾部添加元素："+list);
    System.out.println("获取首部元素："+list.getFirst());
    System.out.println("获取尾部元素："+list.getLast());
    System.out.println("删除首部元素："+list.removeFirst());
    System.out.println("删除尾部元素："+list.removeLast());

    list.push(1);
    System.out.println(list);

    System.out.println(list.pop()); //出栈
}

}
六、定义人类，包含姓名和年龄属性。创建4个人存储到HashSet中，姓名和年龄相同的人看做同一人不存储。
package Week8;

import java.util.HashSet;

public class demo6 {
public static void main(String[] args) {
demo6Student student1 = new demo6Student(“李白”,20);
demo6Student student2 = new demo6Student(“王昭君”,20);
demo6Student student3 = new demo6Student(“孙策”,19);
demo6Student student4 = new demo6Student(“孙策”,19);

    HashSet<demo6Student> set = new HashSet<>();
    set.add(student1);
    set.add(student2);
    set.add(student3);
    set.add(student4);

    System.out.println(set);
}

}

package Week8;

import java.util.Objects;

public class demo6Student {

private String name;
private int age;

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

@Override
public String toString() {
    return "demo6Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    demo6Student student = (demo6Student) o;
    return age == student.age &&
            Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

}
七、向list集合添加姓名{张三,李四,王五,二丫,钱六额,孙七},将二丫替换为王小丫。
package Week8;

import java.util.ArrayList;
import java.util.Collections;

public class demo7 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
Collections.addAll(list,“张三”,“李四”,“王五”,“二丫”,“钱六额”,“孙七”);
list.set(3,“王小丫”);
System.out.println(list);
}
}

八、使用LinkedHashSet存储以下元素：王昭君",“王昭君”,“王昭君”,“西施”,“杨玉环”,“貂蝉”,“貂蝉”。
使用迭代器和增强for循环遍历LinkedHashSet。
package Week8;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;

//八、使用LinkedHashSet存储以下元素：王昭君",“王昭君”,“王昭君”,“西施”,“杨玉环”,“貂蝉”,“貂蝉”。
// 使用迭代器和增强for循环遍历LinkedHashSet。
public class demo8 {
public static void main(String[] args) {
LinkedHashSet set = new LinkedHashSet();
Collections.addAll(set,“王昭君”,“王昭君”,“王昭君”,“西施”,“杨玉环”,“貂蝉”,“貂蝉”);
System.out.println(set);

    for (String string : set) {
        System.out.println(string);
    }
    Iterator it = set.iterator();
    while (it.hasNext()){
        System.out.println(it.next());
    }
}

}

//九、ArrayList集合中有如下内容： {33,11,77,55}，使用Collections.sort()对ArrayList集合中的数据进行排序，并打印出排序后的结果。
package Week8;

import java.util.ArrayList;
import java.util.Collections;

public class demo9 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
Collections.addAll(list,33,11,77,55);
Collections.sort(list);
System.out.println(list);
}
}
十、已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位String[] strs = {“12345”,“67891”,“12347809933”,“98765432102”,“67891”,“12347809933”}。
将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。
package Week8;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;

public class demo10 {
public static void main(String[] args) {
String[] strs = {“12345”,“67891”,“12347809933”,“98765432102”,“67891”,“12347809933”};
LinkedList linkedList = new LinkedList<>();
for (String string : strs) {
if (!linkedList.contains(string)){
linkedList.add(string);
}
}
System.out.println(linkedList);

    for (String string : linkedList) {
        System.out.println(string);
    }
    Iterator it = linkedList.iterator();
    while (it.hasNext()){
        System.out.println(it.next());
    }
}

}

十一、键盘录入一个字符串，去掉其中重复字符，打印出不同的那些字符，必须保证顺序。例如输入：aaaabbbcccdddee，打印结果为：abcde。
package Week8;

import java.util.LinkedHashSet;
import java.util.Scanner;

public class demo11 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入一个字符串：”);
String str = sc.next();

    char[] chars = str.toCharArray();
    LinkedHashSet<Character> linkedHashSet = new LinkedHashSet<>();
    for (char ss : chars) {
        linkedHashSet.add(ss);
    }
    System.out.println(linkedHashSet);
}

}
十二、双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择；蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）
package Week7;

import java.util.HashSet;
import java.util.Random;

十二、双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择；
蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）
*/
public class demo12 {
public static void main(String[] args) {
Random r = new Random();
HashSet set = new HashSet<>();
```
  while (set.size() < 6){
      int num1 = r.nextInt(33)+1;
      set.add(num1);
  }

  for (Integer ss : set) {
      System.out.print(ss+" ");
  }

  int num2 = r.nextInt(16)+1;
  System.out.print(num2);
```
}
}
十三、分别用Comparable和Comparator两个接口对四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。
Comparable:
package Week7;

import java.util.Collections;
import java.util.LinkedList;

public class demo13 {
public static void main(String[] args) {
demo13Student student1 = new demo13Student(“王昭君”,20,90);
demo13Student student2 = new demo13Student(“李白”,22,90);
demo13Student student3 = new demo13Student(“王笑笑”,20,99);
demo13Student student4 = new demo13Student(“xx”,22,100);
LinkedList linkedList = new LinkedList<>();
Collections.addAll(linkedList,student1,student2,student3,student4);

    System.out.println(linkedList);
}

}
students其他都可以生成：只需要重写Comparable方法即可：
@Override
public int compareTo(demo13Student o) {
int result = this.age - o.age; //前减后，升序，反之，降序
if (result == 0){
result = (int) (this.grade - o.grade);
}
return result;
}
Comoparator:
package Week7;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;

public class demo14 {
public static void main(String[] args) {
demo13Student student1 = new demo13Student(“王昭君”,20,90);
demo13Student student2 = new demo13Student(“李白”,22,90);
demo13Student student3 = new demo13Student(“王笑笑”,20,99);
demo13Student student4 = new demo13Student(“xx”,22,100);
LinkedList linkedList = new LinkedList<>();
Collections.addAll(linkedList,student1,student2,student3,student4);

    Collections.sort(linkedList, new Comparator<demo13Student>() {
        @Override
        public int compare(demo13Student o1, demo13Student o2) {
            int result = (int) (o1.getGrade()-o2.getAge()); //前减后，升序，反之，降序
            if (result == 0){
                result = o1.getAge()-o2.getAge();
            }
            return result;
        }
    });
    System.out.println(linkedList);
}

}

今日题库：
一、请简述Map 的特点。
二、说出Entry键值对对象遍历Map集合的原理。
三、请使用Map集合的方法完成添加元素，根据键删除，以及根据键获取值操作。
四、往一个Map集合中添加若干元素。获取Map中的所有value，并使用增强for和迭代器遍历输出每个value。
五、请使用Map集合存储自定义数据类型Car做键，对应的价格做值。并使用keySet和entrySet两种方式遍历Map集合。
六、现在有一个map集合如下：
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, “张三丰”);
map.put(2, “周芷若”);
map.put(3, “汪峰”);
map.put(4, “灭绝师太”);
要求：
1.遍历集合，并将序号与对应人名打印。
2.向该map集合中插入一个编码为5姓名为李晓红的信息
3.移除该map中的编号为1的信息
4.将map集合中编号为2的姓名信息修改为"周林"
七、有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。如{黑龙江省=哈尔滨, 浙江省=杭州, …}。
八、定义一个泛型为String类型的List集合，统计该集合中每个字符（注意，不是字符串）出现的次数。例如：集合中有”abc”、”bcd”两个元素，程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。
九、利用Map，完成下面的功能：
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯，则输出：没有举办世界杯。
十、在原有世界杯Map 的基础上，增加如下功能：读入一支球队的名字，输出该球队夺冠的年份列表。例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出没有获得过世界杯（注：历年世界冠军请百度）