Java之Map集合接口功能（介绍HashMap LinkedHashMap TreeMap Hashtable）以及Collections的使用 泛型之固定上下边界

最新推荐文章于 2021-06-17 17:50:18 发布
最新推荐文章于 2021-06-17 17:50:18 发布
阅读量175 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41910103/article/details/83352650
版权

set的底层其实是由Map实现的
只是值为Object 不显示而已
在这里插入图片描述
注意 各种底层算法（哈希算法，二叉树算法，链表算法 ）都只是针对map中的key！！
Map<k,v>以键值对的形式存在
Map接口一些常用的功能
1.添加功能Value put(K，V)
如果K相同则返回覆盖值V 如果没有为null
2.删除功能clear（）
还有Value remove(Key) 根据键删除值！ 返回键对应的值
3.判断功能
boolean containKey(key)
boolean containValue(Value)
boolean isEmpty()
4.获取功能
Collections< Values > .values（）//获取map中所有的值 并构成集合
set< key >. KeySet（）//获取map中所有的键 并构成集合
Map.entry<key,Value> . EntrySet( ) . //把Map中的键值对包装在一起 组成一个新集合！
也就是说看成一个新的对象 Map，Entry<key,Value>
5.长度功能
int size（）

Map集合不能直接迭代
第一种方法
1.先获取所有的键值集合set
2.迭代器遍历集合
or
fore循环

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

public class Demo2_Iterator {

	/**
	 * 通过查看Map集合的api发现没有iterator方法,那么双列集合如何迭代呢?
	 * 根据键获取值
	 */
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<>();
		map.put("张三", 23);
		map.put("李四", 24);
		map.put("王五", 25);
		map.put("赵六", 26);
		
//		Integer i = map.get("张三");					//根据键获取值
//		System.out.println(i);
		
		//获取所有的键
		/*Set<String> keySet = map.keySet();			//获取所有键的集合
		Iterator<String> it = keySet.iterator();	//获取迭代器
		while(it.hasNext()) {						//判断集合中是否有元素
			String key = it.next();					//获取每一个键
			Integer value = map.get(key);			//根据键获取值
			System.out.println(key + "=" + value);
		}*/
		
		//使用增强for循环遍历
		for(String key : map.keySet()) {			//map.keySet()是所有键的集合
			System.out.println(key + "=" + map.get(key));
		}
	}

}

第二种 迭代方法
把双列集合变成单列集合
.entrySet()
Map.Entry<key,Value> 其子类为 Entry<key,Value>
接口.接口这样的用法 说明Entry是Map的子接口

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class Demo3_Iterator {

	/**
	 * Map集合的第二种迭代,根据键值对对象,获取键和值
	 *  A:键值对对象找键和值思路：
		* 获取所有键值对对象的集合
		* 遍历键值对对象的集合，获取到每一个键值对对象
		* 根据键值对对象找键和值
	 */
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<>();
		map.put("张三", 23);
		map.put("李四", 24);
		map.put("王五", 25);
		map.put("赵六", 26);
		
		//Map.Entry说明Entry是Map的内部接口,将键和值封装成了Entry对象,并存储在Set集合中
		/*Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
		//获取每一个对象
		Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
		while(it.hasNext()) {
			//获取每一个Entry对象
			Map.Entry<String, Integer> en = it.next();	//父类引用指向子类对象
			//Entry<String, Integer> en = it.next();	//直接获取的是子类对象
			String key = en.getKey();					//根据键值对对象获取键
			Integer value = en.getValue();				//根据键值对对象获取值
			System.out.println(key + "=" + value);
		}*/
		
		for(Entry<String, Integer> en : map.entrySet()) {
			System.out.println(en.getKey() + "=" + en.getValue());
		}
	}

}

HashMap
自定义类要重写 equals 和hashcode方法

LinkedHashMap
怎么存就这么取

TreeMap
可以对键进行排序
自定义类的话（方法有两种）
法一：实现comparable接口并重写类中的compareTo
法二：加入比较器Comparator

小练习
判断每次字符出现的次数

