20：Map集合

最新推荐文章于 2025-03-20 16:28:00 发布

原创最新推荐文章于 2025-03-20 16:28:00 发布 · 242 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

37 篇文章

订阅专栏

Map集合分支和Set List分支在同一层次上。
java.util
接口 Map<K,V>类型参数：K - 此映射所维护的键的类型V - 映射值的类型
public interface Map<K,V>
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
键不能重复，不同的键可以映射到相同的值；
此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。
××××××××××××××××××××××××××××××××××××××××××
Map集合特点：该集合存储键值对，一对一往里存，而且要保证键的唯一性。
1：添加
Vput(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。
voidputAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中（可选操作）。
2：删除
voidclear()
从此映射中移除所有映射关系（可选操作）。
Vremove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
3：判断
booleancontainsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。 booleancontainsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。

4：获取
Vget(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
intsize()
返回此映射中的键-值映射关系数。 Collection<V>values()
返回此映射中包含的值的 Collection 视图。

Set<Map.Entry<K,V>>entrySet()
返回此映射中包含的映射关系的 Set 视图。
Set<K>keySet()
返回此映射中包含的键的 Set 视图。
××××××××××××××××××××××××××××××××××××××××××
Map
|——Hashtable：底层是哈希表数据结构，不可以存入null键，null值；集合同步；《前期出现的，后期被HashMap取代 jdk1.0,效率低》
|——HashMap ：底层是哈希表数据结构，可以存入null键，null值；集合不同步；《jdk1.2效率高》
|——TreeMap ：底层是二叉树数据结构，线程不同步。可以用于给map中的键进行排序

Map集合和Set集合很像；
其实，Set底层就是使用Map集合。
××××××××××××××××××××××××××××××××××××××××××××××××××××
package tset1;

import java.util.*;

public class Demo {
public static void main(String[] args) {
Map<String ,String> map= new HashMap<String,String>();
map.put( “01”, “asdf”);
map.put( “02”, “asfasf”);
map.put( “03”, “afsdaasdfasdf”);
System. out.println( “contatinskey: “+ map.containsKey( “02”));
System. out.println( “remove: “+ map.remove( “02”));
System. out.println( map);
}
}
Collection<String> al= map.values();
System. out.println( al);
values()方法返回的是一个集合；
put方法：

将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的映射关系，则用指定值替换旧值（当且仅当 m.containsKey(k) 返回 true 时，才能说映射 m 包含键 k 的映射关系）。
返回：以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。（如果该实现支持 null 值，则返回 null 也可能表示此映射以前将 null 与 key 关联）。

map集合的两种取出方式：
1：keySet（）
Set<K> keySet()

返回此映射中包含的键的 Set 视图。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。set 支持元素移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。返回：此映射中包含的键的 set 视图
将Map中所有的键存入到Set集合。因为Set具备迭代器。所以可以用迭代方式取出所有的键，再根据get方法，获取键对应的值。
Map的取出原理：将map集合转换成set集合，通过迭代器取出。
package tset1;
import java.util.*;
public class Demo {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put( “01”, “asdf”);
map.put( “02”, “asfasf”);
map.put( “03”, “afsdaasdfasdf”);

        Set&lt;String> set = map.keySet();
         for (Iterator&lt;String> it = set.iterator(); it.hasNext();) {
              String s = it.next();
              System. out.println( map.get( s));
        }
  }

}
××××××××××××××××××××××××××××××××××××××××××××××××××××××××
2：
entrySet
public Set<Map.Entry<K,V>> entrySet()

返回此映射所包含的映射关系的 Set 视图。该 set 受映射支持，所以对映射的更改将反映在此 set 中，反之亦然。如果在对 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作，或者通过在该迭代器返回的映射项上执行 setValue 操作除外），则迭代结果是不确定的。该 set 支持元素的移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可从该映射中移除相应的映射关系。它不支持 add 或 addAll 操作。
返回：此映射所包含的映射关系的 set 视图。entrySet()方法返回的是map的键值对象关系；
在获取到键值对的关系集合之后，就可以通过集合的方法取出关系；通过关系的方法处理；java.util
接口 Map.Entry<K,V>
public static interface Map.Entry<K,V>
映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。
Map.Entry 其实Entry也是一个接口，它是Map接口的一个内部接口；
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
在接口中可以定义接口；
class HashMap implements Map
{

}

package tset1;
import java.util.*;
public class Demo {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put( “01”, “asdf”);
map.put( “02”, “asfasf”);
map.put( “03”, “afsdaasdfasdf”);

        Set&lt;Map.Entry&lt;String, String>> entry= map.entrySet();
         for(Iterator&lt;Map.Entry&lt;String, String>> it= entry.iterator(); it.hasNext();)
        {
              Map.Entry&lt;String, String> me= it.next();
              System. out.print( me.getKey()+ " :"+ me.getValue()+ '\t');
              System. out.println( me);
        }
         /*          Set&lt;String> set = map.keySet();
        for (Iterator&lt;String> it = set.iterator(); it.hasNext();) {
              String s = it.next();
              System.out.println(map.get(s));
        }*/
  }

}

TreeMap类型：
/*asdfghjkhjklqwerasdf
希望打印结果a(1)b(2)c(3)……..
题目分析：
发现每一个字母都对应次数；说明字母和次数之间有映射关系。
注意：当发现有映射关系时，可以选择map集合。因为map集合中存在映射关系

什么时候使用map集合？
当数据之间存在映射关系时，就要先想map集合。

第一次用a字母作为键去找集合，那么集合没有a键，所以也没有对应的次数，返回null，如果为null，就将a字母和1存入集合
如果指定的键已经存在，说明有对应的次数。就将对应的次数取出，并自增后重新存入集合。

思路：1：将字符串转换为字符数组。因为要对每一个字母进行操作。
2：定义一个map集合，因为打印字母是有序的，所以使用treeMap集合。
3：遍历字符数组
将每一个字母作为键去查map集合。
如果返回null，将该字母和1存入map集合中
返回不为null,说明该字母在map集合已经存在并有对应次数。
那么取次数自增，重新存入map集合中。
4：将map集合中的数据变成指定字符串形式返回。

*/
package tset1;
import java.util.*;

public class Demo {
public static void main(String[] args) {
System. out.println( charCount(“asdfas1234*&^% $#@$ %^&&**dfasdf”));
}
public static String charCount(String str)
{
char [] ch= str.toCharArray();
TreeMap<Character,Integer> tMap= new TreeMap<Character,Integer>();
int count=0;
for( int i=0; i< ch. length; i++)
{
if(!( ch[ i]>= ‘a’&& ch[ i]<= ‘z’|| ch[ i]>= ‘A’&& ch[ i]<= ‘Z’)) continue;
Integer value= tMap.get( ch[ i]);
if( value!= null) count= value;
count++;
tMap.put( ch[ i], count);
count=0;
/* Integer p=tMap.get( ch[i]);
if(p==null)tMap.put( ch[i], 1);
else{p++;tMap.put( ch[i], p);
}*/
}
StringBuilder sb= new StringBuilder();
Set<Map.Entry<Character, Integer>> entey= tMap.entrySet();
for(Iterator<Map.Entry<Character, Integer>> it= entey.iterator(); it.hasNext();)
{
Map.Entry<Character, Integer> me= it.next();
Character c= me.getKey();
Integer value= me.getValue();
sb.append( c+ “(“+ value+ “)”);
}
return sb.toString();
}
}
×××××××××××××××××××××××××××××××××××××××××××××××××
Map集合的扩展：
map集合被使用是因为具备映射关系；
集合嵌套的实现；