Java学习日志（16-1-Map集合）

最新推荐文章于 2023-12-01 16:29:21 发布
最新推荐文章于 2023-12-01 16:29:21 发布
阅读量277 收藏 2
点赞数
文章标签： java 数据结构与算法
原文链接：https://my.oschina.net/Almon/blog/740065
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

Map集合（双列集合）

添加 
put(K key,V value)
putAll(Map<?extends K,? extends V>m)
移除 
clear()
remove(Object key)
判断 
containsKey(Object key)
containsValue(Object value)
isEmpty()
获取
get(Object key)
size()
values()
entrySet()**
keySet()**

    该集合存储键值对，一对一对存，而且要保证键的唯一性

三个子类集合

Map
    |--Hashtable:底层是哈希表数据结构，不能存入null键null值，线程同步，效率低
    |--HashMap:底层是哈希表数据结构，可使用null键和null值，该集合不同步，效率高
    |--TreeMap:底层是二叉树数据结构，可以给Map中的键排序，线程不同步

**Set集合底层使用了Map集合

操作练习

import java.util.*;
class MapDemo{
	public static void main(String[] args){
		Map<String,String>map=new HashMap<String,String>();
		map.put("01","zhangsan1");
		//相同键存入不同值时，后添加的值会覆盖原有的值，并返回被覆盖的值
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		System.out.println("containsKey:"+map.containsKey("02"));
		// System.out.println("remove:"+map.remove("02"));
		System.out.println("get:"+map.get("02"));
		//可以通过get()的返回值来判断一个键是否存在
		Collection<String>coll=map.values();
		System.out.println(coll);
		System.out.println(map);
	}
}

    map集合的两种取出方式:将map集合转为Set集合，再迭代

        Set<k> keySet():将Map所有的键存入到Set集合

            利用Set迭代，取出所有的键，在用get取出值

import java.util.*;
class MapDemo2{
	public static void main(String[] args){
		Map<String,String>map=new HashMap<String,String>();
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("04","zhangsan4");
		// 获取map中所有键的Set集合
		Set<String>keySet=map.keySet();
		// 获取迭代器
		Iterator<String>it=keySet.iterator();
		while(it.hasNext()){
			String key=it.next();
			// 有了键可以通过map集合的get()获取其对应的值
			String value=map.get(key);
			System.out.println("Key:"+key+",value:"+value);
		}
	}
}

        Set<Map.Entry<k,v>> entrySet():将Map集合中的映射关系存入Set集合

                 而其关系类型为Map.Entry

import java.util.*;
class MapDemo2{
	public static void main(String[] args){
		Map<String,String>map=new HashMap<String,String>();
		map.put("01","zhangsan1");
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("04","zhangsan4");
		// 将Map集合中映射关系取出，存入Set集合
		Set<Map.Entry<String,String>>entrySet=map.entrySet();
		Iterator<Map.Entry<String,String>> it=entrySet.iterator();
		while(it.hasNext()){
			Map.Entry<String,String>me=it.next();
			String key=me.getKey();
			String value=me.getValue();
			System.out.println("Key:"+key+",value:"+value);
		}
	}
}

        **Map.Entry:Entry是Map接口中的一个内部接口

interface Map{
	public static interface Entry{
		public abstract Object getkey();
		public abstract Object getvalue();
	}
}
class HashMap implements Map{
	class Hash implements Map.Entry{
		public Object getkey(){};
		public Object getvalue(){};
	}
}

    HashMap集合练习