import java.util.HashMap;

public class Main{
	public static void main(String[] args) {
		String s = "abbcccddddeeeeeeeeee";
		char[] arr = s.toCharArray();
		HashMap<Character,Integer> map =new HashMap<Character, Integer>();
		for (char c : arr) {
			map.put(c,map.containsKey(c) ? map.get(c)+1 : 1);
		}
		System.out.println(map);
	}
}

在这里插入图片描述

HashMap嵌套

import java.util.HashMap;

import com.heima.bean.Student;

public class Demo8_HashMapHashMap {

	/**
	 * * A:案例演示
	 * 集合嵌套之HashMap嵌套HashMap
	 * 
	 * 需求:
	 * 双元课堂有很多基础班
	 * 第88期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
	 * 第99期基础班定义成一个双列集合,键是学生对象,值是学生的归属地
	 * 
	 * 无论88期还是99期都是班级对象,所以为了便于统一管理,把这些班级对象添加到双元课堂集合中
	 */
	public static void main(String[] args) {
		//定义88期基础班
		HashMap<Student, String> hm88 = new HashMap<>();
		hm88.put(new Student("张三", 23), "北京");
		hm88.put(new Student("李四", 24), "北京");
		hm88.put(new Student("王五", 25), "上海");
		hm88.put(new Student("赵六", 26), "广州");
		
		//定义99期基础班
		HashMap<Student, String> hm99 = new HashMap<>();
		hm99.put(new Student("唐僧", 1023), "北京");
		hm99.put(new Student("孙悟空",1024), "北京");
		hm99.put(new Student("猪八戒",1025), "上海");
		hm99.put(new Student("沙和尚",1026), "广州");
		
		//定义双元课堂
		HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
		hm.put(hm88, "第88期基础班");
		hm.put(hm99, "第99期基础班");
		
		//遍历双列集合
		for(HashMap<Student, String> h : hm.keySet()) {		//hm.keySet()代表的是双列集合中键的集合
			String value = hm.get(h);						//get(h)根据键对象获取值对象
			//遍历键的双列集合对象
			for(Student key : h.keySet()) {					//h.keySet()获取集合总所有的学生键对象
				String value2 = h.get(key);
				
				System.out.println(key + "=" + value2 + "=" + value);
			}
		}
		
	}

}

Hashtable
线程安全 效率低 命运和Vector一样被替代了

Collections 工具类的使用
只针对于list
Collecitons中的常见方法
public static < T > void sort(List< T > list)
public static < T > int binarySearch(List<?> list,T key)
public static < T > T max(Collection<?> coll)
public static void reverse(List<?> list)
public static void shuffle(List<?> list)

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

public class Demo1_Collecitons {

