java中的Map

最新推荐文章于 2024-06-18 10:52:15 发布
最新推荐文章于 2024-06-18 10:52:15 发布
阅读量397 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mercuriooo/article/details/100512029
版权

Maps:
HashMap
TreeMap,
LinkedHashMap,
WeakHashMap,
ConcurrentHashMap,
IdentityHashMap.
区别表现在
efficiency
the order in which the pairs are held and presented
how long the objects are held by the map
how the map works in multithreaded programs
how key equality is determined.

性能

HashMap使用了特殊的值,叫做散列码
hashCode()是根类Object中的方法,所有的java对象都能产生散列码
在这里插入图片描述

//: containers/Maps.java
// Things you can do with Maps.
import java.util.concurrent.*;
import java.util.*;
import net.mindview.util.*;
import static net.mindview.util.Print.*;
public class Maps {
  public static void printKeys(Map<Integer,String> map) {
    printnb("Size = " + map.size() + ", ");
    printnb("Keys: ");
    print(map.keySet()); // Produce a Set of the keys
  }
  public static void test(Map<Integer,String> map) {
    print(map.getClass().getSimpleName());
    map.putAll(new CountingMapData(25)); 					 /***输出所有的键值对*****/
    // Map has ‘Set’ behavior for keys:
    map.putAll(new CountingMapData(25));
    printKeys(map);
    // Producing a Collection of the values:
    printnb("Values: ");
    print(map.values());
    print(map);
    print("map.containsKey(11): " + map.containsKey(11));	/***是否包含key*****/
    print("map.get(11): " + map.get(11));					/***key所对应的value****/
    print("map.containsValue(\"F0\"): "
      + map.containsValue("F0"));							/***是否包含某个value*****/
    Integer key = map.keySet().iterator().next();			/***keySet可以返回所有的key值*****/
    print("First key in map: " + key);
    map.remove(key);										/***删除key***/
    printKeys(map);
    map.clear();
    print("map.isEmpty(): " + map.isEmpty());
    map.putAll(new CountingMapData(25));
    // Operations on the Set change the Map:
    map.keySet().removeAll(map.keySet());					/***删除所有的键值对*****/
    print("map.isEmpty(): " + map.isEmpty());
  }
  public static void main(String[] args) {
    test(new HashMap<Integer,String>());
    test(new TreeMap<Integer,String>());
    test(new LinkedHashMap<Integer,String>());
    test(new IdentityHashMap<Integer,String>());
    test(new ConcurrentHashMap<Integer,String>());
    test(new WeakHashMap<Integer,String>());
  }
} /* Output:
HashMap
Size = 25, Keys: [15, 8, 23, 16, 7, 22, 9, 21, 6, 1, 14, 24, 4, 19, 11,
18, 3, 12, 17, 2, 13, 20, 10, 5, 0]
Values: [P0, I0, X0, Q0, H0, W0, J0, V0, G0, B0, O0, Y0, E0, T0, L0, S0,
D0, M0, R0, C0, N0, U0, K0, F0, A0]
{15=P0, 8=I0, 23=X0, 16=Q0, 7=H0, 22=W0, 9=J0, 21=V0, 6=G0, 1=B0, 14=O0,
24=Y0, 4=E0, 19=T0, 11=L0, 18=S0, 3=D0, 12=M0, 17=R0, 2=C0, 13=N0,
20=U0, 10=K0, 5=F0, 0=A0}
map.containsKey(11): true
map.get(11): L0
map.containsValue("F0"): true
First key in map: 15
Size = 24, Keys: [8, 23, 16, 7, 22, 9, 21, 6, 1, 14, 24, 4, 19, 11, 18,
3, 12, 17, 2, 13, 20, 10, 5, 0]
map.isEmpty(): true
map.isEmpty(): true
...
*///:~

sortedMap

在这里插入图片描述
Comparator comparator( ): Produces the comparator used for this Map, or null for natural ordering.
T firstKey( ): Produces the lowest key.
T lastKey( ): Produces the highest key.
SortedMap subMap(fromKey, toKey): Produces a view of this Map with keys from fromKey, inclusive, to toKey, exclusive.
SortedMap headMap(toKey): Produces a view of this Map with keys less than toKey.
SortedMap tailMap(fromKey): Produces a view of this Map with keys greater than or equal to fromKey.

