集合的笼统介绍之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集合的工具类

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

转载于:https://www.cnblogs.com/a199706/p/11361856.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值