Java_Map

最新推荐文章于 2023-07-02 19:25:36 发布
最新推荐文章于 2023-07-02 19:25:36 发布
阅读量431 收藏 1
点赞数 2
分类专栏： Java算法基础 文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51447496/article/details/127914162
版权

字典(Map)

概述

在这里插入图片描述

HashMap

定义方法

public static void main(String[] args) {
		// HashMap<Integer, String> Map = new HashMap<Integer, String>(); // 定义方法一
		Map<Integer, String> map = new HashMap<Integer, String>(); // 定义方法二
		// map没有add方法
		map.put(1, "LiHua");
		map.put(2, "zhanghua");
		map.put(3, "huanghuan");
		System.out.println(map);
		/*{1=LiHua, 2=zhanghua, 3=huanghuan}*/
	}

常用方法

在这里插入图片描述

put()与remove()

public static void main(String[] args) {
		// HashMap<Integer, String> Map = new HashMap<Integer, String>(); // 定义方法一
		Map<Integer, String> map = new HashMap<Integer, String>();
		// map没有add方法
		map.put(1, "LiHua");
		map.put(2, "zhanghua");
		map.put(3, "huanghuan");
		System.out.println(map);
		/*{1=LiHua, 2=zhanghua, 3=huanghuan}*/
		map.remove(1);
		map.remove(100);
		System.out.println(map);
		/*{2=zhanghua, 3=huanghuan}*/		
	}

containsKey()与containsValue()

public static void main(String[] args) {
		// HashMap<Integer, String> Map = new HashMap<Integer, String>(); // 定义方法一
		Map<Integer, String> map = new HashMap<Integer, String>();
		// map没有add方法
		map.put(1, "LiHua");
		map.put(2, "zhanghua");
		map.put(3, "huanghuan");
		System.out.println(map);
		/*{1=LiHua, 2=zhanghua, 3=huanghuan}*/
		
		System.out.println(map.containsKey(2));
		/*true*/
		
		map.remove(1);
		map.remove(100);
		System.out.println(map);
		/*{2=zhanghua, 3=huanghuan}*/		
		System.out.println(map.containsValue("LiHua"));
		/*false*/
	}

V get(Key) 与 V getOrDefault(Key, DefaultValue)

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		// get() 方法通过key值来获取value值
		System.out.println(map.get(1));/*Lihua*/
		
		// getOrDefault()  如果没有找到key 那么返回的value值就用第二个参数代替
		System.out.println(map.getOrDefault(4, "hahaha"));/*hahaha*/
	}

Set keySet

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		// keySet() 返回key值的集合
		System.out.println(map.keySet());
		/*[1, 2, 3]*/
	}

Collection values() 返回此字典中包含的Collection视图

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		System.out.println(tmap.values());
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		/*[dagu, xiaolong, xidong, zhangsan, zhangming, liming]*/
	}

**V remove(Oject key) ** 返回删除的key对应的value

boolean remove(Object key, Object value) 删除成功的话返回true

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		System.out.println(map.remove(1));
		/*Lihua*/
		System.out.println(map.remove(1));
		/*null*/
		System.out.println(map.remove(2, "Zhanghua"));
		/*true*/
		System.out.println(map.remove(2, "Zhanghua"));
		/*false*/
	}

V replace(K key, V value) 把key对应的value换成新的

boolean replace(K key, V oldValue, V newValue)

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		System.out.println(map.replace(1, "xiaolizi")); 
		/*Lihua*/
		System.out.println(map);
		/*{1=xiaolizi, 2=Zhanghua, 3=xiaozhang}*/
		
		System.out.println(map.replace(2, "Zhanghua", "daxiong")); 
		/*true*/
		System.out.println(map.replace(2, "Zhanghua", "daxiong")); 
		/*false*/  // 这里这个value指定错误 然后就不可以换成功
		System.out.println(map);
		/*{1=xiaolizi, 2=daxiong, 3=xiaozhang}*/
	}

Set<Map.Entry<K,V>> entrySet() 返回的是这个字典对应的键值对的集合

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		System.out.println(map.entrySet()); // 这里返回的是一个Set集合
		// 类型是Set<Map.Entry<K, V>>
		/*[1=Lihua, 2=Zhanghua, 3=xiaozhang]*/
	}

遍历方法

方式一

