Java---Map双列集合

news2025/2/25 2:56:08

目录

一、双列集合的介绍

二、Map的使用

1：Map中常见的API

（1）put方法

（2）remove方法

2：Map的遍历

（1）通过键找值的方式遍历

 （2）通过键值对对象遍历

 （3）Lambda表达式遍历

 三、双列集合的使用

1：HashMap

 2：LinkedHashMap

3：TreeMap

（1）Comparable接口排序

 （2）Comparator比较器排序

一、双列集合的介绍

不同于单列集合，双列集合顾名思义是有两个元素的，说是元素，又有点不大准确。就有有一对键值对，就是有一个标志的值和这个标志的值所对应的值。也就是在算法中我们常说的标志数组吧。它和单列集合一样都是储存数据的容器

HashMap：无序，不重复，无索引

LinkedHashMap：有序，不重复，无索引

TreeMap：

综上所述Map是不重复的，但是这里的不重复是键不能重复，但是值是可以重复的。

二、Map的使用

1：Map中常见的API

V put(k key,V value)                 添加元素
V remove(Object key)                 根据键删除所对应的元素
void clear()                         清空所有的键值对元素
boolean containsKey(Object key)      判断集合是否包含指定的键
boolean containsValue(Object value)  判断集合是否包含指定的值
boolean isEmpty()                    判断集合是否为空
int size()                           集合的长度也就是集合中的键值对个数

这里对于一些细节的方法我会详细说说，其他没说的方法就按照类型操作即可。

（1）put方法

对于put方法的返回值，如果添加的数据的键再Map容器中以及存在了，那么新添加的数据就会覆盖，而返回值就是被覆盖的键所对应的值。如果并没有覆盖，返回值就是null。

package article;

import java.util.Arrays;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
        Map<String,String> s=new HashMap<>();
        
        String v1=s.put("jkjk", "123");
        System.out.println(v1);
        s.put("opo", "234");
        s.put("yyyy", "");
        String v2=s.put("opo", "[[[[");
        
        System.out.println(v2);
        System.out.println(s);
    }
}

 

（2）remove方法

remove方法删除，其中接受的参数是你想要删除的所对应的键，同时它也会有返回值，返回值就是你所删除的对应的值。

package article;

import java.util.Arrays;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
        Map<String,String> s=new HashMap<>();
        
        String v1=s.put("jkjk", "123");
        s.put("opo", "234");
        s.put("yyyy", "");
        String v2=s.put("opo", "[[[[");
        System.out.println(s);
        String v3=s.remove("opo");
        System.out.println(v3);
        System.out.println(s);
    }
}

2：Map的遍历

（1）通过键找值的方式遍历

package article;

import java.util.Arrays;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
        Map<String,String> s=new HashMap<>();
        
        String v1=s.put("jkjk", "123");
        s.put("opo", "234");
        s.put("yyyy", "");
        String v2=s.put("opo", "[[[[");
        System.out.println(s);
        Set<String> ss=s.keySet();//获取到键并放入ss集合
        for(String k:ss) {
        	String value=s.get(k);//通过键获取值
        	System.out.println("键="+k+"，值="+value);
        }
    }
}

 （2）通过键值对对象遍历

这种遍历方式是将键值对当做一个整体进行遍历，每次获取每个键值对对象中的键和值。

package article;

import java.util.Arrays;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
        Map<String,String> s=new HashMap<>();
        
        String v1=s.put("jkjk", "123");
        s.put("opo", "234");
        s.put("yyyy", "");
        String v2=s.put("opo", "[[[[");
        Set<Map.Entry<String,String> > ss=s.entrySet();//获取键值对对象，并将其放入集合中
        
        for(Map.Entry<String, String> oo:ss) {
        	String key=oo.getKey();//获取键值对对象中的键
        	String value=oo.getValue();//获取键值对对象中的值
        	System.out.println("键="+key+" 值="+value);
        }
    }
}

 （3）Lambda表达式遍历

package article;

import java.util.Arrays;
import java.util.function.BiConsumer;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
        Map<String,String> s=new HashMap<>();
        
        String v1=s.put("jkjk", "123");
        s.put("opo", "234");
        s.put("yyyy", "");
        String v2=s.put("opo", "[[[[");
        
        s.forEach(new BiConsumer<String,String>(){

			@Override
			public void accept(String key, String value) {
				// TODO 自动生成的方法存根
				System.out.println("键="+key+" 值="+value);
			}
        	
        });
        System.out.println("Lamda表达式再简化");
        
        s.forEach((String t, String u)-> {
				// TODO 自动生成的方法存根
				System.out.println("键="+t+" 值="+u);
			}
        );
    }
}

 三、双列集合的使用

