zoukankan      html  css  js  c++  java
  • java--常用API之Map接口

    集合继承体系的面向对象思想

      接口:用来明确所有集合中该具有的功能,相当于在定义集合功能标准;

      抽象类:把多个集合中功能实现方式相同的方法,抽取到抽象类实现,具体集合不再遍写,继承使用即可;

      具体类:继承抽象类,实现接口,重写所有抽象方法,达到具备指定功能的集合。

      每个具体集合类,根据自身的数据存储结构方式,对接口中的功能方法,进行不同方式的实现。

    Map接口概述:

      Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。

      Map中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。

      Collection中的集合称为单列集合,Map中的集合称为双列集合。

      需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。

      Map中常用的集合为HashMap集合、LinkedHashMap集合。

     Map接口中常用集合概述

    HashMap集合、LinkedHashMap集合:

    HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。

            由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

    LinkedHashMap<K,V>:HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。

               通过链表结构可以保证元素的存取顺序一致;

               通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

     注意:Map接口中的集合都有两个泛型变量<K,V>,在使用时,要为两个泛型变量赋予数据类型。

               两个泛型变量<K,V>的数据类型可以相同,也可以不同。

     Map接口中的常用方法

      put方法:将指定的键与值对应起来,并添加到集合中

      方法返回值为键所对应的值

    使用put方法时,若指定的键(key)在集合中没有,则没有这个键对应的值,返回null,并把指定的键值添加到集合中;

    使用put方法时,若指定的键(key)在集合中存在,则返回值为集合中键对应的值(该值为替换前的值),

    并把指定键所对应的值,替换成指定的新值。

    get方法:获取指定键(key)所对应的值(value)

    remove方法:根据指定的键(key)删除元素,返回被删除元素的值(value)。

     代码实现:

    复制代码
     1 package com.oracle.map;
     2 
     3 import java.util.HashMap;
     4 import java.util.Iterator;
     5 import java.util.Map;
     6 import java.util.Set;
     7 
     8 public class Demo01 {
     9 
    10     public static void main(String[] args) {
    11         HashMap<Integer,String> map=new HashMap<Integer,String>();
    12         map.put(1, "aaa");
    13         map.put(2, "bbb");
    14         map.put(3, "aaa");
    15         map.put(3, "ccc");
    16         /*System.out.println(map.get(3));
    17         System.out.println(map.remove(2));*/
    18         //1.键找值keySet()
    19         //获取所有键所对应的set集合
    20         /*Set<Integer> set=map.keySet();
    21         //遍历所有的键
    22         Iterator<Integer> it=set.iterator();
    23         while(it.hasNext()){
    24             //获取键
    25             int key=it.next();
    26             //通过键找值
    27             String value=map.get(key);
    28             System.out.println(key+"...."+value);
    29         }*/
    30         //2.获取结婚证entrySet()
    31         //获取结婚证集合
    32         Set<Map.Entry<Integer, String>> set=map.entrySet();
    33         //增强for遍历结婚证集合 获取到每一个结婚证对象
    34         for(Map.Entry<Integer, String> entry:set){
    35             //通过每一个结婚证对象获取key和value
    36             int key=entry.getKey();
    37             String value=entry.getValue();
    38             System.out.println(key+"....."+value);
    39         }
    40 
    41     }
    42 
    43 }
    复制代码

     Map集合遍历键找值方式

    键找值方式:即通过元素中的键,获取键所对应的值

        1.获取Map集合中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键

    2.遍历键的Set集合,得到每一个键

    3.根据键,获取键所对应的值

    HashMap存储自定义类型键值:

      HashMap:

      特点:

                     是Map集合的子集合

                     底层采用哈希表结构

                     HashMap集合中的key不能重复,通过重写hashCode() 与 equals()方法来保证键的唯一。

                     不能保证元素存与取的顺序完全一致

      LinkedHashMap:

      特点:

    是HashMap集合的子集合

    底层采用哈希表+链表结构

    LinkedHashMap集合中的key不能重复,通过重写hashCode() 与 equals()方法来保证键的唯一。

    集合嵌套:

    复制代码
     1 package com.oracle.map;
     2 
     3 import java.util.HashMap;
     4 import java.util.Map;
     5 import java.util.Set;
     6 
     7 //HashMap<String, HashMap<String,String>>
     8 //基地Oracle
     9 //Java0601
    10 //        1   熊大
    11 //        2   熊二
    12 //Java0328
    13 //        1   张维
    14 //        2    王荣臣
    15 public class Demo03 {
    16     public static void main(String[] args) {
    17         //基地oracle
    18         HashMap<String, HashMap<String,String>> oracle
    19                         =new HashMap<String, HashMap<String,String>>();
    20         //班级class
    21          HashMap<String,String> java0601=new  HashMap<String,String>();
    22          java0601.put("1", "熊大");
    23          java0601.put("2", "熊二");
    24          HashMap<String,String> java0328=new  HashMap<String,String>();
    25          java0328.put("1", "张维");
    26          java0328.put("2", "王荣臣");     
    27         //基地oracle
    28          oracle.put("java0601", java0601);
    29          oracle.put("java0328", java0328);
    30          //keySet(oracle);
    31          entry(oracle);
    32     }
    33     //第一种方式:keySet()
    34     public static void keySet(HashMap<String, HashMap<String,String>> oracle){
    35         //先获取所有班级String所对应的key
    36         Set<String> classname=oracle.keySet();
    37         for(String c:classname){
    38             //根据班级名称,获取所有学生信息所在的map
    39              HashMap<String,String> students=oracle.get(c);
    40              //获取所有学生的序号
    41              Set<String> numbers=students.keySet();
    42              for(String num:numbers){
    43                  //根据每个同学的学号获取姓名
    44                  String stuname=students.get(num);
    45                  System.out.println(c+"...."+num+"..."+stuname);
    46              }
    47         }
    48     }
    49     //第二种方式,通过entrySet()
    50     public static void entry(HashMap<String, HashMap<String,String>> oracle){
    51         //获取第一个结婚证
    52         Set<Map.Entry<String, HashMap<String,String>>> classname=oracle.entrySet();
    53         //
    54         for(Map.Entry<String, HashMap<String,String>> c:classname){
    55             //获取班级名称
    56             String cname=c.getKey();
    57             //获取学生信息的map
    58              HashMap<String,String> students=c.getValue();
    59              //获取第二个结婚证集合
    60              Set<Map.Entry<String, String>> stu=students.entrySet();
    61              //遍历结婚证集合 得到每一个结婚证
    62              for(Map.Entry<String, String> s:stu){
    63                  String num=s.getKey();
    64                  String name=s.getValue();
    65                  System.out.println(cname+"..."+num+"..."+name);
    66                  
    67              }
    68             
    69         }
    70     }
    71 }
    复制代码

    Entry键值对对象:

     Entry是Map接口中提供的一个静态内部嵌套接口。

      entrySet()方法:用于返回Map集合中所有的键值对(Entry)对象,以Set集合形式返回。

     

     静态导入

      Collections中的方法:

                       public static <T> void sort(List<T> list) 排序

                       public static void shuffle(List<?> list) 集合中的元素存储位置随机打乱

    代码实现:

    复制代码
     1 import static java.lang.System.out;
     2 public class Demo01 {
     3 
     4     public static void main(String[] args) {
     5         System.out.println("aaa");
     6         out.println("aaa");
     7 
     8     }
     9 
    10 }
    复制代码

    可变参数:int...a

    复制代码
     1 public class Demo02 {
     2 
     3     public static void main(String[] args) {
     4         //写方法:计算几个数的求和
     5         add(4,5,6,7,8,9,23,44,55);
     6     }
     7     //可变参数int...a  相当于一个数组int[]  a
     8     //必须放在参数列表最后  一次只能传一个
     9     public static void add(int b,int...a){
    10         int sum=0;
    11         for(int i:a){
    12             sum+=i;            
    13         }
    14         System.out.println(a.length);
    15         System.out.println(sum);
    16     }
    17 
    18 }
    复制代码

    sort、shuffle方法代码实现

    复制代码
     1     public static void main(String[] args) {
     2         // 给List集合打乱顺序
     3         ArrayList<Integer> list=new ArrayList<Integer>();
     4         list.add(123);
     5         list.add(2);
     6         list.add(33);
     7         list.add(44);
     8         list.add(56);
     9         list.add(633);
    10         list.add(72);
    11         System.out.println(list);
    12         //打乱
    13     /*    Collections.shuffle(list);
    14         System.out.println(list);*/
    15         //对集合进行排序
    16         Collections.sort(list);
    17         System.out.println(list);
    18     }
    19 }
    复制代码

    斗地主案例:

    复制代码
     1 import java.util.ArrayList;
     2 import java.util.Collections;
     3 import java.util.HashMap;
     4 
     5 
     6 public class DouDiZhu {
     7     private static ArrayList<Integer> bottom;
     8 
     9     public static void main(String[] args) {
    10         //1.定义扑克牌Map
    11         HashMap<Integer,String> pooker=new HashMap<Integer,String>();
    12         //2.定义装扑克牌编号的ArrayList
    13         ArrayList<Integer> pookernumber=new ArrayList<Integer>();
    14         //3.定义花色数组
    15         String[] color={"♥","♣","♦","♠"};
    16         //4.数字数组
    17         String[] number={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
    18         //组合牌
    19         int index=2;
    20         for(String num:number){
    21             for(String col:color){
    22                 pooker.put(index, col+num);
    23                 pookernumber.add(index);
    24                 index++;
    25             }
    26         }
    27         //手动封装大小王
    28         pooker.put(0, "大☻");
    29         pookernumber.add(0);
    30         pooker.put(1, "小☺");
    31         pookernumber.add(1);
    32         //洗牌
    33         Collections.shuffle(pookernumber);
    34         //发牌
    35         ArrayList<Integer> player1=new ArrayList<Integer>();
    36         ArrayList<Integer> player2=new ArrayList<Integer>();
    37         ArrayList<Integer> player3=new ArrayList<Integer>();
    38         ArrayList<Integer> bottom=new ArrayList<Integer>();
    39         
    40         for(int i=0;i<pookernumber.size();i++){
    41             if(i<3){
    42                 bottom.add(pookernumber.get(i));
    43             }else if(i%3==0){
    44                 player1.add(pookernumber.get(i));
    45             }else if(i%3==1){
    46                 player2.add(pookernumber.get(i));
    47             }else if(i%3==2){
    48                 player3.add(pookernumber.get(i));
    49             }
    50         }
    51         //对玩家及底牌进行排序
    52         Collections.sort(player1);
    53         Collections.sort(player2);
    54         Collections.sort(player3);
    55         Collections.sort(bottom);
    56         //看牌
    57         look("薛之谦",pooker,player1);
    58         look("刘德华",pooker,player2);
    59         look("王祖蓝",pooker,player3);
    60         look("底牌",pooker,bottom);
    61     }
    62     public static void look(String name,HashMap<Integer,String> pooker,ArrayList<Integer> player){
    63         System.out.print(name+":");
    64         for(int num:player){
    65             System.out.print(pooker.get(num)+" ");
    66         }
    67         System.out.println();
    68     }
    69 }
    复制代码

     

  • 相关阅读:
    打印九九乘法表
    PAT (Basic Level) Practice (中文) 1091 N-自守数 (15分)
    PAT (Basic Level) Practice (中文)1090 危险品装箱 (25分) (单身狗进阶版 使用map+ vector+数组标记)
    PAT (Basic Level) Practice (中文) 1088 三人行 (20分)
    PAT (Basic Level) Practice (中文) 1087 有多少不同的值 (20分)
    PAT (Basic Level) Practice (中文)1086 就不告诉你 (15分)
    PAT (Basic Level) Practice (中文) 1085 PAT单位排行 (25分) (map搜索+set排序+并列进行排行)
    PAT (Basic Level) Practice (中文) 1083 是否存在相等的差 (20分)
    PAT (Basic Level) Practice (中文) 1082 射击比赛 (20分)
    PAT (Basic Level) Practice (中文) 1081 检查密码 (15分)
  • 原文地址:https://www.cnblogs.com/-dashu/p/9429441.html
Copyright © 2011-2022 走看看