在这里插入图片描述

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		for(Integer i : map.keySet())
		{
			System.out.println(i + " " + map.get(i));
		}		
		/*
		   1 Lihua
		   2 Zhanghua
           3 xiaozhang
		 */
	}

方式二

在这里插入图片描述

public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "Lihua");
		map.put(2, "Zhanghua");
		map.put(3, "xiaozhang");
		
		for (Map.Entry<Integer, String> me: map.entrySet())
		{
			System.out.println(me.getKey() + " " + me.getValue());			
		}
		/*
		 * 1 Lihua
		   2 Zhanghua
           3 xiaozhang
		 * */
	}

LinkedHashMap

在这里插入图片描述

定义方法

public static void main(String[] args) {
		Map<Integer, String> linkmap = new LinkedHashMap<>();
		linkmap.put(1, "lihua");
		linkmap.put(2, "zhanghua");
		linkmap.put(3, "xiaobizhaizi");	
		System.out.println(linkmap);
		/*{1=lihua, 2=zhanghua, 3=xiaobizhaizi}*/
	}

常用方法

和HashMap一样

遍历方法

和HashMap一样

TreeMap

在这里插入图片描述

定义方法

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		// 默认按照key升序排列
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 100=liming}*/
	}

常用方法

**在HashMap的基础上多一些 **

Map.Entry<K, V> firstEntry()

K firstKey()

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.firstEntry()); // 返回最小key对应的映射
		/*1=dagu*/
		System.out.println(tmap.firstKey());  // 返回第一个key
		/*1*/
	}

Map.Entry<K, V> floorEntry(K key) 返回小于或等于指定key的最大key的映射

K floorKey(K key) 返回小于或等于指定key的最大的key

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.floorEntry(3)); 
		/*2=xiaolong*/
		System.out.println(tmap.floorKey(3));
		/*2*/
	}

Map.Entry<K, V> ceilingEntry(K key) 返回大于或等于指定key的key的映射

K ceilingKey(K key) 返回大于或等于指定key的key

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.ceilingEntry(3));
		/*45=xidong*/
		System.out.println(tmap.ceilingKey(3));
		/*45*/
	}

Map.Entry<K,V> firstEntry() 返回第一个key对应的映射

K firstKey() 返回第一个key对应的value

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.firstEntry());
		/*1=dagu*/
		System.out.println(tmap.firstKey());
		/*1*/
	}

Map.Entry<K,V> lastEntry() 返回最后一个key对应的映射

K lastKey() 返回最后一个key对应的value

	public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		System.out.println(tmap.lastEntry());
		/*100=liming*/
		System.out.println(tmap.lastKey());
		/*100*/
	}

SortedMap<K,V> headMap(K toKey) 放回此字典的部分视图 其中key值严格小于toKey的部分

NavigableMap<K,V> headMap<K toKey,boolean inclusive> inclusive为true表示有等于的情况

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap.headMap(45));
		/*{1=dagu, 2=xiaolong}*/
		System.out.println(tmap.headMap(45, true));  // 包含等于的情况
		/*{1=dagu, 2=xiaolong, 45=xidong}*/
	}

SortedMap<K,V> tailMap(K fromKey) 返回此字典的部分视图 其key大于等于 fromKey

NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) 这里的inclusive表示是否包含边界 为true包含

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap.tailMap(2));
		/*{2=xiaolong, 45=xidong, 66=zhangming, 100=liming}*/
		System.out.println(tmap.tailMap(2, false));
		/*{45=xidong, 66=zhangming, 100=liming}*/
	}

Map.Entry<K,V> higherEntry(K key) 返回大于指定key的最小的一个 如果没有返回null

K higherKey(K key) 返回大于指定key的最小一个key 如果没有返回null

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		System.out.println(tmap.higherEntry(45));  // 返回大于指定key的最小的一个映射
		/*50=zhangsan*/
		System.out.println(tmap.higherKey(45));	// 返回大于指定key的最小的一个key
		/*50*/
	}

Map.Entry<K,V> lowerEntry(K key) 返回小于这个key的最大的一个映射

K lowerKey(K key) 返回小于这个key的最大一个key

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		System.out.println(tmap.lowerEntry(50));  // 返回小于这个key的最大的一个映射
		/*45=xidong*/
		System.out.println(tmap.lowerKey(50));  // 返回小于这个key的最大一个key
		/*45*/
	}

