【JAVASE】HashMap与TreeMap的排序与存储对象的区别

已于 2022-10-17 21:55:56 修改
阅读量374 收藏
点赞数 1
分类专栏： JavaSE学习 文章标签： java jvm 算法
于 2022-10-14 18:26:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45720193/article/details/127325425
版权

文章目录

前言

我们知道，HashMap不会对键进行排序，而TreeMap会对键进行排序，当然这两者还有很多其他的区别，本文为了保持主题一致，只考虑排序的影响因素，当然本文实际上没有经过其他参考资料验证，也是在自己使用HashMap与TreeMap时所产生的疑惑，并且记录下来，比如当两者的key为integer时，两者都会对键进行排序，而对字符串、自定义类型却会体现不同。而网上探讨角度过于深奥，也许原因会与深层的机制有关，本人也不是很了解就不献丑了，在此仅演示一下两者的实例。

当然若有错误欢迎批评指正。

键为整形(Integer)

HashMap自动排序的情况

当hashmap的键的最大值与第二大的键相差小于16时（不包括16），hashmap会自动排序

package Lab7;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// Treemap会对键进行排序，而HashMap不会
public class Lab7_3 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		HashMap<Integer, String>mp=new HashMap<Integer,String>();		
		mp.put(11, "bna");
		mp.put(2, "apple");
		mp.put(1, "banana");
		mp.put(3, "chel");
		mp.put(5, "d");
		mp.put(4, "e");
		mp.put(7, "f");
		mp.put(6, "g");
		mp.put(8, "h");
		mp.put(10, "l");
		mp.put(9, "o");
		System.out.println(mp);
		Set<Integer>set=mp.keySet();
		Iterator<Integer>it=set.iterator();
		for (Integer i : mp.keySet()) {
			System.out.println("key: "+i+" value:"+mp.get(i));
		}
		TreeMap<Integer, String>MP=new TreeMap<Integer,String>();
		MP.put(11, "bna");
		MP.put(2, "apple");
		MP.put(1, "banana");
		MP.put(3, "chel");
		MP.put(5, "d");
		MP.put(4, "e");
		MP.put(7, "f");
		MP.put(6, "g");
		MP.put(8, "h");
		MP.put(10, "l");
		MP.put(9, "o");	
		System.out.println(MP);
		for (Integer i : MP.keySet()) {
			System.out.println("key: "+i+" value:"+MP.get(i));
		}
		
}

输出

{1=banana, 2=apple, 3=chel, 4=e, 5=d, 6=g, 7=f, 8=h, 9=o, 10=l, 11=bna}
key: 1 value:banana
key: 2 value:apple
key: 3 value:chel
key: 4 value:e
key: 5 value:d
key: 6 value:g
key: 7 value:f
key: 8 value:h
key: 9 value:o
key: 10 value:l
key: 11 value:bna
{1=banana, 2=apple, 3=chel, 4=e, 5=d, 6=g, 7=f, 8=h, 9=o, 10=l, 11=bna}
key: 1 value:banana
key: 2 value:apple
key: 3 value:chel
key: 4 value:e
key: 5 value:d
key: 6 value:g
key: 7 value:f
key: 8 value:h
key: 9 value:o
key: 10 value:l
key: 11 value:bna

可以看到，对于键为整形的映射关系，HashMap与TreeMap都会进行排序，这一点是众多教材都没有指出来的特殊情况，这一点也是我在实践中遇到的问题。

HashMap不会自动排序的情况

当hashmap键的最大值与第二大的键大于等于16时，hashmap不对该键进行排序，而其他小于16的键仍然会自动排序

