映射

 

映射MAP(K,V)

 

　　K ------键

　　V -----值

　　一个键对应一个值，一个值可能对应多个键

　　一个值和一个键对应一个键值对，映射就是由多个键值对组成

 

把键值对抽取成了一个类，Map.Entry<K,V> ，这个类所创建的就代表键值对，映射就由多个Map.Entry<K,V> 组成。

映射是集合？ ---------- 不是，它两没有直接关系，映射是属于java集合类框架的一员

 

HashMap:底层有数组+链式栈结构实现的，可以存储null键和null值，默认的初始容量为16.默认的加载因子为0.75f，可以指定初始容量值，是异步式线程不安全的映射。默认扩容是扩大一倍

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class MapDemo {
    public static void main(String[] args) {
​
        //创建一个映射对象
        Map<String, Integer> m = new HashMap<>();
        //添加元素
        m.put("A", 2);
        m.put("A", 9);      //键不能重复，如果键重复就会覆盖原来的值
                            //值可以对应多个键
                            //不能保证数据存入的顺序
        m.put("c", 3);
        m.put("e", 4);
        m.put("D", 5);
        m.put("d", 6);
        
        //输出
        System.out.println(m);      //{A=9, c=3, D=5, d=6, e=4}
        //判断是否包含键
        System.out.println(m.containsKey("A"));     //true
        //判断是否包含值
        System.out.println(m.containsValue(10));    //false
        //根据键，返回值，如果键不存在就返回null
        //如果返回值是null，不能判定键不存在
        System.out.println(m.get("A"));             // 9
        
        //把映射的键放入到Set集合中
        Set<String> set = m.keySet();
        for(String str:set){
            System.out.println(str);
        }
        
        //根据key进行删除键值对，如果没有找到对应的键就不删
        m.remove("d");
        System.out.println(m);  // {A=9, c=3, D=5, e=4}
        
        //根据key，value对键值对进行删除。
        m.remove("c", 3);
        System.out.println(m);  // {A=9, D=5, e=4}
        
        //将映射中所有的值，放入到集合中
        Collection<Integer> c = m.values();
        for(Integer in:c){
            System.out.println(in);     // 9 5 4
        }
    }
}

 

遍历映射

　　根据键获取值（通过keySet获取所有的键放到一个Set集合中）

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
​
public class MapDemo {
    public static void main(String[] args) {
​
        //创建一个映射对象
        Map<String, Integer> m = new HashMap<>();
        //添加元素
        m.put("A", 2);
        m.put("c", 3);
        m.put("e", 4);
        m.put("D", 5);
        m.put("d", 6);
        
        //遍历映射
        //1.先遍历键，再遍历值
        //把所有的键放入到集合中
        Set<String> s = m.keySet();
        
        //遍历键
        Iterator<String> in = s.iterator();
        
        //
        while(in.hasNext()){
            // 获取键
            String key = in.next();
            // 输出
            System.out.println(key+"="+key);
        }
    }
}

 

获取键值对，在获取其中的键和值（通过entrySet获取到所有的键值对）

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
​
import javax.swing.text.html.parser.Entity;
​
public class MapDemo {
    public static void main(String[] args) {
​
        //创建一个映射对象
        Map<String, Integer> m = new HashMap<>();
        //添加元素
        m.put("A", 2);
        m.put("c", 3);
        m.put("e", 4);
        m.put("D", 5);
        m.put("d", 6);
    
        //遍历映射
        //获取键值对
        Set<Map.Entry<String,Integer>> s =  m.entrySet();
        
        Iterator<Entry<String, Integer>> in = s.iterator();
        //遍历键值对
        while(in.hasNext()){
            //
            Entry<String,Integer> e = in.next();
            System.out.println(e.getKey()+"="+e.getValue());
        }
        
        
//      for(Entry<String,Integer> e : s){
//          System.out.println(e.getKey()+"="+e.getValue());
//      }
        
        for (Entry<String, Integer> e:m.entrySet()) {
            System.out.println(e.getKey()+"="+e.getValue());
        }
    }
}

 

 

练习：通过映射一个字符串中所有的字符出现的次数

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
​
​
/*
 * 通过映射一个字符串中所有的字符出现的次数
 */
public class MapDemo {
    public static void main(String[] args) {
        String str = new Scanner(System.in).nextLine();
        
        //
        Map<String,Integer> map = new HashMap<>();
        //
        for(int i=0;i<str.length();i++){
            //
            char c = str.charAt(i);
            //判断这个字符在映射中的键是否出现过
            if(map.containsKey(c)){
                //如果拿到了这个键就表明这个字符重复出现了
                map.put(c+"", map.get(c+"")+1);
            }else{
                map.put(c+"", 1);
            }
            
        }
        
        for (Entry<String, Integer> e:map.entrySet()) {
            System.out.println(e.getKey()+"="+e.getValue());
        }
    }
}

 

 

HashTable：不能存储null键和null值，默认初始容量为11，加载因子0.75f。默认扩容是扩大一倍再加1，可以指定初始容量，制定了多少容量就是多少。

　　HashTable是同步式，线程安全的映射。