1：HashMap

HashMap也HashSet一样，都是基于哈希表的结构，特点都是无序，不重复，无索引。

并且以来HashCode方法和equals方法保证键的唯一。如果键存储的是自定义对象，需要重写HashCode和equals方法，如果是值存储自定义对象，则不需要重写HashCode和equals方法。

具体我们可以举两个例子感受下

（1）定义一个学生对象，键存学生对象，值存储籍贯，姓名和年龄相同视为同一学生

package article;

import java.util.Objects;

public class student {
   String name;
   int age;
   public student(String name,int age) {
	   this.age=age;
	   this.name=name;
   }
   public void setname(String name) {
	   this.name=name;
   }
   public void setage(int age) {
	   this.age=age;
   }
   public String getname() {
	   return name;
   }
   public int getage() {
	   return age;
   }
@Override
public int hashCode() {
	return Objects.hash(age, name);
}
@Override
public boolean equals(Object obj) {
	if (this == obj)
		return true;
	if (obj == null)
		return false;
	if (getClass() != obj.getClass())
		return false;
	student other = (student) obj;
	return age == other.age && Objects.equals(name, other.name);
}
   
}

package article;

import java.util.Arrays;
import java.util.function.BiConsumer;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
        Map<student,String> s=new HashMap<>();
        student s1=new student("张三",10);
        student s2=new student("王五",20);
        student s3=new student("赵烈",30);
        student s4=new student("王五",20);
        
        s.put(s1,"安徽");
        s.put(s2, "江苏");
        s.put(s3, "浙江");
        s.put(s4, "天津");
        
        Set<Map.Entry<student,String>> ss=s.entrySet();
        for(Map.Entry<student, String> gg:ss) {
        	student key=gg.getKey();
        	String  value=gg.getValue();
        	System.out.println("键中的名字="+key.getname()+"键中的年龄="+key.getage()+"  值中的籍贯="+value);
        }
    }
}

（2）ABCD四个景点，现在有80人，每个人只能去其中一个景点，统计每个景点去的人数，并输出去的人数最多的景点。

 

package article;

import java.util.Arrays;
import java.util.function.BiConsumer;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
       //80人去的景点，我们用随机数来搞
    	Random r=new Random();
    	String[] a= {"A","B","C","D"};
    	ArrayList<String> s=new ArrayList<>();//存储的是80每个人去的景点
    	for(int i=0;i<80;i++) {
    		int index=r.nextInt(4);
    		s.add(a[index]);
    	}
    	//现在每个人去的景点已经添加到s链表中
    	Map<String,Integer> h=new HashMap<>();
    	for(String place:s) {
    		if(h.containsKey(place)) {
    			//地方已经存在
    			int count=h.get(place);
    			count++;
    			h.put(place, count);
    		}
    		else {
    			//第一个人去
    			h.put(place,1);
    		}
    	}
    	
    	int ma=0;
    	//遍历输出
    	Set<Map.Entry<String,Integer>> gg=h.entrySet();
    	for(Map.Entry<String, Integer> oo:gg) {
    		String key=oo.getKey();
    		int value=oo.getValue();
    		if(ma<value) {
    			ma=value;
    		}
    		System.out.println("去"+key+"的人数="+value);
    	}
    	
    	//求最大人数
    	System.out.println("最大人数="+ma);
   }
}

 2：LinkedHashMap

LinkedHashMap特点：有序，不重复，无索引。

注意不重复是键不可重复，值是可以重复的。同时它的底层实现结构是哈希表和双向链表。

package article;

import java.util.Arrays;
import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
       Map<String,Integer> s=new LinkedHashMap<>();
       s.put("909", 100);
       s.put("sd", 1);
       s.put(">>>>", 100);
       
       Set<Map.Entry<String, Integer>> ss=s.entrySet();
       
       for(Entry<String, Integer> oo:ss) {
    	   String key=oo.getKey();
    	   int value=oo.getValue();
    	   System.out.println("键="+key+" 值="+value);
       }
   }
}

 