/* 
每个学生都有对应的归属地
学生Student 地址String
学生属性:姓名，年龄
**相同姓名和年龄实为同一个学生

1.描述学生
2.定义map容器
3.获取map中的元素
 */
 import java.util.*;
 class Student implements Comparable<Student>{	//实现接口
	 private String name;
	 private int age;
	 Student(String name,int age){
		 this.name=name;
		 this.age=age;
	 }
	 public int compareTo(Student s){	//重写排序方式
		 int num=new Integer(this.age).compareTo(new Integer(s.age));
		 if(num==0){
			 return this.name.compareTo(s.name);
		 }
		 return num;
	 }
	 public int hashCode(){				//覆盖hashCode与equals，保证唯一性
		 return name.hashCode()+age*34;
	 }
	 public boolean equals(Object obj){
		 if(!(obj instanceof Student)){
			 throw new ClassCastException("类型不匹配");
		 }
		 Student s=(Student)obj;
		 return this.name.equals(s.name)&&this.age==age;
	 }
	 public String getName(){
		 return name;
	 }
	 public int getAge(){
		 return age;
	 }
	 public String toString(){
		 return name+":"+age;
	 }
 }
 class MapTest{
	 public static void main(String[] args){
		 HashMap<Student,String>hm=new HashMap<Student,String>();
		 hm.put(new Student("lisi1",21),"bj");
		 hm.put(new Student("lisi1",21),"tj");
		 hm.put(new Student("lisi2",22),"sh");
		 hm.put(new Student("lisi3",23),"cq");
		 hm.put(new Student("lisi4",24),"hz");
		 //第一种取出方式
		 Set<Student>keySet=hm.keySet();
		 Iterator<Student>it=keySet.iterator();
		 while(it.hasNext()){
			 Student stu=it.next();
			 String addr=hm.get(stu);
			 System.out.println(stu+"_"+addr);
		 }
		 //第二种取出方式
		 Set<Map.Entry<Student,String>>entrySet=hm.entrySet();
		 Iterator<Map.Entry<Student,String>>it1=entrySet.iterator();
		 while(it1.hasNext()){
			 Map.Entry<Student,String>me=it1.next();
			 Student stu=me.getKey();
			 String addr=me.getValue();
			 System.out.println(stu+".."+addr);
		 }
	 }
 }

    TreeMap集合练习

        排序练习

/* 
按学生姓名排序
使用有排序功能的TreeMap集合
 */
 import java.util.*;
 class StuNameComparator implements Comparator<Student>{
	 public int compare(Student s1,Student s2){
		 int num=s1.getName().compareTo(s2.getName());
		 if(num==0){
			 return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		 }
		 return num;
	 }
 }
 class MapTest2{
	 public static void main(String[] args){
		 TreeMap<Student,String>tm=new TreeMap<Student,String>(new StuNameComparator());
		 tm.put(new Student("alisi2",22),"bj");
		 tm.put(new Student("lisi1",21),"sh");
		 tm.put(new Student("blisi3",23),"cq");
		 tm.put(new Student("lisi4",24),"hz");
		 
		 Set<Map.Entry<Student,String>>entrySet=tm.entrySet();
		 Iterator<Map.Entry<Student,String>>it=entrySet.iterator();
		 while(it.hasNext()){
			 Map.Entry<Student,String>me=it.next();
			 Student stu=me.getKey();
			 String addr=me.getValue();
			 System.out.println(stu+"_"+addr);
		 }
	 }
 }

        获取字母出现次数