Map.Entry<K,V> pollFirstEntry() 删除并返回此字典的第一个key对应的映射

Map.Entry<K,V> pollLastEntry() 删除并返回此字典的最后一个key对应的映射

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap.pollFirstEntry());
		/*1=dagu*/
		System.out.println(tmap);
		/*{2=xiaolong, 45=xidong, 66=zhangming, 100=liming}*/
		System.out.println(tmap.pollLastEntry());
		/*100=liming*/
		System.out.println(tmap);
		/*{2=xiaolong, 45=xidong, 66=zhangming}*/
	}

V remove(Object key) 从此TreeMap中删除此key对应的映射（如果存在）

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 66=zhangming, 100=liming}*/
		tmap.remove(2);
		System.out.println(tmap);
		/*{1=dagu, 45=xidong, 66=zhangming, 100=liming}*/
	}

NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回的视图 可以设置是否包含左右端点

SortedMap<K,V> subMap(K fromKey, K toKey) 返回的的字典的集合可以包含左端点 但是不包含右端点

public static void main(String[] args) {
		TreeMap<Integer, String> tmap = new TreeMap<>();
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{1=dagu, 2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming, 100=liming}*/
		System.out.println(tmap.subMap(2, 66));  // 只包含左边界
		/*{2=xiaolong, 45=xidong, 50=zhangsan}*/
		
		System.out.println(tmap.subMap(2, true, 66, true));  // 可以设置是否包含左右边界
		/*{2=xiaolong, 45=xidong, 50=zhangsan, 66=zhangming}*/
	}

遍历方法

和HashMap一样

排序

因为Map数据结构的特殊性质 导致使用Comparator()需要一些技巧

Comparator()只能对key值排序 所以如果想要对Key和Value都排序 可以自定义Pair类 把Key和Value封装在一起

然后把Key值设置为Pair类型 这个时候的Value随便什么都可以

public static void main(String[] args) {
		// 按照Key值从大到小排序
		TreeMap<Integer, String> tmap = new TreeMap<>(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				int num = 0;
				if (o1 > o2) num = -1;
				else num = 1;
				return num;
			}
		});
		tmap.put(100, "liming");
		tmap.put(1, "dagu");
		tmap.put(2, "xiaolong");
		tmap.put(45, "xidong");
		tmap.put(50, "zhangsan");
		tmap.put(66, "zhangming");
		System.out.println(tmap);
		/*{100=liming, 66=zhangming, 50=zhangsan, 45=xidong, 2=xiaolong, 1=dagu}*/
	}