3：TreeMap

TreeMap的特点：可排序，不重复，无索引。默认按照键的从小到大进行排序，也可按照自己定义的规则进行排序。对于它的排序与TreeSet也是一样的，有两种方法进行排序。一种是使用比较器进行排序，一种是使用Comparable接口进行排序。

（1）Comparable接口排序

 这里的this表示当前添加进去的，o表示的是已经存在的。我这里是先按照年龄从小到大，年龄一样按照名字从小到大排序。大家不理解就记住this在前表示是升序（从小到大）

package article;

import java.util.Objects;

public class student implements Comparable<student>{
   String name;
   int age;
   public student(String name,int age) {
	   this.age=age;
	   this.name=name;
   }
   public void setname(String name) {
	   this.name=name;
   }
   public void setage(int age) {
	   this.age=age;
   }
   public String getname() {
	   return name;
   }
   public int getage() {
	   return age;
   }
@Override
public int compareTo(student o) {
	// TODO 自动生成的方法存根
	int t=this.age-o.age;
	if(t==0) {
		return this.name.compareTo(o.name);
	}
	return t;
}

   
}
package article;

import java.util.Arrays;
import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
       Map<student,String> s=new TreeMap<>();
       student s1=new student("abc",19);
       student s2=new student("bnc",19);
       student s3=new student("acc",19);
       student s4=new student("adddd",19);
       student s5=new student("nzbs",20);
       student s6=new student("qqss",3);
       student s7=new student("poojs",30);
       
       s.put(s1,"安徽");
       s.put(s2, "安徽");
       s.put(s3, "天津");
       s.put(s4, "浙江");
       s.put(s5, "安徽");
       s.put(s6, "天津");
       s.put(s7, "浙江");
       
       Set<Map.Entry<student, String>> ss=s.entrySet();
       for(Map.Entry<student, String> oo:ss) {
    	   student key=oo.getKey();
    	   String value=oo.getValue();
    	   System.out.println("键中名字="+key.getname()+" 键中年龄="+key.getage()+" 值="+value);
       }
   }
}

 （2）Comparator比较器排序

这里我将排序规则修改了下，按照年龄从大到小排序，如果年龄相同，则按照名字从大到小进行排序。这里大家不理解，就可以这样理解o1在前就是升序，o2在前就是降序。（嗯，死记硬背吧，哈哈哈）

package article;

import java.util.Arrays;
import java.util.Map.Entry;
import java.util.function.BiConsumer;
import java.lang.reflect.Array;
import java.util.*;

public class so {
    public static void main(String[] args) {
       Map<student,String> s=new TreeMap<>(new Comparator<student>() {

		@Override
		public int compare(student o1, student o2) {
			// TODO 自动生成的方法存根
			int t=o2.age-o1.age;
			if(t==0) {
				return o2.name.compareTo(o1.name);
			}
			
			return t;
		}
    	   
       });
       student s1=new student("abc",19);
       student s2=new student("bnc",19);
       student s3=new student("acc",19);
       student s4=new student("adddd",19);
       student s5=new student("nzbs",20);
       student s6=new student("qqss",3);
       student s7=new student("poojs",30);
       
       s.put(s1,"安徽");
       s.put(s2, "安徽");
       s.put(s3, "天津");
       s.put(s4, "浙江");
       s.put(s5, "安徽");
       s.put(s6, "天津");
       s.put(s7, "浙江");
       
       Set<Map.Entry<student, String>> ss=s.entrySet();
       for(Map.Entry<student, String> oo:ss) {
    	   student key=oo.getKey();
    	   String value=oo.getValue();
    	   System.out.println("键中名字="+key.getname()+" 键中年龄="+key.getage()+" 值="+value);
       }
   }
}

提醒大家，排序排序，这里的排序都是按照键来排序，千万不要扯到值上了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/10174.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FRNet代码

FRNet代码

代码目录简简单单&#xff0c;令人心旷神怡。 模型框架&#xff1a; 数据增强包括; 接着看一下数据集&#xff1a; import os from PIL import Image import numpy as np from sklearn.model_selection import train_test_splitimport torch import torch.utils.data as da…
阅读更多...
Tomcat+Maven+Servlet安装与部署

Tomcat+Maven+Servlet安装与部署

