欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第51节:Java当中的集合框架Map

程序员文章站 2022-05-13 22:38:19
简书作者:达叔小生 Java当中的集合框架Map 01 提供了三个集合视图: 1. 键集 2. 值集 3. 键 值 映射集 (星期天)、 (星期一)、 (星期二)、 (星期三)、 (星期四)、 (星期五)、 (星期六) 知道的子接口: 知道的实现类: 实现的接口: 在映射中不能有重复的键,每个键只能 ......

第51节:Java当中的集合框架Map

简书作者:达叔小生

java当中的集合框架map

01

map提供了三个集合视图:

  1. 键集
  2. 值集
  3. 键-值 映射集
public string getweek(int num){
 if(num<0 || num>7){
  throw new noweekexception(num+"没有对应的星期");
  string[] weeks = {"","星期一"...."星期日"};
  return weeks[num];
 }
}

sunday(星期天)、monday(星期一)、tuesday(星期二)、wednesday(星期三)、thursday(星期四)、friday(星期五)、saturday(星期六)

java.util
接口 map<k,v>
参数:
k为此映射的键
v为此映射的值

知道的子接口:

bindings,concurrentmap<k,v>,concurrentnavigablemap<k,v>,logicalmessagecontext,messagecontext,navigablemap<k,v>,soapmessagecontext,sortemap<k,v>

知道的实现类:

abstractmap,attributes,authprovider,concurrenthashmap,concurrentskiplistmap,enummap,hashmap,hashtable,identityhashmap,linkedhashmap,printerstatereasons,properties,provider,renderinghints,simplebindings,tabulardatasupport,treemap,uidefaults,weakhashmap

实现的接口:

public interface map<k,v>

在映射中不能有重复的键,每个键只能映射在一个值上

map集合中的特点:

  1. 内部存储的模式是以键-值对的形式
  2. map中的键要具有唯一性

嵌套类(内部的):

方法 说明
map.entry<k,v> static interface,静态 接口,映射模式键-值对

map方法:

方法 说明
clear() 类型为void,在映射中移除所有的映射关系
containskey(object key) 返回boolean类型,如果映射中包含指定的键的映射关系,返回为true,反之为false
containsvalue(object value) 返回boolean类型,如果映射中一个或多个键映射到指定的值上,返回为true,反之为false
entryset() 返回类型为set<map.entry<k,v>> 返回此映射中包含的映射关系
equals(object o) 返回类型为boolean,比较指定对象与映射是否相等
get(object key) 返回值,返回指定键所映射的值,如果此映射不包含该键的映射关系,返回为null,代表没有
hascode() 返回为int类型,返回此映射的哈希码值
isempty() 返回类型为boolean,如果此映射没有键-值的映射关系,返回为true,反之为false
keyset() 返回类型为set<e>,返回此映射中包含的所有键的set视图
put(k key, v value) 将对应的键与值,建立映射关系,添加映射关系的方法
putall(map<? extends k, ? extends v> m) 返回类型为void,从指定的映射关系中将所有的映射关系复制到此映射中
remove(object key) 如果存在这个键的映射关系就将其移除
size() 返回类型为int类型,返回此映射关系中的键-值映射关系的数目
values() 返回类型为collection<v>,返回此映射中包含的值的collection视图

put

v put (e key, v value)

将对应的键与值,建立映射关系,添加映射关系的方法,如果之前就有这个映射关系,就会将指定的值替换掉旧的值。

参数:

key - 为指定的关联的键
value - 为指定的关联的值

会抛出的错误:

unsupportedoperationexception:不支持put操作
classcastexception:不允许用映射关系
nullpointerexception:将指定的键或者值为null,而此映射却不允许存储
illegalargumentexception:指定的键或者值不允许存储到映射中

一般用的实现类:

hashmap

java.util
类 hashmap<k,v>
java.lang.object
 -> java.util.abstractmap<k,v>
  -> java.util.hashmap<k,v>

参数:

k-为所对应的键
v-为所对应的值

已实现的接口:

serializable,cloneable,map<k,v>

已知的子类:

linkedhashmap,printerstatereasons

所以:

public class hashmap<k,v> extends abstractmap<k,v>
implements map<k,v>, cloneable, serializable

02

map例子:

import java.util.hashmap;
public class mapdemo {
 public static void main(string[] args){
  // 建立map
  map<string,string> map = new hashmap<string,string>();
 // 添加元素
  map.put("星期一", "monday");
  mpa.put( ...// 自行添加 );
  map.put("星期日", "sunday");
  // 添加元素时,如果键相同,值会覆盖
  map.put("星期日", "sundaydemo");  // 值被覆盖
 // 获取值
 string value = map.get("星期日"); // 键存在,返回值,反之返回null,为空
 // 删除元素
 string s = map.remove("星期日"); // 删除对应的键值对关系,这样在map集合中就少了这一对键值对
 }
}

如何获取所有的键

map<string,string> map = new hashmap<string,string>();
map.put("星期一", "monday");
map.put("星期日", "sunday");

使用keyset

set<string> keyset = map.keyset();
for(iterator<string> it = keyset.iterator(); it.hasnext(); ){
 string key = it.next();
 string value = map.get(key);
 system.out.println(key + " : " + value);
}

可以使用foreach循环

for(string key : keyset){
 system.out.println(key + " = " + map.get(key));
}

entryset

set<map.entry<k,v>> entryset()

作用为返回此映射中包含的映射关系set的视图,将map集合中映射关系存储到set集合中。

映射关系:指键和值对应的关系,数据类型map.entry(内部的)关系的类型

set<map.entry<string,string>> entryset = map.entryset();
iterator< map.entry<string,string> > it = entryset.iterator();
while(it.hasnext(k,v)){
 map.entry<string,string> m = it.next();
 // 获取键
 string key = m.getkey();
 // 获取值
 string value = m.getvalue();
 system.out.println(key + " : " + value);
}

map.entry<k,v>

java.util
接口 map.entry<k,v>

接口实现类:

abstractmap.simpleentry , abstractmap.simpleimmutableentry

接口:

public static interface map.entry<k,v>
// 为映射项 - 键-值 对

map.entry<k,v>方法

方法:

方法 说明
equals(object o) 返回类型为boolean,比较指定对象与此项的相等性
getkey() 返回为此项对应的键
getvalue() 返回为此项对应的值
hashcode() 返回类型为int,返回为此项的哈希码值
setvalue(v value) 用指定的值去换此项对应的值
for(map.entry<string,string> m : map.entryset()){
 string key = m.getkey();
 string value = m.getvalue();
 system.out.println(key + " : " + value);
}
interface map{
 public static interface entry();
}

values()

返回类型为collection<v>,返回此映射中包含的值的collection视图

collection<string> values = map.values();
for(string value : values){
 system.out.println("value:"+value);
}

总结:map -> entryset() getkey() getvalue() -> keyset() get(key) -> values()

03

第51节:Java当中的集合框架Map

hashmap

public class hashmapdemo {
 public static void main(string[] args){
  map<student,string> map = new hashmap<student,string>();
 // 添加元素
 map.put(new student("da",12), "1");
 map.put(new student("shu",13), "2");
 map.put(new student("dashu",14), "3");
 // 取出数据
 // set<student> keyset = map.keyset();
 // for(student key : keyset){}
 for(student key : map.keyset() ){
  string value = map.get(key);
  system.out.println(key.tostring() + " : " + value);
 }
 }
}
public class student implements comparable<student>{
 private string name;
 private int age;
 public student(){
  super();
 }
 public student(string name, int age){
  super();
  this.name = name;
  this.age = age;
 }
 public string getname() {
  return name;
 }
 public void setname(string name) {
  this.name = name; 
 }
 public int getage() {
  return age;
 }
 public void setage(int age){
  this.age = age;
 }
 @override 
 public string tostring() {
  return "student [name = " + name +",age = " + age + "]";
 }
 @override
 public int hascode() {
  final int prime = 31;
  int result = 1;
  result = prime + result + age;
  result = prime + result + ((name == null) ? 0 : name.hashcode());
  return result;
 }
 @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;
  if(age != other.age)
   return false;
  if(name == null){
   if(other.name != null)
    return false;
  }else if(!name.equals(other.name))
    return false;
  return true;
 }
 @override
 public int  compareto(student o){
  int temp = this.age - o.age;
  
  return temp == 0? this.name.compareto(o.name) : temp;
 }
}

treemap

public class treemapdemo{
 public static void main(string[] args){
   map<student, string> map = new treemap<student, string>(new comparatorbyname());
 // 添加元素
 map.put(new student("da",12), "1");
 map.put(new student("shu",13), "2");
 map.put(new student("dashu",14), "3");
 // 取出数据
 for(map.entry<string,string> m : map.entryset()){
  student key = m.getkey();
  string value = m.getvalue();
  system.out.println(key + " : " + value);
 }
 }
}
public class comparatorbyname implements comparator<student>{
 @override
 public int compare(student o1, student o2){
  int temp = o1.getname().compareto(o2.getname());
  return temp == 0 ? o1.getage() - o2.getage() : temp;
 }
}

04

实例:

public class collectionsdemo {
   public static void main(string[] args) {
      map m = new hashmap(); 
      m.put("da", "8");
      m.put("shu", "9");
      m.put("dashu", "10");
      m.put("dashucoding", "12");
      system.out.println(m);
   }
}

java map 集合类

最常用的集合类就是listmaplist的实现类包括arraylistvector,可以变大小的列表,适合构建,存储,和操作任何类型对象元素的列表。

map是比较通用的,map集合类是用于存储元素对的,为键-值对,每个键映射到一个值,从理解上可以将list看作数值键的map,但两者没有什么关系。

所有键值对 — entryset()
所有键 — keyset()
值 — values()

iterator keyvalues = map.entryset().iterator();
iterator keys = map.keyset().iterator();
iterator values = map.values().iterator();

entryset():返回 map 中所包含 映射 的 set 视图。
keyset():返回 map 中所包含 键 的 set 视图。
values():返回 map 中所包含 值 的 collection 视图。

往后余生,唯独有你
简书作者:达叔小生
90后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通
简书博客:

结语

  • 下面我将继续对 其他知识 深入讲解 ,有兴趣可以继续关注
  • 小礼物走一走 or 点赞