/* 
sdfgzxcvasdfxcvdf
获取该字符串中字符出现的次数
打印格式: a(1)c(2)...

通过审题发现，每一个字母都有对应的次数
说明字母和次数之间都用映射关系

用a字母作为键去找集合，返回为null，则将a和1存入集合
如果指定的键已经存在，就将次数取出，自增后重新存入集合

**有映射关系时，采用Map集合

1.将字符串转换成字符数组
2.定义一个Map集合，有顺序使用TreeMap
3.遍历字符数组，将字母作为键contains集合
	返回null则存入，value为1，
	返回!null，则将value取出自增后存入
4.将Map集合按指定格式返回
 */
 import java.util.*;
 class MapTest3{
	 public static void main(String[] args){
		 String s=charCount("aaa+b-b+bccdeeefavc");
		 System.out.println(s);
	 }
	 public static String charCount(String str){
		 char[] chs=str.toCharArray();
		 TreeMap<Character,Integer>tm=new TreeMap<Character,Integer>();
		 int count=0;	//可定在循环内，但是效率低
		 for(int x=0;x<chs.length;x++){
			 if(!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]<='Z')){
				 continue;
			 }
			 //非字母不计数
			 Integer value=tm.get(chs[x]);
			 if(value!=null){
				 count=value;
			 }
			 count++;
			 tm.put(chs[x],count);
			 count=0;	//count需要清零
/* 			 if(value==null){
				 tm.put(chs[x],1);
			 }
			 else{
				 value=value+1;
				 tm.put(chs[x],value);
			 } */
		 }
		 // System.out.println(tm);
		 StringBuilder sb=new StringBuilder();
		 Set<Map.Entry<Character,Integer>>entrySet=tm.entrySet();
		 Iterator<Map.Entry<Character,Integer>>it=entrySet.iterator();
		 while(it.hasNext()){
			 Map.Entry<Character,Integer>me=it.next();
			 Character ch=me.getKey();
			 Integer value=me.getValue();
			 sb.append(ch+"("+value+")");
		 }
		 return sb.toString();
	 }
 }

            Map扩展知识--一对多映射/集合嵌套

/* 
Map扩展知识	一对多映射
Map集合被使用是因为具备映射关系
"yureban" "01" "zhangsan"
"yureban" "02" "lisi"
"jiuyeban" "01" "wangwu"
"jiuyeban" "02" "zhaoliu"
一个学校有多个教室，每个教室都有名称
 */
 
import java.util.*;
class MapTest4{
	public static void main(String[] args){
		HashMap<String,HashMap<String,String>>czbk=new HashMap<String,HashMap<String,String>>();
		HashMap<String,String>yure=new HashMap<String,String>();
		HashMap<String,String>jiuye=new HashMap<String,String>();

		czbk.put("yureban",yure);
		czbk.put("jiuyeban",jiuye);

		yure.put("01","zhangsan");
		yure.put("02","lisi");
		
		jiuye.put("01","wangwu");
		jiuye.put("02","zhaoliu");
		//遍历czbk集合，获取所有教室
		Iterator<String>it=czbk.keySet().iterator();
		while(it.hasNext()){
			String roomName=it.next();
			HashMap<String,String>room=czbk.get(roomName);
			getStuInfo(room);
		}
		// getStuInfo(yure);
	}
	public static void getStuInfo(HashMap<String,String>roomMap){
		Iterator<String>it=roomMap.keySet().iterator();
		while(it.hasNext()){
			String id=it.next();
			String name=roomMap.get(id);
			System.out.println(id+"_"+name);
		}
	}
}

            在开发中学生姓名与学号通常封装为一个对象，因此常用List嵌套

import java.util.*;
class Student{
	private String id;
	private String name;
	Student(String id,String name){
		this.id=id;
		this.name=name;
	}
	public String toString(){
		return id+":::"+name;
	}
}
class MapTest4{
	public static void mDemo(){
		HashMap<String,List<Student>>czbk=new HashMap<String,List<Student>>();
		List<Student>yure=new ArrayList<Student>();
		List<Student>jiuye=new ArrayList<Student>();
		
		czbk.put("yureban",yure);
		czbk.put("jiuyeban",jiuye);
		
		yure.add(new Student("01","zhangsan"));
		yure.add(new Student("02","lisi"));
		jiuye.add(new Student("01","wangwu"));
		jiuye.add(new Student("02","zhaoliu"));


		Iterator<String>it=czbk.keySet().iterator();
		while(it.hasNext()){
			String roomName=it.next();
			List<Student>room=czbk.get(roomName);
			getInfos(room);
		}
	}
	public static void getInfos(List<Student>list){
		Iterator<Student>it=list.iterator();
		while(it.hasNext()){
			Student s=it.next();
			System.out.println(s);
		}
	}
	public static void main(String[] args){
        mDemo();
	}
}

 