文章目录前言一、Tomcat8下载安装二、MavenServlet部署1.创键Maven项目&#xff08;idea2021community&#xff09;2.pom.xml下引入servlet依赖3.main下创建webapp/WEB-INF/web.xml4.验证HttpServlet是否导入&#xff08;配置WebServlet路径&#xff09;5.手动打包web项目6.浏览…
阅读更多...
DAMA-CDGA/CDGP数据治理认证包括哪几个方面？

DAMA-CDGA/CDGP数据治理认证包括哪几个方面？

DAMA认证为数据管理专业人士提供职业目标晋升规划&#xff0c;彰显了职业发展里程碑及发展阶梯定义&#xff0c;帮助数据管理从业人士获得企业数字化转型战略下的必备职业能力&#xff0c;促进开展工作实践应用及实际问题解决&#xff0c;形成企业所需的新数字经济下的核心职业…
阅读更多...
【夯实Kafka知识体系及基本功】分析一下消费者（Consumer）实现原理分析「原理篇」

【夯实Kafka知识体系及基本功】分析一下消费者（Consumer）实现原理分析「原理篇」

Consumer消费者 消费者可以从broker中读取数据。 一个消费者可以消费多个topic中的数据&#xff08;其中一个partion&#xff09;。 Consumer Group&#xff08;消费组&#xff09; 每个Consumer属于一个特定的Consumer Group。 可为每个Consumer指定group name&#xff0c…
阅读更多...
自动驾驶--定位技术

自动驾驶--定位技术

