• Java---Map双列集合

    目录

    一、双列集合的介绍

    二、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

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

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

    （1）put方法

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

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.lang.reflect.Array;
    5. import java.util.*;
    6.  
    7. public class so {
    8.     public static void main(String[] args) {
    9.         Map s=new HashMap<>();
    10.         
    11.         String v1=s.put("jkjk", "123");
    12.         System.out.println(v1);
    13.         s.put("opo", "234");
    14.         s.put("yyyy", "");
    15.         String v2=s.put("opo", "[[[[");
    16.         
    17.         System.out.println(v2);
    18.         System.out.println(s);
    19.     }
    20. }
    21.

    （2）remove方法

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

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.lang.reflect.Array;
    5. import java.util.*;
    6.  
    7. public class so {
    8.     public static void main(String[] args) {
    9.         Map s=new HashMap<>();
    10.         
    11.         String v1=s.put("jkjk", "123");
    12.         s.put("opo", "234");
    13.         s.put("yyyy", "");
    14.         String v2=s.put("opo", "[[[[");
    15.         System.out.println(s);
    16.         String v3=s.remove("opo");
    17.         System.out.println(v3);
    18.         System.out.println(s);
    19.     }
    20. }
    21.

    2：Map的遍历

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

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.lang.reflect.Array;
    5. import java.util.*;
    6.  
    7. public class so {
    8.     public static void main(String[] args) {
    9.         Map s=new HashMap<>();
    10.         
    11.         String v1=s.put("jkjk", "123");
    12.         s.put("opo", "234");
    13.         s.put("yyyy", "");
    14.         String v2=s.put("opo", "[[[[");
    15.         System.out.println(s);
    16.         Set ss=s.keySet();//获取到键并放入ss集合
    17.         for(String k:ss) {
    18.         	String value=s.get(k);//通过键获取值
    19.         	System.out.println("键="+k+"，值="+value);
    20.         }
    21.     }
    22. }
    23.

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

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

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.lang.reflect.Array;
    5. import java.util.*;
    6.  
    7. public class so {
    8.     public static void main(String[] args) {
    9.         Map s=new HashMap<>();
    10.         
    11.         String v1=s.put("jkjk", "123");
    12.         s.put("opo", "234");
    13.         s.put("yyyy", "");
    14.         String v2=s.put("opo", "[[[[");
    15.         Set > ss=s.entrySet();//获取键值对对象，并将其放入集合中
    16.         
    17.         for(Map.Entry oo:ss) {
    18.         	String key=oo.getKey();//获取键值对对象中的键
    19.         	String value=oo.getValue();//获取键值对对象中的值
    20.         	System.out.println("键="+key+" 值="+value);
    21.         }
    22.     }
    23. }
    24.

     （3）Lambda表达式遍历

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.util.function.BiConsumer;
    5. import java.lang.reflect.Array;
    6. import java.util.*;
    7.  
    8. public class so {
    9.     public static void main(String[] args) {
    10.         Map s=new HashMap<>();
    11.         
    12.         String v1=s.put("jkjk", "123");
    13.         s.put("opo", "234");
    14.         s.put("yyyy", "");
    15.         String v2=s.put("opo", "[[[[");
    16.         
    17.         s.forEach(new BiConsumer(){
    18.  
    19. 			@Override
    20. 			public void accept(String key, String value) {
    21. 				// TODO 自动生成的方法存根
    22. 				System.out.println("键="+key+" 值="+value);
    23. 			}
    24.         	
    25.         });
    26.         System.out.println("Lamda表达式再简化");
    27.         
    28.         s.forEach((String t, String u)-> {
    29. 				// TODO 自动生成的方法存根
    30. 				System.out.println("键="+t+" 值="+u);
    31. 			}
    32.         );
    33.     }
    34. }
    35.

     三、双列集合的使用

    1：HashMap

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

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

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

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

    1. package article;
    2.  
    3. import java.util.Objects;
    4.  
    5. public class student {
    6.    String name;
    7.    int age;
    8.    public student(String name,int age) {
    9. 	   this.age=age;
    10. 	   this.name=name;
    11.    }
    12.    public void setname(String name) {
    13. 	   this.name=name;
    14.    }
    15.    public void setage(int age) {
    16. 	   this.age=age;
    17.    }
    18.    public String getname() {
    19. 	   return name;
    20.    }
    21.    public int getage() {
    22. 	   return age;
    23.    }
    24. @Override
    25. public int hashCode() {
    26. 	return Objects.hash(age, name);
    27. }
    28. @Override
    29. public boolean equals(Object obj) {
    30. 	if (this == obj)
    31. 		return true;
    32. 	if (obj == null)
    33. 		return false;
    34. 	if (getClass() != obj.getClass())
    35. 		return false;
    36. 	student other = (student) obj;
    37. 	return age == other.age && Objects.equals(name, other.name);
    38. }
    39.    
    40. }
    41.  
    42. package article;
    43.  
    44. import java.util.Arrays;
    45. import java.util.function.BiConsumer;
    46. import java.lang.reflect.Array;
    47. import java.util.*;
    48.  
    49. public class so {
    50.     public static void main(String[] args) {
    51.         Map s=new HashMap<>();
    52.         student s1=new student("张三",10);
    53.         student s2=new student("王五",20);
    54.         student s3=new student("赵烈",30);
    55.         student s4=new student("王五",20);
    56.         
    57.         s.put(s1,"安徽");
    58.         s.put(s2, "江苏");
    59.         s.put(s3, "浙江");
    60.         s.put(s4, "天津");
    61.         
    62.         Set> ss=s.entrySet();
    63.         for(Map.Entry gg:ss) {
    64.         	student key=gg.getKey();
    65.         	String  value=gg.getValue();
    66.         	System.out.println("键中的名字="+key.getname()+"键中的年龄="+key.getage()+"  值中的籍贯="+value);
    67.         }
    68.     }
    69. }
    70.  
    71.

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

     

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.util.function.BiConsumer;
    5. import java.lang.reflect.Array;
    6. import java.util.*;
    7.  
    8. public class so {
    9.     public static void main(String[] args) {
    10.        //80人去的景点，我们用随机数来搞
    11.     	Random r=new Random();
    12.     	String[] a= {"A","B","C","D"};
    13.     	ArrayList s=new ArrayList<>();//存储的是80每个人去的景点
    14.     	for(int i=0;i<80;i++) {
    15.     		int index=r.nextInt(4);
    16.     		s.add(a[index]);
    17.     	}
    18.     	//现在每个人去的景点已经添加到s链表中
    19.     	Map h=new HashMap<>();
    20.     	for(String place:s) {
    21.     		if(h.containsKey(place)) {
    22.     			//地方已经存在
    23.     			int count=h.get(place);
    24.     			count++;
    25.     			h.put(place, count);
    26.     		}
    27.     		else {
    28.     			//第一个人去
    29.     			h.put(place,1);
    30.     		}
    31.     	}
    32.     	
    33.     	int ma=0;
    34.     	//遍历输出
    35.     	Set> gg=h.entrySet();
    36.     	for(Map.Entry oo:gg) {
    37.     		String key=oo.getKey();
    38.     		int value=oo.getValue();
    39.     		if(ma
    40.     			ma=value;
    41.     		}
    42.     		System.out.println("去"+key+"的人数="+value);
    43.     	}
    44.     	
    45.     	//求最大人数
    46.     	System.out.println("最大人数="+ma);
    47.    }
    48. }
    49.

     2：LinkedHashMap

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

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

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.util.Map.Entry;
    5. import java.util.function.BiConsumer;
    6. import java.lang.reflect.Array;
    7. import java.util.*;
    8.  
    9. public class so {
    10.     public static void main(String[] args) {
    11.        Map s=new LinkedHashMap<>();
    12.        s.put("909", 100);
    13.        s.put("sd", 1);
    14.        s.put(">>>>", 100);
    15.        
    16.        Set> ss=s.entrySet();
    17.        
    18.        for(Entry oo:ss) {
    19.     	   String key=oo.getKey();
    20.     	   int value=oo.getValue();
    21.     	   System.out.println("键="+key+" 值="+value);
    22.        }
    23.    }
    24. }
    25.

    3：TreeMap

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

    （1）Comparable接口排序

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

    1. package article;
    2.  
    3. import java.util.Objects;
    4.  
    5. public class student implements Comparable{
    6.    String name;
    7.    int age;
    8.    public student(String name,int age) {
    9. 	   this.age=age;
    10. 	   this.name=name;
    11.    }
    12.    public void setname(String name) {
    13. 	   this.name=name;
    14.    }
    15.    public void setage(int age) {
    16. 	   this.age=age;
    17.    }
    18.    public String getname() {
    19. 	   return name;
    20.    }
    21.    public int getage() {
    22. 	   return age;
    23.    }
    24. @Override
    25. public int compareTo(student o) {
    26. 	// TODO 自动生成的方法存根
    27. 	int t=this.age-o.age;
    28. 	if(t==0) {
    29. 		return this.name.compareTo(o.name);
    30. 	}
    31. 	return t;
    32. }
    33.  
    34.    
    35. }
    36. package article;
    37.  
    38. import java.util.Arrays;
    39. import java.util.Map.Entry;
    40. import java.util.function.BiConsumer;
    41. import java.lang.reflect.Array;
    42. import java.util.*;
    43.  
    44. public class so {
    45.     public static void main(String[] args) {
    46.        Map s=new TreeMap<>();
    47.        student s1=new student("abc",19);
    48.        student s2=new student("bnc",19);
    49.        student s3=new student("acc",19);
    50.        student s4=new student("adddd",19);
    51.        student s5=new student("nzbs",20);
    52.        student s6=new student("qqss",3);
    53.        student s7=new student("poojs",30);
    54.        
    55.        s.put(s1,"安徽");
    56.        s.put(s2, "安徽");
    57.        s.put(s3, "天津");
    58.        s.put(s4, "浙江");
    59.        s.put(s5, "安徽");
    60.        s.put(s6, "天津");
    61.        s.put(s7, "浙江");
    62.        
    63.        Set> ss=s.entrySet();
    64.        for(Map.Entry oo:ss) {
    65.     	   student key=oo.getKey();
    66.     	   String value=oo.getValue();
    67.     	   System.out.println("键中名字="+key.getname()+" 键中年龄="+key.getage()+" 值="+value);
    68.        }
    69.    }
    70. }
    71.

     （2）Comparator比较器排序

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

    1. package article;
    2.  
    3. import java.util.Arrays;
    4. import java.util.Map.Entry;
    5. import java.util.function.BiConsumer;
    6. import java.lang.reflect.Array;
    7. import java.util.*;
    8.  
    9. public class so {
    10.     public static void main(String[] args) {
    11.        Map s=new TreeMap<>(new Comparator() {
    12.  
    13. 		@Override
    14. 		public int compare(student o1, student o2) {
    15. 			// TODO 自动生成的方法存根
    16. 			int t=o2.age-o1.age;
    17. 			if(t==0) {
    18. 				return o2.name.compareTo(o1.name);
    19. 			}
    20. 			
    21. 			return t;
    22. 		}
    23.     	   
    24.        });
    25.        student s1=new student("abc",19);
    26.        student s2=new student("bnc",19);
    27.        student s3=new student("acc",19);
    28.        student s4=new student("adddd",19);
    29.        student s5=new student("nzbs",20);
    30.        student s6=new student("qqss",3);
    31.        student s7=new student("poojs",30);
    32.        
    33.        s.put(s1,"安徽");
    34.        s.put(s2, "安徽");
    35.        s.put(s3, "天津");
    36.        s.put(s4, "浙江");
    37.        s.put(s5, "安徽");
    38.        s.put(s6, "天津");
    39.        s.put(s7, "浙江");
    40.        
    41.        Set> ss=s.entrySet();
    42.        for(Map.Entry oo:ss) {
    43.     	   student key=oo.getKey();
    44.     	   String value=oo.getValue();
    45.     	   System.out.println("键中名字="+key.getname()+" 键中年龄="+key.getage()+" 值="+value);
    46.        }
    47.    }
    48. }
    49.

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

  • 相关阅读:
    【NOIP2018模拟10.30】Idioms 题解
    猿创正文|C++——模板初阶|泛型编程|函数模板|函数模板概念 |函数模板格式|函数模板的实例化|模板参数的匹配原则|类模板 |类模板定义格式|习题
    【Ubuntu】Anaconda的安装和使用
    人工智能 | AI芯片类型：CPU GPU TPU DPU NPU BPU
    K210(SiPEED MaixBit)MicroPython使用参考（十、MAX98357A的I2S驱动）
    【Qt炫酷动画】专栏导航目录
    如何理解分布式架构和微服务架构呢
    前端程序员如何使用GPT
    索尼 toio™ 应用创意开发征文｜教育与游戏的完美融合：toio™核心Q宝引领数字学习新潮流
    Qt实用技巧：在CentOS上使用linuxdeployqt打包发布qt程序
  • 原文地址：https://blog.csdn.net/gaoqiandr/article/details/127892284