	/**
	 * 	Collecitons中的常见方法
	 * 	public static <T> void sort(List<T> list)
		public static <T> int binarySearch(List<?> list,T key)
		public static <T> T max(Collection<?> coll)
		public static void reverse(List<?> list)
		public static void shuffle(List<?> list)
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("c");
		list.add("d");
		list.add("g");
		list.add("f");
		//System.out.println(Collections.max(list)); 			//根据默认排序结果获取集合中的最大值
		//Collections.reverse(list);							//反转集合
		Collections.shuffle(list);								//随机置换,可以用来洗牌
		System.out.println(list);
	}

	public static void demo2() {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("c");
		list.add("d");
		list.add("f");
		list.add("g");
		
		System.out.println(Collections.binarySearch(list, "c"));
		System.out.println(Collections.binarySearch(list, "b"));  //返回-2 为 ：-插入值-1
	}

	public static void demo1() {
		ArrayList<String> list = new ArrayList<>();
		list.add("c");
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("d");
		
		System.out.println(list);
		Collections.sort(list);						//将集合排序
		System.out.println(list);
	}

}

最后小练习
模拟斗地主
1.存牌
ArrayList< Integer > list 存索引
HashMap<Integer,String> hm存 索引值和牌的内容
2.洗牌 洗索引
Collections.shuffle(list);
3.发牌 发索引
TreeSet< Integer > player1 = new TreeSet<>(); //拥有自动排序的功能
4.看牌 通过索引找到牌的内容并打印

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Main{
	public static void main(String[] args) {
		//1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
		String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
		String[] color = {"方片","梅花","红桃","黑桃"};
		ArrayList<Integer> list = new ArrayList<>();
		HashMap<Integer,String> hm = new HashMap<>();
		int index = 0;
		
		//拼接扑克牌并索引和扑克牌存储在hm中
		for(String s1 : num) {											//获取数字
			for(String s2 : color) {									//获取颜色
				hm.put(index, s2.concat(s1));
				list.add(index);										//将索引0到51添加到list集合中
				index++;
			}
		}
		hm.put(index, "小王");
		list.add(index);	
		index++;
		hm.put(index, "大王");
		list.add(index);	
//		2.洗牌
		Collections.shuffle(list);
		
//		3.发牌   添加的仅仅只是索引
		TreeSet<Integer> player1 = new TreeSet<>();
		TreeSet<Integer> player2 = new TreeSet<>();
		TreeSet<Integer> me = new TreeSet<>();
		TreeSet<Integer> dipai = new TreeSet<>();
		
		for(int i = 0; i < list.size(); i++) {
			if(i >= list.size() - 3) {
				dipai.add(list.get(i));							//将三张底牌存储在底牌集合中
			}else if(i % 3 == 0) {
				player1.add(list.get(i));
			}else if(i % 3 == 1) {
				player2.add(list.get(i));
			}else {
				me.add(list.get(i));
			}
		}
//		4.看牌
		lookPoker(hm,player1,"熊海涛");
		lookPoker(hm,player2,"武晓慧");
		lookPoker(hm,me,"杨瑞卿");
		lookPoker(hm,dipai,"底牌");
		
		
	}
	public static void lookPoker(HashMap<Integer,String> hm,TreeSet<Integer> player,String name)
	{
		System.out.print(name+"的牌是:");
		for(Integer i : player) {
			System.out.print(hm.get(i)+" ");
		}
		System.out.println();
	}
}

所以最后的牌是按照顺序打印的
在这里插入图片描述

泛型固定上边界
? extends E
用于addAll（Collection c）
表示向父类集合可以添加子类集合

泛型固定下边界
? super E
用于TreeSet 或TreeMap 中的比较器方法中
表示父类的比较器 子类也能用

演示代码

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

import com.heima.bean.BaseStudent;
import com.heima.bean.Student;

public class Demo2_Genric {

	/**
	 * 泛型固定下边界
	 * ? super E  
	 * 
	 * 泛型固定上边界
	 * ? extends E
	 */
	public static void main(String[] args) {
		//demo1();
		TreeSet<Student> ts1 = new TreeSet<>(new CompareByAge());
		ts1.add(new Student("张三", 33));
		ts1.add(new Student("李四", 13));
		ts1.add(new Student("王五", 23));
		ts1.add(new Student("赵六", 43));
		
		TreeSet<BaseStudent> ts2 = new TreeSet<>(new CompareByAge());
		ts2.add(new BaseStudent("张三", 33));
		ts2.add(new BaseStudent("李四", 13));
		ts2.add(new BaseStudent("王五", 23));
		ts2.add(new BaseStudent("赵六", 43));
		
		System.out.println(ts2);
	}

	public static void demo1() {
		ArrayList<Student> list1 = new ArrayList<>();
		list1.add(new Student("张三", 23));
		list1.add(new Student("李四", 24));
		
		ArrayList<BaseStudent> list2 = new ArrayList<>();
		list2.add(new BaseStudent("王五", 25));
		list2.add(new BaseStudent("赵六", 26));
		
		list1.addAll(list2);
	}

}

class CompareByAge implements Comparator<Student> {