极客李华
关注
专栏目录
list map转换成json格式例子以及相关jar包(java)
10-08
list map转换json格式数据以及相关的jar包 list转换后格式： [{"address":"广东省惠州","name":"tom","id":1,"age":23},{"address":"广东省深圳市","name":"jone","id":2,"age":84}] map转换后格式： {"address":"广东省惠州","name":"tom","id":1,"age":23}
map(java).rar_ map ja_MAP JAVA_java map_java系统_map
09-20
标题中的"map(java).rar_ map ja_MAP JAVA_java map_java系统_map"暗示了这是一个与Java编程语言相关的项目，特别是涉及到地图（Map）的实现。在Java中，`Map`是一个接口，它定义了键值对的数据结构，允许我们通过键...
Java——双向map BiMap
热门推荐
小欣儿的专栏
08-08 1万+
BiMap是guava中一个有用的集合类型，很简单，它就是一个双向的映射。 反向转换一个Map 一个普通的map是一个key/value的集合，你可以使用key来查询value，例如，我来创建一个字段： · Map<String,String> britishToAmerican = Maps.newHashMap(); britishToAmerican.put("auberg...
java双向集合Map
qq_44761778的博客
11-10 1017
java Map集合
转： java 双向map
weixin_34362991的博客
03-30 233
package tools; import java.util.HashMap; public class DuplexMap<K,V> { class Entry{ K k; V v; public Entry(K k,V v){ this.k=k; t...
java中的双列集合Map
qq_51476492的博客
03-13 670
Map
java_Map-sort.rar_Java编程_Java_
08-12
在Java编程领域，Map接口是Java集合框架的重要组成部分，它提供了键值对（key-value pairs）的存储方式。HashMap作为Map的一个实现，以其高效的查找性能和灵活的使用方式深受开发者喜爱。本篇将深入探讨Java中如何对...
JavaMap.rar_arraylist map_collection_java map_javamap_地图 java
09-23
在Java中，"javamap"和"地图_java"可能是指使用Map类来模拟现实世界中的地理地图，例如通过键表示地理位置，值表示该地点的信息。这涉及到自定义类作为键值对中的元素类型，以及如何设计键值对以适应特定需求的问题...
OCL.rar_andriod google map_google map_java google map_map_ocl
09-14
标题中的“OCL.rar_andriod google map_google map_java google map_map_ocl”似乎是一个包含多个技术元素的项目文件，其中“OCL”可能是指Objective-C++或Open Computing Language（OpenCL），而“andriod”是...
Java__Map集合.mp4
07-09
Java__Map集合.mp4
java的字典 就是map map的定义 取值 判断map是否为空
tenc1239的博客
07-02 467
【代码】java的字典 就是map map的定义 取值。
Java集合框架之双列Map集合简介
m0_48008264的博客
06-23 245
对于Map集合，它和Collection集合不同在于：Collection体系下的集合为单列集合，而Map体系下的集合为双列集合 Map集合：无序，由Key（键）和Value（值）组成 在Map集合中一个键对应一个值，并且键不能重复，但值可以重复出现 Map是一个接口，所以无法直接创建实例化对象，所以我们需要根据其子类来创建实例化对象 上图为Map中两个常用的子类 HashMap：散列的键值对，常用 TreeMap：树状键值队 通过上述两个子类我们就可以创建实例化对象了 //通过HashMap创建实例
python将java的map类型转为dict字典类型
m0_67266585的博客
04-07 1163
竟然直接就能转 dict(java_map) 提醒一下，字典内数据类型还是java的所以还要转一下
【Java基础14】双列集合Map
少安的博客
12-26 200
目录1. 双列集合2. 特点3. 双列集合体系4. 常用API5. 格式6. Map集合遍历6.1 键找值的方法6.2 迭代器方式6.3 Lambda表达式 1. 双列集合 双列集合也是用于存储数据的，但是与单列集合不同的是，双列集合是以key=value 的形式存在的。每个部分包含两部分key和value。 2. 特点 Map键是无序、不可重复和无索引的。 Map值是不做要求的。 Map存相同键的值，后者会覆盖前者 Map的键和值都可以是null 3. 双列集合体系 HashMap：键无序、不重复
commons之迭代器(Map、过滤、循环)_双向Map_包JAVA141
好好学习天天向上
12-13 2359
来源：http://www.bjsxt.com/ 1、S02E141_01commons之迭代器(Map、过滤、循环)、双向Map、包 a.迭代器(Map、去重、过滤、循环、数组)package com.test.commons;import java.util.ArrayList; import java.util.Iterator; import java.util.List;import
用map实现数据字典功能
weixin_33898233的博客
06-27 1571
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中 Hashmap转为Dictionary
weixin_42638570的博客
02-14 365
java hashmap怎么转Dictionary
Java基础 | 13.Map双列集合 - Map接口
xyx-Eshang的博客
04-01 729
文章目录参考视频1.双列集合概述1.1.整体总述1.2.双列集合选型2.双列集合遍历方法2.1.与遍历相关的Map接口简介2.2.以HashMap为例，实现三种遍历3.Map接口概述3.1.操作Map的抽象方法3.2.新增结点规则4.Map实现类概述**4.1.HashMap - 无序，效率高，线程不安全**4.2.LinkedHashMap - 存取同序4.3.TreeMap - 默认自然排序4.4.HashTable / ConcurrentHashMap - 无序，线程安全4.5.Properties
Java双列集合Map
qi341500的博客
11-25 518
一、Map 1、Map的常见API 2、map集合的三种遍历方式 3、HashMap 4、LinkedHashMap 5、TreeMap
ordered_map java
最新发布
09-06
在Java中，没有直接的ordered_map类。Java中有TreeMap类可以用来实现有序的映射，其底层是基于红黑树实现的。使用TreeMap可以实现有序的键值对存储，并且支持快速的插入、删除和查找操作。与之类似的是LinkedHashMap...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

极客李华

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

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

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

打赏作者

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

抵扣说明：

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

余额充值