//: containers/SortedMapDemo.java
// What you can do with a TreeMap.
import java.util.*;
import net.mindview.util.*;
import static net.mindview.util.Print.*;
public class SortedMapDemo {
  public static void main(String[] args) {
    TreeMap<Integer,String> sortedMap =
      new TreeMap<Integer,String>(new CountingMapData(10));
    print(sortedMap);
    Integer low = sortedMap.firstKey();
    Integer high = sortedMap.lastKey();
    print(low);
    print(high);
    Iterator<Integer> it = sortedMap.keySet().iterator();
    for(int i = 0; i <= 6; i++) {
        if(i == 3) low = it.next();
        if(i == 6) high = it.next();
    	else it.next();
    }
    print(low);
    print(high);
    print(sortedMap.subMap(low, high));
    print(sortedMap.headMap(high));
    print(sortedMap.tailMap(low));
  }
} /* Output:
{0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0}
0
9
3
7
{3=D0, 4=E0, 5=F0, 6=G0}
{0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0}
{3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0}
*///:~

LinkedHashMap

在这里插入图片描述

//: containers/LinkedHashMapDemo.java
// What you can do with a LinkedHashMap.
import java.util.*;
import net.mindview.util.*;
import static net.mindview.util.Print.*;
public class LinkedHashMapDemo {
  public static void main(String[] args) {
    LinkedHashMap<Integer,String> linkedMap =
      new LinkedHashMap<Integer,String>(
        new CountingMapData(9));
    print(linkedMap);
    // 最小使用的次数
    linkedMap =
      new LinkedHashMap<Integer,String>(16, 0.75f, true);  //不知道这里怎么弄出来的
    linkedMap.putAll(new CountingMapData(9));
    print(linkedMap);
    for(int i = 0; i < 6; i++) //对前面六个元素进行访问
      linkedMap.get(i);
    print(linkedMap);//这里0~5就被挪到数组的后面去了
    linkedMap.get(0);//再访问一下0
    print(linkedMap);//0又被挪到数组的末尾去了
  }
} /* Output:
{0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0}
{0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0}
{6=G0, 7=H0, 8=I0, 0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0}
{6=G0, 7=H0, 8=I0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 0=A0}
*///:~

Hashing and hash code

这里有个bruce版超长代码来说明

  • 如果是自己的类,继承于基类object,生成散列码的时候就会使用object的hashCode方法生成散列码,而它默认是使用对象的地址计算散列码的
    所以要写hashCode的覆盖版本
  • HashMap使用equals判断当前的键是否与表中存在的键相同
    所以也要override equals()方法

在这里插入图片描述

这里是很(lan)详(de)细(kan)的代码

//: containers/Groundhog.java
    // Looks plausible, but doesn’t work as a HashMap key.
    public class Groundhog {
      protected int number;
      public Groundhog(int n) { number = n; }
      public String toString() {
        return "Groundhog #" + number;
      }
} ///:~
    //: containers/Prediction.java
    // Predicting the weather with groundhogs.
    import java.util.*;
    public class Prediction {
      private static Random rand = new Random(47);
      private boolean shadow = rand.nextDouble() > 0.5;
      public String toString() {
        if(shadow)
          return "Six more weeks of Winter!";
        else
          return "Early Spring!";
}
} ///:~
    //: containers/SpringDetector.java
    // What will the weather be?
    import java.lang.reflect.*;
    import java.util.*;
    import static net.mindview.util.Print.*;
    public class SpringDetector {
      // Uses a Groundhog or class derived from Groundhog:
      public static <T extends Groundhog>
      void detectSpring(Class<T> type) throws Exception {
        Constructor<T> ghog = type.getConstructor(int.class);
        Map<Groundhog,Prediction> map =
          new HashMap<Groundhog,Prediction>();
        for(int i = 0; i < 10; i++)
          map.put(ghog.newInstance(i), new Prediction());
        print("map = " + map);
        Groundhog gh = ghog.newInstance(3);
        print("Looking up prediction for " + gh);
        if(map.containsKey(gh))
          print(map.get(gh));
        else
          print("Key not found: " + gh);
      }
      public static void main(String[] args) throws Exception {
        detectSpring(Groundhog.class);
         }
} /* Output:
map = {Groundhog #3=Early Spring!, Groundhog #7=Early Spring!, Groundhog
#5=Early Spring!, Groundhog #9=Six more weeks of Winter!, Groundhog
#8=Six more weeks of Winter!, Groundhog #0=Six more weeks of Winter!,
Groundhog #6=Early Spring!, Groundhog #4=Six more weeks of Winter!,
Groundhog #1=Six more weeks of Winter!, Groundhog #2=Early Spring!}
Looking up prediction for Groundhog #3
Key not found: Groundhog #3
*///:~

