java-Map接口

2022-01-28 14:53 220阅读 0赞

**Map接口的概述和使用**

**-概述：public interface Map<K，V>**

**-特点：\*将****键映射到值的对象**

**            \*一个映射不能包含重复的键**

**            \*每个键最多只能映射到一个值**

**-Map接口和Collection接口的区别：**

**            \*Map时双列的，Collection是单列的**

**            \*Map的键是唯一的，Collection的子体系Set也是唯一的**

**            \*Map集合的数据结构只针对键有效，对值无关，Collection集合的数据结构只针对元素有效**

**-成员方法：**

**\*1.添加功能：**

**                         \*V put(K key,V value) ;         添加元素**

**                         \*如果键是第一次存储，就直接存储元素，返回null**

**                         \*如果不是第一次存在，就用值把之前的值覆盖掉，并返回以前的值**

**              \*2.删除功能：**

**                          \*void clear() ;         清空所有的键值对组合**

**                          \*V remove(object key) ;     根据键删除键值对元素，并把值返回**

**               \*3.判断功能：**

**                          \*bollean containsKey(object key) ；  判断集合是否包含指定的键**

**                          \*bollean containsValue(object value)； 查看集合是否包含指定的值**

**                          \*bollean isEmpty()；   判断集合是否为空**

**                 \*4.获取功能：**

**                          \*Set<Map.Entry<K,V>> entrySet() ；**

**                          \*V get(Object key)；    根据键获取值         V v = mp.get(key)；**

**                          \*Set<K> keySet()；     获取集合中所有键的集合，返回一个Set集合**

**                          \*Collection<V> values()    获取集合中所有值的集合，collection的泛型和map值的泛型一致****  collecton<V> c = mp.values()；**

**                  \*5.长度功能：**

**                           \*int size() ；         返回集合中键值对的个数**

**-Map集合的遍历：**

**         \*Map集合没有迭代器，不能使用Iterator来进行遍历**

**\*方法1：利用迭代器来遍历**

**            思路：1.首先获取集合中所有键的集合（map.keyset****  -- 返回一个set集合)**

**2.创建迭代器**

**                       3.利用while循环，使用get方法来根据键获取对应的值**

Set<String> key = mp.keySet();
    		//创建迭代器
    		Iterator<String> it = key.iterator();   
    		while(it.hasNext()){
    			//获取每一个键
    			String k = it.next();   
    			//根据键来获取值
    			Integer i = mp.get(k);
    			System.out.println(i);
    		}

**\*方法2：利用增强for循环**

for (String s : mp.keySet()) {        //mp.keyset()是所有键的集合
    			System.out.println(mp.get(s));
    		}

**\*方法3：键值对对象找键和值**

**              思路：1.获取所有键值对对象的集合**

**                         2.遍历键值对对象的集合，获取每一个键值对对象**

**                         3.根据键值对对象获取值**

//Map.Entry说明Entry是Map的内部接口，将键和值封装成了Entry对象，并保存在set集合中
    		Set<Map.Entry<String, Integer>> entries = map.entrySet();          
    		//获取迭代器
    		Iterator<Map.Entry<String, Integer>> it = entries.iterator();
    		while(it.hasNext()){
    			//获取每一个Entry对象
    			//Map.Entry<String, Integer> en = it.next();            //父类引用指向子类对象
    			Entry<String, Integer> en = it.next();                          //直接获取子类对象
    			String key = en.getKey();
    			Integer i = en.getValue();
    			System.out.println(key+"=" +i);
    		}

**\*方法4：利用增强for循环Entry对象**

for(Entry<String, Integer> en:map.entrySet()){
    			System.out.println(en.getKey()+"="+en.getValue());
    		}

**-存储自定义类**

HashMap<Student, String> hm = new HashMap<>();
    		hm.put(new Student("张三", 23), "北京");
    		hm.put(new Student("张三", 23), "上海");            //因为运用了哈希算法，所以自定义类需要重写hashCode()和equals()方法
    		hm.put(new Student("李四", 24), "广州");
    		hm.put(new Student("王五", 25), "深圳");
    		System.out.println(hm);

**-LinkedHashMap：怎么存怎么取（存取顺序一致）与LinkedHashSet差不多**

**-TreeMap：与TreeSet差不多**

**-范例：输入一个字符串，获得每一个字符出现的次数**