[整理自百度技术培训中心课程](https://bit.baidu.com/products?id70) 为什么无人车需要精确的定位系统 在地下车库实现自动泊车的一个非常关键的技术是什么呢&#xff1f;那就是定位技术。 为什么无人车需要一个精确的定位系统。为什么无人车需要精确的定位系统&#xff…
阅读更多...
网络线缆连接器和线槽

网络线缆连接器和线槽

一、信息插座 1、信息插座简介 信息插座是终端（工作站）与水平干线子系统连接的接口，在水平干线子系统中双绞线的两 端是直接压接到配线架和信息插座中的，不需要跳线。 2、信息插座的配置 综合布线系统的设计，应该根据实际情况确定 所需信息插座个数和分布位置，也就决…
阅读更多...
计算机的另一半

计算机的另一半

本篇先介绍了计算机中数字编码&#xff0c;地址的概念。然后介绍了组成计算机的另外一半内容&#xff0c;也就是CPU&#xff0c;和前面的计算机一半合起来就可以组成一个简易版的计算机了。至此终于大概看到了计算机的全貌。 数字编码系统 这里我们简单说一下计算机里数字编码…
阅读更多...
智慧环卫解决方案-最新全套文件

智慧环卫解决方案-最新全套文件

智慧环卫解决方案-最新全套文件一、建设背景二、思路架构三、建设方案四、获取 - 智慧环卫全套最新解决方案合集一、建设背景 城市环境卫生管理是一项复杂而系统的社会工程&#xff0c;是与人民群众生活联系最密切的重要工作之一。环卫水平不仅是一个城市的“脸面”&#xff0…
阅读更多...
kotlin 之单例类详解

kotlin 之单例类详解

object 单例对象的声明&#xff1a; object Model{var temp "1"val temp2 "2"const val temp3 "3" }抛出疑问&#xff1a;使用object修饰的类&#xff0c;是哪种类型的单例模式 这里我们先回顾一下java六种单例模式 1. 饿汉式 public c…
阅读更多...
String、StringBuffer和StringBuilder类的区别

String、StringBuffer和StringBuilder类的区别

在 Java 中字符串属于对象&#xff0c;Java 提供了 String 类来创建和操作字符串。String 类是不可变类&#xff0c;即一旦一个 String 对象被创建以后&#xff0c;包含在这个对象中的字符序列是不可改变的&#xff0c;直至这个对象被销毁。 Java 提供了两个可变字符串类 Stri…
阅读更多...
EFLFK——ELK日志分析系统+kafka+filebeat架构（3）

EFLFK——ELK日志分析系统+kafka+filebeat架构（3）

ELFK——ELK结合filebeat日志分析系统&#xff08;2&#xff09;_Evens7xxX的博客-CSDN博客 紧接上期&#xff0c;在ELFK的基础上&#xff0c;添加kafka做数据缓冲 附kafka消息队列 nginx服务器配置filebeat收集日志&#xff1a;192.168.116.40&#xff0c;修改配置将采集到的…
阅读更多...
SoC-ZCU106求解非线性方程（一）：环境安装

SoC-ZCU106求解非线性方程（一）：环境安装

一、大家好久不见&#xff0c;本次给大家带来的是SoC求解非线性方程问题。计划发布三篇文章&#xff0c;这是第一篇----环境安装。 主要的解决的问题是&#xff1a;PL侧给PS传输数据&#xff0c;然后PS将数据作为已知量求解非线性方程&#xff0c;为了简化问题复杂度&#xff…
阅读更多...
中睿天下实力入选2022信创产业独角兽TOP100

中睿天下实力入选2022信创产业独角兽TOP100

近日&#xff0c;中国科学院主管的权威媒体《互联网周刊》、德本咨询、eNet研究院联合发布了“2022信创产业独角兽100强”榜单。中睿天下凭借在网络安全攻击溯源领域的深耕、硬的技术能力和突出的产品创新力&#xff0c;实力入选榜单&#xff0c;在上榜的安全企业中&#xff0c…
阅读更多...
Docker（四）—— 部署Nginx、Tomcat

Docker（四）—— 部署Nginx、Tomcat

一、部署Nginx 将Nginx后台挂载后&#xff0c;用curl命令访问&#xff0c;进行本机自测&#xff1a; 二、部署Tomcat 出现404页面的原因&#xff1a;为了缩小镜像的大小&#xff0c;官方下载的Tomcat镜像是精简版的&#xff0c;只提供了必要、核心的内容。我们进入容器内部的/w…
阅读更多...
You辉编程_kafka

You辉编程_kafka

一、什么是kafka? 是分布式(项目部署于多个服务器)的基于发布/订阅模式的消息队列&#xff0c;主要用于处理活跃的数据&#xff0c;如&#xff1a;登录、浏览、点击、分享等用户行为产生的数据&#xff0c;说白了就是一个消息系统&#xff08;消息队列&#xff09;。 进一步…
阅读更多...
java项目-第132期ssm学生会管理系统-ssm+shiro+activity社团毕业设计

java项目-第132期ssm学生会管理系统-ssm+shiro+activity社团毕业设计

java项目-第132期ssm学生会管理系统-ssmshiroactivity社团毕业设计 【源码请到资源专栏下载】 今天分享的项目是《学生会管理系统》 该项目分为不同的角色&#xff0c;其中包含超级管理员、生活文体部部长、行政秘书部部长、 外联部部长、策划部部长、学生会干事等角色&#xf…
阅读更多...
[附源码]java毕业设计基于的网上饮品店

[附源码]java毕业设计基于的网上饮品店

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
FITC标记葡聚糖(40kDa)，FITC Dextran-40，CAS号：60842-46-8

FITC标记葡聚糖(40kDa)，FITC Dextran-40，CAS号：60842-46-8

中文名称&#xff1a;FITC标记葡聚糖(40kDa) 英文名称&#xff1a;FITC Dextran-40 CAS号&#xff1a;60842-46-8 产品规格&#xff1a;50mg|250mg|1g 本制品是对平均分子量约40kDa葡聚糖进行标记的荧光素衍生物&#xff0c;即异硫氰酸荧光素葡聚糖40&#xff08;fluoresce…
阅读更多...
QT编译Opencv库过程中出现的问题总结

QT编译Opencv库过程中出现的问题总结

一、人脸识别模块编译出错 出错原因&#xff1a;没有加入opencv_contrib OpenCV 4.4开始需要提供opencv_contrib 如果不需要人脸识别模块可以进行下列操作 [ 77%] Linking CXX executable ..\..\bin\opencv_test_dnn.exe jom: E:\1WT\18.OCR\opencv\build-sources-Desktop_…
阅读更多...
计算机网络 3 - 传输层

计算机网络 3 - 传输层

第3章 传输层(Transport Layer)3.1 传输层服务与协议3.2 复用 分用无连接的分用、复用(UDP)面向连接的分用、复用(TCP)持续/非持续HTTP连接 与 常见端口3.3 无连接传输: UDP3.4 可靠数据传输原理(rdt)rdt 1.0&#xff1a;经完全可靠信道的可靠数据传输rdt 2.0&#xff1a;发现并…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023