	@Override
	public int compare(Student s1, Student s2) {
		int num = s1.getAge() - s2.getAge();
		return num == 0 ? s1.getName().compareTo(s2.getName()) :  num;
	}
	
}
黑瞳丶
关注
专栏目录
小王Java学习打卡day13——泛型，hashMap，LinkedHashMap，TreeMap
w1099938370的博客
05-20 335
泛型 ​ 为什么使用泛型 存在一些问题： 取集合元素的时候，取出来的是Object类型，需要使用的时候只能强转 添加元素的时候，缺乏规范，导致类型转换异常 设计原则：不要写重复的代码 泛型： 一种数据的约束 jdk 1.5之后出来的，提供编译时期的安全检查机制，给我们提供了自动的强制类型转换，安全 如何使用泛型？ 常见字母 T ——type K V —— key value E —— Element 使用 使用在类上 //一个类使用一个泛型 public c
集合(二)之Collection的接口List,Set,Iterator,Map,以及泛型的掌握
m0_52540692的博客
05-27 115
文章目录引入一、Java集合二、Collection接口方法三、Iterator迭代器接口四、Collection子接口一：ListList接口的常用方法List的遍历（三种方式）ArrayList源码分析：五、Collection子接口二：Set1、Set的理解1.1、无序性1.2、不可重复性1.3、向set中添加元素的过程2、treeSet六、Map接口1、Map接口的框架结构2、key-value的理解3、HashMap的底层实现原理4、Map接口中常用方法5、Map的遍历七、Collection工具
关于springCloud组件feign调用微服务数据格式转换为linkedHashMap
weixin_44842084的博客
06-17 1476
SpringCloud版本：Hoxton.SR11 SpringBoot版本：2.3.10.RELEASE 原来的feign调用接口 @FeignClient(name = "microservice-user") public interface UserFeignClient { @RequestMapping(value = "/user/user", method = RequestMethod.GET) public List finsdById(); } 调用地方的使用： pu
NO.94 RestTemplate.getForObject将PO中List<T>的泛型变成LinkedHashMap问题的解决
AmosRyan--整体的局部还是整体，宇宙之外还是宇宙
01-04 2万+
我们有个PO，长这样： public class MyPO implements java.io.Serializable{ private List data = new ArrayList(); ｝ 结果用RestTemplate.getForObject 后，不管这个T是什么，接收到都被转化为LinkedHashMap，造成ClassCastException。
Feign服务调用出现LinkedHashMap can not be cast to xxx
流星007
09-30 2744
LinkedHashMap can not be cast to xxx feign底层基于http协议，而现在非常流行restful风格，并且现在大部分都采用json的数据格式进行交互，所以这里就会有一个问题，那就是格式问题。 先看看我的返回数据结构： 被调用方： 调用方： 一跑，报错了 这就蛋疼了，数据明显都是一致的，为什么会出现这种问题呢？进入断点...
RestTemplate Hashmap变为LinkedHashMap源码解读
weixin_30745641的博客
06-19 288
使用restTemplate远程调用服务，正常应该接收List<HashMap>数据，但实际却是List<LikedHashMap>经过不断地debug，终于找到了数据被转换成LinkedHashMap的方法，下面我将这个可恶的方法贴出来并解读(解决方式在另一篇https://www.cnblogs.com/gqymy/p/11047327.html) 包 com....
map集合的特点以及遍历方式，泛型,工具类的介绍
07-01
5. **多种实现**：Java提供多种Map的实现，包括HashMap、TreeMap、LinkedHashMap、Hashtable等，每种实现都有其特定的性能和使用场景。 **二、Map集合的遍历方式** 1. **键集遍历**：通过`keySet()`方法获取所有键...
泛型-Collections工具类-Map双列集合复习
qq_40245464的博客
11-17 279
泛型 泛型的概述 广泛的类型，在定义一个类的时候，类型有些方法参数，返回值类型不确定时，就使用一个符号，表示这些尚未确定的类型，就称为泛型。 泛型的好处 提高了数据的安全性，将运行时的问题提前暴露在了编译阶段。 避免了强转的麻烦 泛型 泛型类 泛型方法 泛型接口 说明 类名后面跟着的泛型类型，是泛型的声明，一旦泛型声明出来，就相当于成为了已知类型，这个类型在整个类中都可以使...
Java笔记（15）泛型与Map集合
weixin_42621024的博客
07-23 522
Java笔记（15）泛型和Map集合 1.泛型
HashMap,LinkedHashMap,TreeMap的区别
03-29 1049
　　Map主要用于存储健值对，根据键得到值，因此不允许键重复（重复了覆盖了），但允许值重复。 HashMap 　　HashMap 是一个最常用的Map，它根据键的HashCode 值存储数据，根据键可以直接获取它的值，具有很快的访问速度。遍历时，取得数据的顺序是完全随机的。 　　HashMap最多只允许一条记录的键为Null；允许多条记录的值为 Null。 　　HashMap不支持线程的同...
RestTemplate请求http接口示例
IT_10的博客
01-11 514
SpringMVC提供 RestTemplate请求http接口，RestTemplate的底层可以使用第三方的http客户端工具实现http 的请求，常用的http客户端工具有Apache HttpClient、OkHttpClient等。 这里以OkHttpClient为例讲解RestTemplate的用法 1.添加依赖 <dependency> <groupId>c...
JSON 泛型序列化方法 与 LinkedHashMap转成对象
STRANGE-P 的博客
06-03 6676
JSON 泛型序列化方法 与 LinkedHashMap转成对象1、说明1、JSON 泛型序列化方法2.1 JSON 源码2.2 示例2.3 忽略反转义报错3、LinkedHashMap 转成对象 convertValue() 方法 1、说明   本文均基于 com.alibaba.fastjson.jar 包，所以首先引入jar   <dependency> <groupId>com.alibaba</groupId> <art
fegin调用的时候数据格式转换为linkedhashmap
suiyueran8023的博客
07-13 7213
在spring cloud项目开发中，使用fegin进行远程调用 1、接口服务方返回类型为Map(String,Object)类型 2、接口调用方返回值类型也是Map(String,Object) : 3、通过fegin调用之后返回的结果为linkedHashMap类型！！！非常奇怪： 并显示报错类型为如下： java.lang.ClassCastException: java.util.Link...
spring cloud 复杂类型 FeignClient 避免linkedHashMap
ahty的专栏
07-10 3464
项目使用spring cloud后，各种服务被独立开，功能被分开。因此，会开发中我们往往会遇到一些问题，服务间的互相调用需要更为复杂的方式。 调用方式主要有两种 一种是http请求方式，结合常说的restful风格，来传递信息，基于tcp的短暂通讯方式（伪RPC）。 另一种就是基于socket的长连接，底层同样基于tcp的RPC方式调用。 这两种方式，可能RPC效率更高，因为他...
彻底搞懂了 泛型上下边界！跟普通泛型比，抽象层级都不同！
chaletan的博客
05-31 2939
<? extends T>和<? super T>是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念。 <? extends T>：是指“上界通配符（Upper Bounds Wildcards）” <? super T>：是指“下界通配符（Lower Bounds Wildcards） 泛型可以是看成容器里元...
Error：com.google.gson.internal.LinkedTreeMap cannot be cast to ***
liuzhen007的专栏
04-28 2344
数据转换错误，类似的错误还有LinkedHashMap，这个时候，我们应该将子类向父类或接口转换，因为LinkedTreeMap和LinkedHashMap都实现了Map。转换代码： Map<String, Object> infoMap = (Map<String, Object>) linkTreeMap; Map<String, Object> in...
如何将linkedHashMap转化为实体对象
热门推荐
m0_37708405的博客
08-26 2万+
import lombok.Data; import java.util.List; @Data public class ProfitPage&lt;T&gt; { private int pageSize ; //页码 private int total; //总条数 private Integer size; //当前页 private int pag...
Java HashMap, LinkedHashMap, TreeMap与HashTable比较详解
在Java编程中，`HashMap`, `LinkedHashMap`, `TreeMap`, 和 `HashTable` 都是实现 `java.util.Map` 接口的容器类，用于存储键值对。它们各自有独特的特性和适用场景。 1. **HashMap**: - HashMap 是基于哈希表实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

黑瞳丶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值