// A class that’s used as a key in a HashMap
// must override hashCode() and equals().
public class Groundhog2 extends Groundhog {
  public Groundhog2(int n) { super(n); }
  public int hashCode() { return number; }
  public boolean equals(Object o) {
    return o instanceof Groundhog2 &&
      (number == ((Groundhog2)o).number);
}
} ///:~
//: containers/SpringDetector2.java
// A working key.
public class SpringDetector2 {
  public static void main(String[] args) throws Exception {
    SpringDetector.detectSpring(Groundhog2.class);
  }
} /* Output:
map = {Groundhog #2=Early Spring!, Groundhog #4=Six more weeks of
Winter!, Groundhog #9=Six more weeks of Winter!, Groundhog #8=Six more
weeks of Winter!, Groundhog #6=Early Spring!, Groundhog #1=Six more
weeks of Winter!, Groundhog #3=Early Spring!, Groundhog #7=Early
Spring!, Groundhog #5=Early Spring!, Groundhog #0=Six more weeks of
Winter!}
Looking up prediction for Groundhog #3
Early Spring!
*///:~

反正我觉得重点就这一点点
在这里插入图片描述
还有这一点点
在这里插入图片描述
hashingCode其实就是唯一表示key的东西,类似于id嘛

理解hashCode()

–这里是被省略的超长代码containers/SlowMap.java–
在这里插入图片描述
在这里插入图片描述
–被省略的container/MapEntry.java–
在这里插入图片描述
(不听不听?bruce念经)
(等我需要自己定义的时候再仔细看…)

为速度而散列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

覆盖hashCode()

在这里插入图片描述
在这里插入图片描述
关于如何生成散列码
在这里插入图片描述
(哈这一节终于完了!)