package Lab6;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// Treemap会对键进行排序，而HashMap不会
public class Lab6_1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		HashMap<Integer, String>mp=new HashMap<Integer,String>();		
		mp.put(11, "bna");
		mp.put(2, "apple");
		mp.put(1, "banana");
		mp.put(3, "chel");
		mp.put(16, "ld");
		mp.put(5, "d");
		mp.put(4, "e");
		mp.put(15, "we");
		mp.put(17, "f");
		mp.put(6, "g");
		mp.put(32, "os");
		mp.put(8, "h");
		mp.put(10, "l");
		mp.put(9, "o");
		mp.put(12, "ll");
		mp.put(13, "oo");
		mp.put(14, "lsd");
		
		
		
		System.out.println(mp);
		Set<Integer>set=mp.keySet();
		Iterator<Integer>it=set.iterator();
		for (Integer i : mp.keySet()) {
			System.out.println("key: "+i+" value:"+mp.get(i));
		}
		TreeMap<Integer, String>MP=new TreeMap<Integer,String>();
		MP.put(11, "bna");
		MP.put(2, "apple");
		MP.put(1, "banana");
		MP.put(3, "chel");
		MP.put(16, "ld");
		MP.put(5, "d");
		MP.put(4, "e");
		MP.put(15, "we");
		MP.put(17, "f");
		MP.put(6, "g");
		MP.put(32, "os");
		MP.put(8, "h");
		MP.put(10, "l");
		MP.put(9, "o");
		MP.put(12, "ll");
		MP.put(13, "oo");
		MP.put(14, "lsd");
		
		
		System.out.println(MP);
		for (Integer i : MP.keySet()) {
			System.out.println("key: "+i+" value:"+MP.get(i));
		}
		
}
}

输出：

{32=os, 1=banana, 2=apple, 3=chel, 4=e, 5=d, 6=g, 8=h, 9=o, 10=l, 11=bna, 12=ll, 13=oo, 14=lsd, 15=we, 16=ld, 17=f}
key: 32 value:os
key: 1 value:banana
key: 2 value:apple
key: 3 value:chel
key: 4 value:e
key: 5 value:d
key: 6 value:g
key: 8 value:h
key: 9 value:o
key: 10 value:l
key: 11 value:bna
key: 12 value:ll
key: 13 value:oo
key: 14 value:lsd
key: 15 value:we
key: 16 value:ld
key: 17 value:f
{1=banana, 2=apple, 3=chel, 4=e, 5=d, 6=g, 8=h, 9=o, 10=l, 11=bna, 12=ll, 13=oo, 14=lsd, 15=we, 16=ld, 17=f, 32=os}
key: 1 value:banana
key: 2 value:apple
key: 3 value:chel
key: 4 value:e
key: 5 value:d
key: 6 value:g
key: 8 value:h
key: 9 value:o
key: 10 value:l
key: 11 value:bna
key: 12 value:ll
key: 13 value:oo
key: 14 value:lsd
key: 15 value:we
key: 16 value:ld
key: 17 value:f
key: 32 value:os

键为字符串

package Lab7;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// Treemap会对键进行排序，而HashMap不会
public class Lab7_3 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		HashMap<String, String>mp=new HashMap<>();		
		mp.put("11", "bna");
		mp.put("2", "apple");
		mp.put("1", "banana");
		mp.put("3", "chel");
		mp.put("5", "d");
		mp.put("4", "e");
		mp.put("7", "f");
		mp.put("6", "g");
		mp.put("8", "h");
		mp.put("10", "l");
		mp.put("9", "o");
		System.out.println(mp);
		Set<String>set=mp.keySet();
		Iterator<String>it=set.iterator();
		for (String i : mp.keySet()) {
			System.out.println("key: "+i+" value:"+mp.get(i));
		}
		TreeMap<String, String>MP=new TreeMap<String,String>();
		MP.put("11", "bna");
		MP.put("2", "apple");
		MP.put("1", "banana");
		MP.put("3", "chel");
		MP.put("5", "d");
		MP.put("4", "e");
		MP.put("7", "f");
		MP.put("6", "g");
		MP.put("8", "h");
		MP.put("10", "l");
		MP.put("9", "o");
		System.out.println(MP);
		for (String i : MP.keySet()) {
			System.out.println("key: "+i+" value:"+MP.get(i));
		}
}

输出

