一、双列集合的介绍

二、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>(){@Overridepublic 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>() {@Overridepublic 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);}}
}

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

Java---Map双列集合相关推荐

Map双列集合的用法，遍历方法
Map集合的常用方法. Map集合是一个双列集合,里面的每个元素都是一个键值对. Map<K,V> 有两个泛型, K 表示Map集合中键的类型. V 表示Map集合中值的数据类型. 常用方 ...
【Java】如何理解Java中的双列集合Map？
1 Map<K,V>接口 1.1 特点双列集合一个元素包含俩值 Key不可以重复,Value可以重复 Key和Value一一对应 Key和Value可以时任意类型 1.2 常用方法 pu ...
JAVA day20、21 双列集合Map＜K,V＞：HashMap，LinkedHashMap，TreeMap，Hashtable， ConcurrentHashMap；JDK1.9新特性
一.Map<K,V> Java提供了专⻔的集合类⽤来存放这种这种⼀⼀对应的关系,叫做映射对象,即 java.util.Map 接⼝. 类型参数: K - 此映射所维护的键的类型 V - 映 ...
Java双列集合之Map以及斗地主案列
Map集合知识点-- 概述讲解图文演示现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射.Java提供了专门的 ...
java 双列集合Map 万字详解
目录一.前言二.概述三.特点四.常用方法 1. V put(K key, V value) : Δ代码演示 : 2. V get(Object key) : Δ代码演示 : 3. V remo ...
java基础巩固-宇宙第一AiYWM：为了维持生计，多高（多线程与高并发）_Part9~整起（单双列集合们、ArrayList 的扩容机制、HashMap、ConcurrentHashMap ）
再进入正文之前,先看看集合相关操作的时间复杂度: 本故事源自于~ 开唠: PART0: 为什么突然蹦出集合这个玩意,就是因为咱们基础那里学的"数组"不够用~: 数组一般用来保存一组 ...
java 中遍历双列集合_获取单列集合，双列集合，数组的Stream流对象以及简单操作...
获取流对象获取单列集合,双列集合,数组的流对象单列集合获取流对象: 1.java.util.Collection接口中加入了default方法stream()获取流对象,因此其所有实现类均可通过此 ...
java-集合-Map(双列)——迪迦重制版
目录引言一:Map星云,集合(概要!!!,,,哦,不是,喊错了,盖亚!!!) 1.盖亚?(概要): 2.技能(特点): 3.举例: 4.创建Map集合的对象: 5.所有方法: 6.Map注意事项: ...
双列集合，往treeMap里添加元素的时候注意的事项
双列集合:数据是成对存在的,存在映射关系. TreeSet要注意的事项: 1.往treeMap里添加元素的时候,如果元素本身具备了自然顺序的特性,那么就按照元素自然顺序特性进行排序储存. 2.往tre ...

Java---Map双列集合

一、双列集合的介绍

二、Map的使用

1：Map中常见的API

（1）put方法

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

（2）remove方法

2：Map的遍历

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

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

（3）Lambda表达式遍历

三、双列集合的使用

1：HashMap

2：LinkedHashMap

3：TreeMap

（1）Comparable接口排序

（2）Comparator比较器排序

Java---Map双列集合相关推荐

最新文章

热门文章