Mercuriooo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈java中Map的用法
09-03
1. **键值对（Key-Value Pair）**：在Map中，数据是以键值对的形式存储的，键（Key）用于唯一标识一个值（Value）。键必须是唯一的，不允许有重复，而值可以重复出现，但同一个键对应的值只能有一个。 2. **`put()`...
Java中map遍历方式的选择问题详解
08-29
Java中map遍历方式的选择问题详解 在 Java 编程中，Map 是一个常用的数据结构，但是当我们需要遍历 Map 中的元素时，常见的遍历方式有多种，包括使用 keySet、entrySet 和 values 等方法。那么，在 Java 中 map ...
Java中操作Map集合时：使用Map.of()添加数据报错 java.lang.UnsupportedOperationException 解决办法以及注意事项
最新发布
weixin_43860634的博客
06-18 1090
Java8操作Map集合时：使用Map.of()添加数据报错 java.lang.UnsupportedOperationException 解决办法以及注意事项
Java中Map详解
m0_67391377的博客
04-03 2万+
用法 Map:java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 本文主要介绍java map的初始化、用法、map的两种常用的遍历方式。 map存放值的时候通过put存放，如果key值相等的话会把之前存放的值覆盖。 查找、删除、修改通过key值进行操作。 下面是HashMap存放值的操作。 HashMap<Integer,Doub
详解Java中Map用法
m0_54849873的博客
04-29 7171
转载：http://blog.csdn.net/guomutian911/article/details/45771621 Map以按键/数值对的形式存储数据，这里要特别说明（Map.Entry，是Map的内部类，它用来描述Map中的键/值对）。Map是一个接口，我们平时多用它的实现类HashMap。 用例如下： [java] view plain copy publicstaticvoidmain(Stringargs[]) { HashMaphashmap=newHashMap(); hashmap.
Java 中Map四种取值方式
于歌852的标题
05-09 6255
map的主要作用是什么？ 可以通过创建一个map的实现类 来存放 数据 值 和值的描述 也可以通过描述去取得数据 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。 Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一
java中Map的用法
ambiyou的博客
05-28 1万+
Map是java中的接口，Map.Entry是Map的一个内部接口。 Map提供了一些常用方法，如keySet()、entrySet()等方法。 keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。 Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。 Map<Stri
Java中的Map
bigBbug的博客
01-12 2万+
Java中Map的一些方法介绍
Java中Map.Entry详解
热门推荐
Java硬件工程师的博客
02-08 3万+
关于HashMap的详细介绍请参考Java基础-HashMap集合 1.Map.Entry简介 Map是java中的接口，Map.Entry是Map的一个内部接口。 Map提供了一些常用方法，如keySet()、entrySet()等方法，keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。 Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个k
Java中Map的用法整理
雪岩的博客
03-12 8273
一、HashMap 常用函数： 添加功能 V put(K key,V value):添加元素。这个其实还有另一个功能 如果键是第一次存储，就直接存储元素，返回null 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值 删除功能 void clear():移除所有的键值对元素 V remove(Object key)：根据键删除键值对元素，并把值返回 判断功能 boolean containsKey(Object key)：判断集合是否包含指定的键 boolean containsValue(Obj
java中Map 和 HashMap 的区别
独断万码
09-07 4391
java中Map 和 HashMap 的区别
Java 中map和list
weixin_43887870的博客
08-02 3162
map和list 1、List（有序、可重复） List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。 2、Set（无序、不能重复） Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。 3、Map（键值对、键唯一、值不唯一） Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键.
Java中Map的用法详解
09-02
Java中的`Map`接口是Java集合框架的重要组成部分，它提供了键值对的存储方式，使得可以通过键来查找对应的值。`Map`接口替代了早期的`Dictionary`类，因为它是作为一个接口存在，允许不同的实现方式，如`HashMap`, `...
java中map集合的用法.doc
05-09
使用`put()`方法将键值对放入Map中，如： ```java map.put("sa", "dd"); ``` 3. **获取值**： 通过键来获取对应的值，可以使用`get()`方法： ```java String str = map.get("sa").toString(); ``` 4. **...
JavaScript实现Java中Map容器的方法
10-21
主要介绍了JavaScript实现Java中Map容器的方法,结合实例形式分析了JavaScript实现Java中Map容器的原理与相关实现技巧,需要的朋友可以参考下
int []数组和ArrayList<Integer>的相互转换
Mercuriooo的博客
11-25 1977
今天用java写leetcode46的时候,只是想把一个数组转换为ArrayList… 我尝试着这么做: ArrayList<Integer> list = Arrays.asList(nums); 但是一直报错告诉我类型不符合 我搜了一下发现string就可以这么做! 图片来自这里 想了一下觉得大概是对象和基本类型的区别: 这里????的圈圈内容是相同的 可是在int数组和ArrayL...
java中的Set和SortedSet
Mercuriooo的博客
09-03 1777
The asterisk on HashSet indicates that, in the absence of other constraints, this should be your default choice because it is optimized for speed. 对hashCode( )的定义在后面 对hashed & tree必须写 equals( )方...
java连接数据库错误总结
Mercuriooo的博客
05-15 891
之前听课一直都是看着老师操作，今天想试着用一下clob，从头到尾写了一遍，结果编译的时候各种报错 总结一下各种错误 No suitable driver found for jdbc:mysql//127.0.0.1:3306/test private static final String URL = "jdbc:mysql//127.0.0.1:3306/test" 少了一个冒号
java中map
05-25
Map是Java中的一种数据结构，它是一种键值对的集合，每个键映射到一个值。Map中的键和值都可以是任何类型，但键必须是唯一的。 在Java中，Map是一个接口，有许多不同的实现类，比如HashMap、TreeMap、LinkedHashMap等。其中，HashMap是最常用的实现类，它提供了快速的查找和插入操作，但是不保证元素的顺序。而TreeMap则按照键的自然顺序进行排序，而LinkedHashMap则按照元素的插入顺序进行排序。 下面是一个简单的示例，展示如何使用HashMap存储键值对： ```java import java.util.HashMap; import java.util.Map; public class MapExample { public static void main(String[] args) { Map<String, Integer> map = new HashMap<>(); map.put("Alice", 25); map.put("Bob", 30); map.put("Charlie", 35); System.out.println(map.get("Bob")); // 输出 30 System.out.println(map.containsKey("Dave")); // 输出 false for (String key : map.keySet()) { System.out.println(key + ": " + map.get(key)); } } } ``` 上述示例中，我们创建了一个HashMap对象，并向其中存储了三个键值对。然后，我们通过get方法获取了其中的一个元素，并使用containsKey方法判断了是否存在某个键。最后，我们使用for循环遍历了所有的键，并输出了对应的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值