{11=bna, 1=banana, 2=apple, 3=chel, 4=e, 5=d, 6=g, 7=f, 8=h, 9=o, 10=l}
key: 11 value:bna
key: 1 value:banana
key: 2 value:apple
key: 3 value:chel
key: 4 value:e
key: 5 value:d
key: 6 value:g
key: 7 value:f
key: 8 value:h
key: 9 value:o
key: 10 value:l
{1=banana, 10=l, 11=bna, 2=apple, 3=chel, 4=e, 5=d, 6=g, 7=f, 8=h, 9=o}
key: 1 value:banana
key: 10 value:l
key: 11 value:bna
key: 2 value:apple
key: 3 value:chel
key: 4 value:e
key: 5 value:d
key: 6 value:g
key: 7 value:f
key: 8 value:h
key: 9 value:o

可以看到，HashMap没有进行排序，而TreeMap会对字符串的首字符进行排序，如"1",“10”,“11"首字符都为"1”,根据ASCII码都小于"2"

为了更好的说明，下面的例子将键改为字母进行比较：

package Lab7;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// Treemap会对键进行排序，而HashMap不会
public class Lab7_3 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		HashMap<String, String>mp=new HashMap<>();		
		mp.put("a", "bna");
		mp.put("b", "apple");
		mp.put("e", "banana");
		mp.put("r3", "chel");
		mp.put("t5", "d");
		mp.put("s4", "e");
		mp.put("fd7", "f");
		mp.put("jf6", "g");
		mp.put("l8", "h");
		mp.put("o10", "l");
		mp.put("p9", "o");
		System.out.println(mp);
		Set<String>set=mp.keySet();
		Iterator<String>it=set.iterator();
		for (String i : mp.keySet()) {
			System.out.println("key: "+i+" value:"+mp.get(i));
		}
		TreeMap<String, String>MP=new TreeMap<String,String>();
		MP.put("a", "bna");
		MP.put("b", "apple");
		MP.put("e", "banana");
		MP.put("r3", "chel");
		MP.put("t5", "d");
		MP.put("s4", "e");
		MP.put("fd7", "f");
		MP.put("jf6", "g");
		MP.put("l8", "h");
		MP.put("o10", "l");
		MP.put("p9", "o");
		System.out.println(MP);
		for (String i : MP.keySet()) {
			System.out.println("key: "+i+" value:"+MP.get(i));
		}
		
}

输出

{a=bna, r3=chel, t5=d, s4=e, b=apple, e=banana, fd7=f, p9=o, jf6=g, l8=h, o10=l}
key: a value:bna
key: r3 value:chel
key: t5 value:d
key: s4 value:e
key: b value:apple
key: e value:banana
key: fd7 value:f
key: p9 value:o
key: jf6 value:g
key: l8 value:h
key: o10 value:l
{a=bna, b=apple, e=banana, fd7=f, jf6=g, l8=h, o10=l, p9=o, r3=chel, s4=e, t5=d}
key: a value:bna
key: b value:apple
key: e value:banana
key: fd7 value:f
key: jf6 value:g
key: l8 value:h
key: o10 value:l
key: p9 value:o
key: r3 value:chel
key: s4 value:e
key: t5 value:d

可以看到，对于键为字符串的映射关系，TreeMap会对其进行ASCII码的比较进行排序，而HashMap则不会。

键为自定义类型

注意代码中对自定义类型重载了比较运算符，并重载了输出


