zoukankan      html  css  js  c++  java
  • 集合的笼统介绍之map

    collection集合的全部都已经结束,但是我们发现他都是单列存在的集合,map则是双列存在的集合。

     如图:

    它是键值存在的集合,键是唯一的,但是值可以不唯一,但是必须一对一唯一。也就是不能重复的。

     Map接口中常用集合概述(它的键对,其实就是两个泛型)

    通过查看Map接口描述,看到Map有多个子类,这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

    HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。常用

    LinkedHashMap<K,V>HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

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

    如前文,集合

    ①创建对象

    Map<string,interger> map=new hashmap <string,integer>();

    ②常用方法

    ③遍历重要

    它的遍历方式非常特殊。

    1.

    2.

      

      

      

    3.但因为它是通过返回一个set集合,借用set集合的遍历方法进行遍历,也就是说它可以用for或者迭代器Iterator来使用,两两配合,总共有四个方法

    代码如下

    package com.oracle.demo01;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Demo01 {
        public static void main(String[] args) {
            //创建map集合 hashmap是子类
            Map<String,String> map=new HashMap<String,String>();
            map.put("a", "123");
            map.put("b", "456");
            map.put("c", "123");
            map.put("a", "147");
            //重复的键值存储不了,但会把原先的覆盖掉
            //get方法返回的是value值
            System.out.println(map.get("a"));
            //遍历
            //第一种,通过map的keySet()方法,调取key,通过key获取所有的set。
            //keySet+增强for
            //1、获取所有key所在的Set集合
            //多态
            Set<String>set =map.keySet();
            //增强for遍历set集合
            System.out.println("-----------------------------------keyset()方法+增强for-");
            for(String key:set){
                System.out.println(key+"..."+map.get(key));
                System.out.println("-----------------------------------keyset+Iterator-");
                //第二种:keySet +Iterator
                Set<String> set1=map.keySet();
                //遍历  用变量名.方法名()
                Iterator<String> iterator=set1.iterator();
                while(iterator.hasNext()){
                    String key1=iterator.next();
                    System.out.println(key1+map.get(key1));
                    //创建map集合 hashmap是子类
                }
            }
        }
    }

    package com.oracle.demo01;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Demo02 {
        public static void main(String[] args) {
            //创建map集合
            Map<Integer,String>map=new HashMap<Integer,String>();
            //put增加内容
            map.put(1, "司南");
            map.put(2, "周戎");
            map.put(3, "楚慈");
            //遍历
            //1.entrySet+增强for
            //1.获取所有结婚证entry对象
            System.out.println("==================entrySet+增强for");
            Set<Map.Entry<Integer,String>> set=map.entrySet();
            //2.遍历结婚证集合获取每一个结婚证entry对象
            for(Map.Entry<Integer,String> entry :set){
                //因为有返回值,所以接收一下
            /*    int key=entry.getKey();
                String value=entry.getValue();*/
                System.out.println(entry.getKey()+"..."+entry.getValue());
            }
                //entry+Iterator
                System.out.println("==================entry+Iterator");
                //1.获取所有结婚证对象所在的set集合
                Set<Map.Entry<Integer, String>> set2=map.entrySet();
                //2.获取iterator对象 这里需要提前声明泛型,要不后面需要向下转换
                Iterator<Map.Entry<Integer, String>> it=set2.iterator();
                //3.遍历循环
                while(it.hasNext()){
                    //获取每一个结婚证对象这里必须要带有map.entry<>因为这才是里面返回的泛型
                    Map.Entry<Integer, String> entry1=it.next();
                    int key1=entry1.getKey();
                    String value1=entry1.getValue();
                    System.out.println(key1+"..."+value1);
                }
        }
    }

    这里的hashmap集合如果泛型是自定义类,和set一样,需要重写hashcode和equals方法。就不多说了。(因为他是返回set的缘故)也因为hashset的缘故,它的LinkedHashMap也是保证顺序的集合呢。

    比较少见的方法

    1.静态导入

    import static XXXimport static java.lang.System.out;.YYY;   导入后YYY可直接使用。

    import static java.lang.System.out;

        //导入静态
            out.println("lalla");

    2.可变参数

    修饰符 返回值类型 方法名(参数类型... 形参名){  }

    代码案例:

    package com.oracle.demo02;
    import static java.lang.System.out;
    public class Demo01 {
        public static void main(String[] args) {
            //导入静态
            out.println("lalla");
            System.out.println(add(1,2));
            System.out.println(add(2,3,4));
            System.out.println(add(2,3,4,5));
            System.out.println(add(2,3,4,5,6));
        }
        //写一个方法,计算求和,方法类型可以
        public static int add(int ...a){//double...b){//可变参数,int [] a数组,如果有另外的可变参数,需要把它写在后面,如果是限定死的参数,
                                    就可以写在前面,好处就是可以无限制的传递参数,但一个里面只能写一个、
    int sum=0; for(int s:a){ sum=sum+s; } return sum; } /*public static int add(int a,int b,int c){ return a+b; }*/ }

    3.collections集合的工具类

    好了,篇幅有点长,下一篇单纯补充两个案例。

  • 相关阅读:
    自定义组件要加@click方法
    绑定样式
    647. Palindromic Substrings
    215. Kth Largest Element in an Array
    448. Find All Numbers Disappeared in an Array
    287. Find the Duplicate Number
    283. Move Zeroes
    234. Palindrome Linked List
    202. Happy Number
    217. Contains Duplicate
  • 原文地址:https://www.cnblogs.com/a199706/p/11361856.html
Copyright © 2011-2022 走看看