package Map;
    
    import java.util.Scanner;
    import java.util.TreeMap;
    
    public class demo8 {
    
    	public static void main(String[] args) {
    		//获取键盘输入对象
    		Scanner sc = new Scanner(System.in);
    		String str = sc.nextLine();
    		//将输入的字符串切割为字符数组
    		String[] arr = str.split("");
    		//创建TreeMap集合，key保存字符，value保存出现的次数
    		TreeMap<String, Integer> tm = new TreeMap<>();
    		//遍历字符数组
    		for (String s : arr) {
    			//设置初始次数为1
    			Integer value = 1;
    			//如果集合包含所遍历的字符，则value相加
    			if(tm.containsKey(s)){
    				value += tm.get(s);
    			}
    			//向集合中存储元素
    			tm.put(s, value);
    		}
    		//打印
    		System.out.println(tm);
    	}
    
    }
    //统计一个字符串各个字符出现了多少次

![20181221163150609.png][]

**-HashMap嵌套HashMap**

package Map;
    
    import java.util.HashMap;
    
    import Collection.Student;
    
    public class demo9 {
    
    	public static void main(String[] args) {
    		HashMap<HashMap<Student, String>, Integer> hm = new HashMap<>();
    	
    		HashMap<Student, String> hm1 = new HashMap<>();
    		hm1.put(new Student("张三",23), "北京");
    		hm1.put(new Student("李四",24), "南京");
    		hm1.put(new Student("王五",25), "东京");
    		HashMap<Student, String> hm2 = new HashMap<>();
    		hm2.put(new Student("德玛",23), "德玛西亚");
    		hm2.put(new Student("提莫",23), "班德尔城");
    		hm2.put(new Student("卡特",23), "诺克萨斯");
    		hm.put(hm1,222);
    		hm.put(hm2, 666);
    		//for循环遍历获得每一个HashMap集合对象
    		for(HashMap<Student, String> h : hm.keySet()){     
    			//通过键获取值
    			Integer value = hm.get(h);        
    			//遍历HashMap集合对象，获得学生信息
    			for (Student s : h.keySet()) {
    				String value1 = h.get(s);
    				System.out.println(s + " " + value1 + " " + value);
    			}
    		}
    	}
    }

![20181221183450247.png][]

**-HashMap和Hashtable的区别：**

**       \*1.** **Hashtable是JDK1.0版本出现的,是线程安全的,效率低**

**            HashMap是JDK1.2版本出现的,是线程不安全的,效率高**

**       \*2.Hashtable不可以存储null键和null值**

**               HashMap可以存储null键和null值**

**86. Collections类的概述和常用方法**

**   public static <T> void sort(List<T> list)         //对所选集合进行排序  
        public static <T> int binarySearch(List<?> list,T key)       //返回二分查找所选元素的索引  
        public static <T> T max(Collection<?> coll)      //返回集合中最大的元素  
        public static void reverse(List<?> list)              //集合倒序  
        public static void shuffle(List<?> list)                //随机置换集合元素（随机排列）**

**87.集合总结**

**1.Collection（单列集合）**

**       List（存取有序，有索引，可以重复）**

**              ArrayList(底层是数组实现的，线程不安全，查找和修改快，增删慢)**

**              LinkedList(底层是链表实现的，线程不安全，增删快，查找和修改慢)**

**              Vector(底层是数组实现的，线程安全，无论增删改查都慢)**

**               \*如果查找和修改多，用ArrayList**

**               \*如果增加和删除多，用LinkedList**

**               \*如果都多，用ArrayList**

**       Set（存取无序，无索引，不可以重复）**

**              HashSet(底层是哈希算法实现的)**

**                    LinkedHashSet（底层是链表实现的，但是也可以保证元素唯一，和HashSet原理一样）**

**              TreeSet(底层是二叉树实现的)**

**\*一般开发的时候不需要对存储的元素进行排序，所以开发时一般使用HashSet，HashSet的效率比较高**

**               \*TreeSet一般在面试的时候多用，问有几种排序方式，几种排序方式的区别**

**2.Map（双列集合）**

**         HashMap（底层是哈希算法实现的，针对键）**

**              LinkedHashMap(底层是链表，针对键)**

**         TreeMap（底层是二叉树实现的，针对键）**

**          \*开发中多用HashMap**

[20181221163150609.png]: /images/20220128/3b45b6d3e13a42fb994adbce4e136411.png
[20181221183450247.png]: /images/20220128/6e80269771164de38508f1d07c011f4f.png