package Lab7;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
// Treemap会对键进行排序，而HashMap不会
public class Lab7_3 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

		HashMap<student, Integer>lovesHashMap=new HashMap<>();
		lovesHashMap.put(new student("李白", 1), 2);
		lovesHashMap.put(new student("王安石", 2), 3);
		lovesHashMap.put(new student("格斯", 3), 4);
		lovesHashMap.put(new student("嘎哈", 4), 5);
		lovesHashMap.put(new student("李白1", 5), 6);
		lovesHashMap.put(new student("李白2", 6), 7);
		lovesHashMap.put(new student("李白3", 7), 8);
		lovesHashMap.put(new student("李白4", 8), 9);
		lovesHashMap.put(new student("李白5", 9), 10);
		for (student stu : lovesHashMap.keySet()) {
			System.out.println(stu);
		}
		System.out.println();
		TreeMap<student, Integer>lmp=new TreeMap<>();
		lmp.put(new student("李白", 1), 2);
		lmp.put(new student("王安石", 2), 3);
		lmp.put(new student("格斯", 3), 4);
		lmp.put(new student("嘎哈", 4), 5);
		lmp.put(new student("李白1", 5), 6);
		lmp.put(new student("李白2", 6), 7);
		lmp.put(new student("李白3", 7), 8);
		lmp.put(new student("李白4", 8), 9);
		lmp.put(new student("李白5", 9), 10);
		for (student stu : lmp.keySet()) {
			System.out.println(stu);
		}
	}

}
class student implements Comparable<student>{
	public student(String nameString,int id) {
		// TODO 自动生成的构造函数存根
		this.nameString=nameString;
		this.id=id;
	}
	private String nameString;
	private int id;
	@Override
	public int compareTo(student arg0) {
		// TODO 自动生成的方法存根
		if(this.id>arg0.id)return 1;
		else if(this.id<arg0.id)return -1;
		return 0;
	}
	@Override
	public String toString() {
		// TODO 自动生成的方法存根
		return "名字："+nameString+"      学号为："+id;
	}
}

输出

名字：李白      学号为：1
名字：嘎哈      学号为：4
名字：李白1      学号为：5
名字：格斯      学号为：3
名字：李白4      学号为：8
名字：李白3      学号为：7
名字：王安石      学号为：2
名字：李白5      学号为：9
名字：李白2      学号为：6

名字：李白      学号为：1
名字：王安石      学号为：2
名字：格斯      学号为：3
名字：嘎哈      学号为：4
名字：李白1      学号为：5
名字：李白2      学号为：6
名字：李白3      学号为：7
名字：李白4      学号为：8
名字：李白5      学号为：9

可以看到TreeMap的键进行了排序，而HashMap的并没有

总结

  1. 对于键为integer，HashMap与TreeMap都会进行排序
  2. 对于键为String，自定义类型，TreeMap会对键进行排序，而HashMap则不会