转载于:https://my.oschina.net/Almon/blog/740065

weixin_34357928
关注
Java学习笔记-Map集合
u010186280的博客
09-29 250
一、 Map集合 1.1 概述 现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。 我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同。 Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 Map中的集合，元素是成对存在的(理
map集合（Java学习第四十天）
qq_37181884的博客
02-06 331
map集合就类似于python的字典，通过键值对来对应 map集合的实现类是通过HashMap来实现的 Map集合的基本方法 方法名 说明 V put(K key,V value) 添加元素 V remove(Object Key) 根据键删除键值对元素 void clear() 清空所有的键值对 boolean comtainsKey(Object key) 判断集合是否包含某个键 boolean comtainsKey(Object value)
Java学习日记:Map集合
kxbb99的博客
10-23 586
Java学习日记：Map集合
学生日志管理系统（ArrayList集合的应用）
qq_38864858的博客
07-23 1089
前几天学了集合框架，现在先大致对集合总结一下，再对ArrayList的一个实例进行具体讲解。 所有集合的上层接口为collection接口，它有三个子接口，分别为List，Set，Map。 其中，List接口的实现类均是线性结构，其中存储的元素是有序的，主要有三个常用的，分别是ArrayList，Vector，LinkedList，其中，前两个是线性表，便于查询，后一个是线性链表，便于对元素进
礼拜一log~java Map & 层级筛选代码
YuqiRealm.com
03-28 740
java Map＋层级筛选
Java初学者日志_集合_Map
dream_start_的博客
03-10 194
package com.jihe.java1.Map; import javax.swing.*; import java.util.*; /*-----Map接口:双列集合，用来存储一对(key-value)，一对的数据(高中函数：y=f(x),一个key只能对应一个value，一个value可以对应多个一个key) /-----HashMap:作为Map的主要实现类线程不安全，效率高，存储null和value -------LinkedHashMap:保证在
Java集合：Map
记录，记录，记录
09-02 189
一、Map概述 一讲到Map，我们就会想到散列表和HashMap，散列表：数组+列表的节点，那就有两个问题了，如何进行存放元素的下标定位和如果出现哈希碰撞了怎么办？ 散列表详解链接 Map常用类：HashMap，LinkedHashMap，TreeMap，ConcurrentHashMap，接下来就是一一来看下它们。 HashMap 现在我们已知Map的底层结构为散列表，在JDK1.8中， HashMap在决定元素存放下标时，采用HashMap的哈希算法hash（key）&（length-1）。
java基础学习之集合-Map
Johunqig的博客
02-21 890
java中的Map集合是一个由键-值（key-value）组合而成的，Map作为一个接口，jdk解释为将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 Map.entry是其内部的一个接口，由于Map没有实现Iterable接口，就不能使用iterator来遍历集合，所以通过entrySet方法转换为Set，这个Set里存放每个元素都是一个 Map.Entry< K ,
java8集合源码-scala-adventures:我通过示例自学Scala的旅程日志
06-04
7. **集合工厂方法**：Java 8为List、Set和Map添加了新的工厂方法，如of()和copyOf()，这些方法创建不可变集合，防止修改集合状态，增加了代码安全性。 在这个“scala-adventures”项目中，作者可能是通过学习Scala...
Java架构面试专题（含答案）和学习笔记-1
01-20
Java架构面试专题是针对Java开发人员在面试过程中可能会遇到的核心技术与架构问题的集合，它涵盖了从基础到高级的各种知识点，旨在帮助求职者提升面试准备的全面性和深度。本资料包含学习笔记和答案，便于自我检验和...
基于java的开发源码-通用数据底层 Jsa4j.zip
最新发布
04-01
1. **Java基础** - 类与对象：Java是面向对象的语言，一切皆为对象。通用数据底层Jsa4j可能包含了各种数据结构的封装，如ArrayList、HashMap等。 - 异常处理：Java通过try-catch-finally语句进行异常处理，确保...
Java创建map集合
imtokenmax众筹
07-28 708
01 阿里面试题之MySQL 之前的阿里面试题都有做总结，具体面试题内容整理成了文档，本文是针对MySQL系列的，所以下面只展示了自己第一次面试阿里时被吊打问到的一些MySQL难题 请解释关系型数据库概念及主要特点？ 请说出关系型数据库的典型产品、特点及应用场景？ 请详细描述 SQL 语句分类及对应代表性关键字。 什么是 MySQL 多实例，如何配置 MySQL 多实例？ 如何加强 MySQL 安全，请给出可行的具体措施？ 误操作执行了一个 drop 库 SQL 语句，如何完整恢复？ 详述 MySQL 主
Java Log 类
愿君出走半生，归来时仍是少年
05-27 2492
这个类为管理日志信息的通用类 package util; public class Log { private static final boolean debug_mode = true; public static void info(final String className, final String methodName, final String info) {
工作日志：Map的一般用法
weixin_38032755的博客
11-29 455
Map的一般用法 1.声明一个Map :Map map = new HashMap(); 2 .向map中放值 ，注意： map是key-value的形式存放的，如：map.put("mingzi","lihong"); 3 .从map中取值 :String str = map.get("sa").toString, 结果是： str = “lihong”4 .遍历一个map,从中取得key和va
JAVA学习日志10（set集合和map）
Jmist的博客
07-15 192
JAVA学习日志10 Set集合 1.是Collection的子类 Set也是一个接口 2.特点: set集合存的数据不能重复 set集合是无序 存与取获取的顺序不一样 set集合没有索引 set集合方法都是Collection的方法 实现类 : 实例化对象的时候 只能实例化其子类 set集合的遍历方法（一） 1.没有泛型的set 可以把其转换成数组 toArray() 方法 public static void main(String[] args) { Set set = new Hash
Java使用三种方式循环输出Map集合
weixin_69026046的博客
12-01 616
【代码】Java使用三种方式循环输出Map集合。
log4j使用手册
Maroon85的专栏
06-04 1315
原文http://pharaohsprince.javaeye.com/blog/74872三、编写一个简单的示例　　在了解Log4J的使用方法之前，先编写一个简单的示例，以对Log4J有个感性认识。如果使用的是Eclipse，请点击"文件"->"新建"->"类"，打开"新建Java类"对话框，设置包为 piv.zheng.log4j.test，名称为Test，并确保"
每次调试打印日志都很头痛
嘴巴吃糖了
11-29 817
当代码的运行效果不符合预期时就得进行调试，排查下整个数据链路上到底是哪个环节出了问题。 断点调试当然是首选，因为它可以单步执行程序，并查看当前执行步骤中所有的数据值。但有些场景下，断点调试就显得笨拙。比如大量异步并发的场景，当程序不是线性执行而是跳来跳去时，就会发生你期望下一步是执行到这里，断点调试却跳到了另一个线程，这样的复杂度，让正在执行的代码变得难以理解。除此之外，有些型号的手机，一断点调试就卡的不行，甚至 crash。
Java 输出Map中元素
weixin_45063703的博客
08-24 8241
前言 想要输出Map中的元素，并进行下一步处理，但是卡在了如何输出元素这块，所以经查找后，总结一下四种输出方式 程序 主程序： package TestFunction; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class TestMap { public static void main(String[] args) { // 循环遍历Map的4中方法
Java集合：List、Set与Map的区别详解
Java中的集合框架是其核心组成部分，主要分为三种类型：Set、List和Map。这三种数据结构在Java中具有不同的特性和用途。 1. **Set（集）**: - Set是无序且不允许有重复元素的集合。它的主要特点是去重，例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值