java之map接口

一。collection与map集合的区别

1.collection集合中的元素为孤立存在，map集合中的预算为成对存在（key键--vlaue值）

2.collection集合为单列集合，map集合为双列集合

3.collection集合中有重复的元素，也可以没有重复的元素，map集合中key值不能重复，但值可以重复

4.Map中常用的集合为HashMap集合（存储无顺序）、LinkedHashMap集合（存储有顺序）

5.键值遵循hashSet，不能重复，无序存储。linkedMap，有顺序。

二。如果存储的键为自定义数据类型，必须重写键的hashCode()方法、equals()方法。

person对象

package com.oracle.demo01;

public class Person {
 private String name;
 private Integer age;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Integer getAge() {
    return age;
}
public void setAge(Integer age) {
    this.age = age;
}
public Person(String name, Integer age) {
    super();
    this.name = name;
    this.age = age;
}
public Person() {
    super();
}
@Override
public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";
}
 @Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((age == null) ? 0 : age.hashCode());
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}
 @Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (age == null) {
        if (other.age != null)
            return false;
    } else if (!age.equals(other.age))
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}
}

 

package com.oracle.demo01;

import java.util.HashMap;
import java.util.Set;

//自定义类型Map集合中的键值
public class Demo04 {
public static void main(String[] args) {
    HashMap<Person,String>  map=new HashMap<Person,String>();
    //自定义类使用对象的形式存储数值
    map.put(new Person("一",18),"yi");
    map.put(new Person("二",18),"er");
    map.put(new Person("三",18),"san");
    map.put(new Person("一",18),"wu");
    //遍历
    Set<Person> set=map.keySet();
    for(Person p:set){
        System.out.println(p+"---"+map.get(p));
    }
    //重写hashcode(),equals()   source___  hashcode()and equals()  
}
}

 

三。put  remove  get方法的使用

package com.oracle.demo01;

import java.util.HashMap;
import java.util.HashSet;

public class Demo01 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String, String>();
        // put存储键值对
        map.put("yi", "123");
        map.put("er", "456");
        map.put("yi", "456");
        map.put("san", "789");
        //删除
        System.out.println(map.remove("yi"));
        // 取值 获得Value值    同一个key值，value值覆盖前面的内容,若无这个key值，返回null
        System.out.println(map.get("yi"));
    }
}

四。map集合中通过键查询value值的四种方法

keyset+迭代器或增强for

package com.oracle.demo01;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Demo02 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String, String>();
        // put存储键值对,返回Value值
        map.put("yi", "123");
        map.put("er", "456");
        map.put("yi", "456");
        map.put("san", "789");
        // keyset+增强for ,得到key值
        // 导set包，
        /*
         * Set<String> ss=map.keySet(); //遍历 for(String s:ss){//获得S对应的key值
         * System.out.println(map.get(s));//传入s值，得到value值 }
         */
        // keySet+迭代器
        // 获得set集合，单列集合
        Set<String> s1 = map.keySet();
        // 创建迭代器
        Iterator<String> s2 = s1.iterator();
        // 遍历
        while (s2.hasNext()) {
            // 此时为两次next()
            // System.out.println(ssss.next()+","+map.get(ssss.next()));
            // 程序中最好出现一次next().
            String a = s2.next();
            System.out.println("键值key为" + a + ",value值为" + map.get(a));
        }

    }

}

enteyset+迭代器或增强for循环（）

1.首先获得键值对对象map.entry<E,E>   2.再使用getkey/getvalue

package com.oracle.demo01;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo03 {
    public static void main(String[] args) {
        //内部类的调用，内部类名.外部类名.方法/属性或创建对象
        //Entry把集合中的键值对封装称为对象（整体）Entry<E,E>,
        //然后通过getKey和GetValue，获得键值和value值
        HashMap<String, String> map = new HashMap<String, String>();
        // put存储键值对,返回Value值
        map.put("yi", "123");
        map.put("er", "456");
        map.put("yi", "456");
        map.put("san", "789");
        //entry+增强for
        //获得Map.Entry<String,String>对象的Set集合
        //泛型可以为数据类型、对象、集合
        Set<Map.Entry<String,String>> set=map.entrySet();
        /*for(Map.Entry<String,String> s:set){//获得set集合中的每一个对象
            String s1=s.getKey();
            String s2=s.getValue();
            System.out.println(s1+"---"+s2);
        }*/
        //获取迭代器
        Iterator<Map.Entry<String,String>> i=set.iterator();
    while(i.hasNext()){
        //得到每一个Entry对象
        Map.Entry<String,String>  entry=i.next();
        String s1=entry.getKey();
        String s2=entry.getValue();
        System.out.println(entry);//默认调用Entry中的tostring()方法
        System.out.println(s1+"/"+s2);
    }
    }
}