LenckCuak
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JavaSE024static与final使用陷阱续..pdf
06-24
JavaSE024static与final使用陷阱续..pdfJavaSE024static与final使用陷阱续..pdfJavaSE024static与final使用陷阱续..pdfJavaSE024static与final使用陷阱续..pdfJavaSE024static与final使用陷阱续..pdfJavaSE024static与final使用陷阱续..pdf
HashMap与 TreeMap区别
Zachary
10-12 720
Map： 在数组中是通过数组下标来对 其内容进行索引的，而Map是通过对象来对 对象进行索引的，用来 索引的对象叫键key，其对应的对象叫值value； 1、HashMap是通过hashcode()对其内容进行快速查找的；HashMap中的元素是没有顺序的； TreeMap中所有的元素都是有某一固定顺序的，如果需要得到一个有序的结果，就应该使用TreeMap； 2、HashMap和TreeMap都不是线程安全的； 3、HashMap继承AbstractMap类；覆盖了hashcode() 和equals()
Java HashMap和TreeMap的排序问题总结
影の聚宝盆
11-17 2442
Map存储的是key->value的值对，key的值是唯一的，而value的值可以重复。通常使用的是HashMap或TreeMap，如果考虑性能，使用HashMap。TreeMap使用红黑树实现，保留有key值顺序性，会自动按照key值排序。 默认是按照key值的升序排序，key值必须实现 Comparator接口。如果希望按找一定规则排序，则需要重新定义compare函数。 如:
Java_关于HashMap和TreeMap的排序问题
weixin_51578439的博客
11-18 199
原本从了解的资料知道HashMap是不会自动排序，TreeMap是可以自动排序的，晚上测试 了一下发现 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201118215701558.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTU3ODQzOQ==,size_16,color_FFFF
【JavaSE】Java基础语法(三十)：HashMap与TreeMap
莫等闲 白了少年头 空悲切
05-29 2841
HashMap底层是哈希表结构的依赖hashCode方法和equals方法保证键的唯一如果键要存储的是自定义对象，需要重写hashCode和equals方法TreeMap底层是红黑树结构依赖自然排序或者比较器排序,对键进行排序如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则HashMap和TreeMap都是常用的Java集合框架中的映射类型，实现了Java中Map接口，并且具有不同的特点和使用场景。
区别HashSet、TreeSet、HashMap、TreeMap
qq_41975950的博客
08-11 1019
1.首先HashSet和TreeSet都是set的实现类 : 而set中元素是无序、不重复的、所以他们两个只是对set进行了进一步的封装、实现了各自的功能  其中HashSet和TreeSet的区别就是：后者可以排序 、因为TreeSet底层是二叉树、通过传入比较器，可以自定义排序。但需要自定义比较器（通过实现implements Comparable接口重写compareTo（）方法或则在实例...
JavaSE进阶 | Map集合、HashMap集合、TreeMap集合
m0_61933976的博客
07-24 1589
JavaSE进阶 | Map集合、HashMap集合、TreeMap集合
Java中的HashMap与TreeMap
K.Sun
11-27 1240
原文地址：HashMap and TreeMap in JavaHashMap与TreeMap是Collection框架中的一部分。 HashMapjava.util.HashMap类是一种基于哈希的实现。在HashMap中，我们有一个key和一个value，pairHashMap<K, V> hmap = new HashMap<K, V>();我们考虑下面的例子，我们需要对已知整型数组中的
Java中HashMap、Hashtable、LinkedHashMap、TreeMap特点和区别
weixin_42263032的博客
07-17 520
Java中HashMap、Hashtable、LinkedHashMap、TreeMap特点和区别
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
JavaSE基础之变量与运算符复习（3）-CSDN@追光者♂
07-28
这是近期JavaSE基础系列练习过的源代码，还是十分适合Java复习或者Java初学者等学习的，欢迎大家下载练习，这部分内容已经在博客中记录。此外，主页专栏“Python从入门到人工智能”持续更新AI及前沿知识中，欢迎大家...
西安云工厂xaygc.com_JavaSE_04类与对象_旺旺老师
09-22
学习java,讲的很不错
JavaSE之Object与Object类
07-21
这这文件里的内容适合Java初学者，Object为基类，是所有类的父类，这里边对其进行了相关的介绍以及Object这个类的声明与调用。这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE入门者学习，...
【JavaSE】详解HashMap与HashTable区别
兴趣是最好的老师
05-26 2560
HashMap是Hashtable的轻量级实现（非线程安全的实现）都完成了Map接口，主要区别在于能否键对值能为null。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1057
介绍了Java泛型中的重要知识点——通配泛型及其应用。
获取Java 虚拟机进程ID（java应用进程Id的方法） Linux & windows
weixin_44131922的博客
04-30 505
这个命令会列出所有包含"java"的进程信息。从中你可以找到你的Java应用对应的进程行，第一列就是进程ID（PID）。这个命令会列出所有包含"java"的进程信息。在输出的信息中，你可以找到Java进程及其PID。替换为你的Java主类名或jar文件名的部分匹配字符串，pgrep会直接返回对应的进程ID。如果你需要在Java程序内部获取其自身的进程ID，可以使用。这段代码会打印出当前运行Java程序的进程ID。
springboot 获取maven打包时间
I do more ，you do less
04-30 501
【代码】springboot 获取maven打包时间。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1070
Java类与对象
javaee与javase区别
03-23
它包含了JavaSE的所有功能，并且还提供了一些额外的API和服务，如Servlet、JSP、EJB、JMS等。而JavaSE是Java Standard Edition的缩写，是Java平台的标准版，主要用于开发桌面应用程序和小型服务器应用程序。它包含了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LenckCuak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值