Android map研究

已于 2022-08-01 10:50:04 修改
阅读量489 收藏
点赞数
分类专栏： java 多线程 android 文章标签： android java 开发语言
于 2022-07-17 09:58:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42015021/article/details/125828584
版权
android 同时被 3 个专栏收录
145 篇文章 2 订阅
订阅专栏
java
82 篇文章 1 订阅
订阅专栏
多线程
3 篇文章 0 订阅
订阅专栏

单线程存放10000条数据，hashMap、ConcurrentHashMap、hashMap + synchronized耗时分析

public class MainActivity extends AppCompatActivity {
    private String TAG = "MapTest";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                return thread;
            }
        };
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 5, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>(2),
                factory, new ThreadPoolExecutor.AbortPolicy());

        executor.execute(new Runnable() {
            @Override
            public void run() {
                HashMap<String, String> hashMap = new HashMap<>();
                long hashMapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    hashMap.put(Thread.currentThread().getName() + "-" +i,Thread.currentThread().getName() + "-" +i);
                }
                long hashMapEndTime = System.currentTimeMillis();
                Log.e(TAG, "hashMap put "+ hashMap.size()+" values cost time: " + (hashMapEndTime - hashMapStartTime));
            }
        });


        executor.execute(new Runnable() {
            @Override
            public void run() {
                ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<String,String>();
                long mapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    concurrentHashMap.put(Thread.currentThread().getName() + "-" +i,Thread.currentThread().getName() + "-" +i);
                }
                long mapEndTime = System.currentTimeMillis();
                Log.e(TAG, "concurrentHashMap put "+ concurrentHashMap.size()+" values cost time: " + (mapEndTime - mapStartTime));
            }
        });

        Object o = new Object();
        // hashMap + synchronized 锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                HashMap<String, String> hashMap = new HashMap<>();
                long hashMapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    synchronized (o){
                        hashMap.put(Thread.currentThread().getName() + "-" +i,Thread.currentThread().getName() + "-" +i);
                    }
                }
                long hashMapEndTime = System.currentTimeMillis();
                Log.e(TAG, "hashMap + synchronized put "+ hashMap.size()+" values cost time: " + (hashMapEndTime - hashMapStartTime));

            }
        });

    }
}

耗时结果：

2022-07-17 09:43:54.950 5497-5526/com.example.myapplication E/MapTest: hashMap + synchronized put 10000 values cost time: 140
2022-07-17 09:43:54.952 5497-5524/com.example.myapplication E/MapTest: hashMap put 10000 values cost time: 144
2022-07-17 09:43:54.953 5497-5525/com.example.myapplication E/MapTest: concurrentHashMap put 10000 values cost time: 144

三线程存放30000条数据，每个线程存放10000数据、hashMap、ConcurrentHashMap、hashMap + synchronized耗时分析

public class MainActivity2 extends AppCompatActivity {
    private String TAG = "MapTest";
    private HashMap<String, String> hashMap;
    private ConcurrentHashMap<String, String> concurrentHashMap;
    private long mapStartTime;
    private long hashMapStartTime;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);


        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                return thread;
            }
        };
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 5, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>(2),
                factory, new ThreadPoolExecutor.AbortPolicy());


        hashMap = new HashMap<>();
        hashMapStartTime = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        hashMap.put(Thread.currentThread().getName() + "-" + j, Thread.currentThread().getName() + "-" + j);
                    }
                    long hashMapEndTime = System.currentTimeMillis();
                    Log.e(TAG, "hashMap put " + hashMap.size() + " values cost time: " + (hashMapEndTime - hashMapStartTime));
                }
            });
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        concurrentHashMap = new ConcurrentHashMap<String,String>();
        mapStartTime = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        concurrentHashMap.put(Thread.currentThread().getName() + "-" + j, Thread.currentThread().getName() + "-" + j);
                    }
                    long mapEndTime = System.currentTimeMillis();
                    Log.e(TAG, "concurrentHashMap put " + concurrentHashMap.size() + " values cost time: " + (mapEndTime - mapStartTime));
                }
            });
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Object o = new Object();
        hashMap = new HashMap<>();
        hashMapStartTime = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        synchronized (o){
                            hashMap.put(Thread.currentThread().getName() + "-" + j, Thread.currentThread().getName() + "-" + j);
                        }
                    }
                    long hashMapEndTime = System.currentTimeMillis();
                    Log.e(TAG, "hashMap + synchronized put " + hashMap.size() + " values cost time: " + (hashMapEndTime - hashMapStartTime));
                }
            });
        }


    }
}

2022-07-17 09:55:06.863 6155-6182/com.example.myapplication E/MapTest: hashMap put 27663 values cost time: 72
2022-07-17 09:55:06.864 6155-6183/com.example.myapplication E/MapTest: hashMap put 28057 values cost time: 73
2022-07-17 09:55:06.866 6155-6184/com.example.myapplication E/MapTest: hashMap put 29205 values cost time: 74
2022-07-17 09:55:07.853 6155-6185/com.example.myapplication E/MapTest: concurrentHashMap put 22030 values cost time: 59
2022-07-17 09:55:07.872 6155-6183/com.example.myapplication E/MapTest: concurrentHashMap put 29407 values cost time: 78
2022-07-17 09:55:07.873 6155-6182/com.example.myapplication E/MapTest: concurrentHashMap put 30000 values cost time: 78
2022-07-17 09:55:08.932 6155-6186/com.example.myapplication E/MapTest: hashMap + synchronized put 28818 values cost time: 135
2022-07-17 09:55:08.932 6155-6184/com.example.myapplication E/MapTest: hashMap + synchronized put 29086 values cost time: 136
2022-07-17 09:55:08.934 6155-6185/com.example.myapplication E/MapTest: hashMap + synchronized put 30000 values cost time: 138

第一组是对比concurrentHashMap、hashMap + synchronized中存放10000个数据的耗时：
第二组是对比hashMap、concurrentHashMap、hashMap + synchronized覆盖数据量大小为10的map中的某一个key_value 10000次的耗时结果：
第三组是对比hashMap、concurrentHashMap、hashMap + synchronized分别使用三个线程存放数据，每个线程存储10000条数据的耗时结果：

public class MainActivity extends AppCompatActivity {
    private String TAG = "MapTest";
    private HashMap hashMap;
    private long hashMapStartTime;
    private ConcurrentHashMap concurrentHashMap;
    private long mapStartTime;
    private Object o = new Object();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                return thread;
            }
        };
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 5, 4, TimeUnit.SECONDS, new LinkedBlockingDeque<>(2),
                factory, new ThreadPoolExecutor.AbortPolicy());

        executor.execute(new Runnable() {
            @Override
            public void run() {
                HashMap<String, String> hashMap = new HashMap<>();
                long hashMapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    hashMap.put(Thread.currentThread().getName() + "-" + i, Thread.currentThread().getName() + "-" + i);
                }
                long hashMapEndTime = System.currentTimeMillis();
                Log.e(TAG, "hashMap put " + hashMap.size() + " values cost time: " + (hashMapEndTime - hashMapStartTime));
            }
        });


        executor.execute(new Runnable() {
            @Override
            public void run() {
                ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<String, String>();
                long mapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    concurrentHashMap.put(Thread.currentThread().getName() + "-" + i, Thread.currentThread().getName() + "-" + i);
                }
                long mapEndTime = System.currentTimeMillis();
                Log.e(TAG, "concurrentHashMap put " + concurrentHashMap.size() + " values cost time: " + (mapEndTime - mapStartTime));
            }
        });

        // hashMap + synchronized 锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                HashMap<String, String> hashMap = new HashMap<>();
                long hashMapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    synchronized (o) {
                        hashMap.put(Thread.currentThread().getName() + "-" + i, Thread.currentThread().getName() + "-" + i);
                    }
                }
                long hashMapEndTime = System.currentTimeMillis();
                Log.e(TAG, "hashMap + synchronized put " + hashMap.size() + " values cost time: " + (hashMapEndTime - hashMapStartTime));

            }
        });

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        executor.execute(new Runnable() {
            @Override
            public void run() {
                HashMap<String, String> hashMap = new HashMap<>();
                hashMap.put("1", "1");
                hashMap.put("2", "1");
                hashMap.put("3", "1");
                hashMap.put("4", "1");
                hashMap.put("5", "1");
                hashMap.put("6", "1");
                hashMap.put("7", "1");
                hashMap.put("8", "1");
                hashMap.put("9", "1");
                hashMap.put("10", "1");
                long hashMapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    hashMap.put("1", "1");
                }
                long hashMapEndTime = System.currentTimeMillis();
                Log.e(TAG, "hashMap overWrite " + 10000 + " times cost time: " + (hashMapEndTime - hashMapStartTime));
            }
        });


        executor.execute(new Runnable() {
            @Override
            public void run() {
                ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<String, String>();
                concurrentHashMap.put("1", "1");
                concurrentHashMap.put("2", "1");
                concurrentHashMap.put("3", "1");
                concurrentHashMap.put("4", "1");
                concurrentHashMap.put("5", "1");
                concurrentHashMap.put("6", "1");
                concurrentHashMap.put("7", "1");
                concurrentHashMap.put("8", "1");
                concurrentHashMap.put("9", "1");
                concurrentHashMap.put("10", "1");
                long mapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    concurrentHashMap.put("1", "1");
                }
                long mapEndTime = System.currentTimeMillis();
                Log.e(TAG, "concurrentHashMap overWrite " + 10000 + " times cost time: " + (mapEndTime - mapStartTime));
            }
        });

        // hashMap + synchronized 锁
        executor.execute(new Runnable() {
            @Override
            public void run() {
                HashMap<String, String> hashMap = new HashMap<>();
                hashMap.put("1", "1");
                hashMap.put("2", "1");
                hashMap.put("3", "1");
                hashMap.put("4", "1");
                hashMap.put("5", "1");
                hashMap.put("6", "1");
                hashMap.put("7", "1");
                hashMap.put("8", "1");
                hashMap.put("9", "1");
                hashMap.put("10", "1");
                long hashMapStartTime = System.currentTimeMillis();
                for (int i = 0; i < 10000; i++) {
                    synchronized (o) {
                        hashMap.put("1", "1");
                    }
                }
                long hashMapEndTime = System.currentTimeMillis();
                Log.e(TAG, "hashMap + synchronized overWrite " + 10000 + " times cost time: " + (hashMapEndTime - hashMapStartTime));

            }
        });


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        concurrentHashMap = new ConcurrentHashMap<String, String>();
        mapStartTime = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        concurrentHashMap.put(Thread.currentThread().getName() + "-" + j, Thread.currentThread().getName() + "-" + j);
                    }
                    long mapEndTime = System.currentTimeMillis();
                    Log.e(TAG, "concurrentHashMap put " + concurrentHashMap.size() + " values cost time: " + (mapEndTime - mapStartTime));
                }
            });
        }


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        hashMap = new HashMap<String, String>();
        hashMapStartTime = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        hashMap.put(Thread.currentThread().getName() + "-" + j, Thread.currentThread().getName() + "-" + j);
                    }
                    long hashMapEndTime = System.currentTimeMillis();
                    Log.e(TAG, "hashMap put " + hashMap.size() + " values cost time: " + (hashMapEndTime - hashMapStartTime));
                }
            });
        }


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        hashMap = new HashMap<>();
        hashMapStartTime = System.currentTimeMillis();
        for (int i = 0; i < 3; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        synchronized (o) {
                            hashMap.put(Thread.currentThread().getName() + "-" + j, Thread.currentThread().getName() + "-" + j);
                        }
                    }
                    long hashMapEndTime = System.currentTimeMillis();
                    Log.e(TAG, "hashMap + synchronized put " + hashMap.size() + " values cost time: " + (hashMapEndTime - hashMapStartTime));
                }
            });
        }

    }
}

2022-07-17 10:14:33.144 7277-7304/? E/MapTest: concurrentHashMap put 10000 values cost time: 103
2022-07-17 10:14:33.153 7277-7303/? E/MapTest: hashMap put 10000 values cost time: 112
2022-07-17 10:14:33.154 7277-7305/? E/MapTest: hashMap + synchronized put 10000 values cost time: 106
2022-07-17 10:14:38.048 7277-7303/? E/MapTest: concurrentHashMap overWrite 10000 times cost time: 4
2022-07-17 10:14:38.049 7277-7304/? E/MapTest: hashMap overWrite 10000 times cost time: 5
2022-07-17 10:14:38.051 7277-7305/? E/MapTest: hashMap + synchronized overWrite 10000 times cost time: 6
2022-07-17 10:14:43.084 7277-7304/? E/MapTest: concurrentHashMap put 24568 values cost time: 38
2022-07-17 10:14:43.089 7277-7307/? E/MapTest: concurrentHashMap put 29046 values cost time: 43
2022-07-17 10:14:43.091 7277-7303/? E/MapTest: concurrentHashMap put 30000 values cost time: 45
2022-07-17 10:14:48.078 7277-7307/? E/MapTest: hashMap put 17009 values cost time: 28
2022-07-17 10:14:48.090 7277-7305/? E/MapTest: hashMap put 25622 values cost time: 41
2022-07-17 10:14:48.097 7277-7309/? E/MapTest: hashMap put 29355 values cost time: 48
2022-07-17 10:14:53.203 7277-7305/? E/MapTest: hashMap + synchronized put 23495 values cost time: 151
2022-07-17 10:14:53.222 7277-7311/? E/MapTest: hashMap + synchronized put 29300 values cost time: 170
2022-07-17 10:14:53.223 7277-7303/? E/MapTest: hashMap + synchronized put 30000 values cost time: 171


2022-07-17 10:35:54.819 8561-8590/com.example.myapplication E/MapTest: concurrentHashMap put 10000 values cost time: 143
2022-07-17 10:35:54.824 8561-8591/com.example.myapplication E/MapTest: hashMap + synchronized put 10000 values cost time: 143
2022-07-17 10:35:54.827 8561-8589/com.example.myapplication E/MapTest: hashMap put 10000 values cost time: 152
2022-07-17 10:35:59.683 8561-8591/com.example.myapplication E/MapTest: concurrentHashMap overWrite 10000 times cost time: 3
2022-07-17 10:35:59.684 8561-8590/com.example.myapplication E/MapTest: hashMap overWrite 10000 times cost time: 4
2022-07-17 10:35:59.688 8561-8589/com.example.myapplication E/MapTest: hashMap + synchronized overWrite 10000 times cost time: 8
2022-07-17 10:36:04.728 8561-8590/com.example.myapplication E/MapTest: concurrentHashMap put 22345 values cost time: 48
2022-07-17 10:36:04.740 8561-8591/com.example.myapplication E/MapTest: concurrentHashMap put 26892 values cost time: 60
2022-07-17 10:36:04.754 8561-8596/com.example.myapplication E/MapTest: concurrentHashMap put 30000 values cost time: 74
2022-07-17 10:36:09.737 8561-8634/com.example.myapplication E/MapTest: hashMap put 20812 values cost time: 56
2022-07-17 10:36:09.763 8561-8589/com.example.myapplication E/MapTest: hashMap put 28044 values cost time: 77
2022-07-17 10:36:09.772 8561-8591/com.example.myapplication E/MapTest: hashMap put 29790 values cost time: 89
2022-07-17 10:36:14.916 8561-8635/com.example.myapplication E/MapTest: hashMap + synchronized put 24728 values cost time: 233
2022-07-17 10:36:14.936 8561-8589/com.example.myapplication E/MapTest: hashMap + synchronized put 28907 values cost time: 253
2022-07-17 10:36:14.938 8561-8596/com.example.myapplication E/MapTest: hashMap + synchronized put 30000 values cost time: 255

HashMap Remove

remove() 方法用于删除hashMap 中指定键 key 对应的键值对(key-value)。

返回值
如果指定 key，返回指定键 key 关联的值，如果指定的 key 映射值为 null 或者该 key 并不存在于该 HashMap 中，此方法将返回null。
如果指定了 key 和 value，删除成功返回 true，否则返回 false。

学知识拯救世界
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
android基础之Map系列
旺帝春心
03-13 2811
数组：内存存储连续 占用内存多 寻址容易，时间复杂度： 索引查找 （O（1）），按值查找（O（log(2)n） 链表: 内存存储不连续 占用内存少 插入与删除方便,时间复杂度(O（n）) , 为了结合数组寻址容易与链表的插入删除容易，HashTable应运而生; java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtab...
android中map的作用,Android Map相关总结
weixin_36473464的博客
05-26 1208
HashMap、LinkedHashMap、ConcurrentHashMap、ArrayMap、SparseMap、Hashset、TreeMap的底层原理、数据结构与对比1、HashMap底层数据结构(数组+链表+红黑树)，链表中节点数量大于8则转换为红黑树。参数对性能的影响：加载因子(loadFactor)和初始容量(initialCapacity)。加载因子跟初始容量得乘积是判断是否需要扩...
Android--Map集合的使用
m0_67402125的博客
04-29 1914
1.map集合 4.支持泛型 5.向map集合中添加元素用Put Map 可以返回一个key值得集合，一个vaule值的集合，键值对的集合。通过这三种方法很方便去遍历map中的元素。 7.案例
android map使用方法,android遍历map的两种常用方法
weixin_39654245的博客
05-25 1817
Map一般用来保存具有映射关系的数据，Map里保存着两组数据：key(键)和value(值)，它们可以是任何引用类型的数据，但key不能重复。所以通过指定的key就可以取出对应的value。遍历方式一、当键和值都需要用到时所采用的方法。Map map = new HashMap();for (Map.Entry entry : map.entrySet()) {System.out.println...
android遍历map的六种方式
wangyongqi的博客
12-10 7521
需要导入的包 import java.util.Map; import java.util.HashMap; import java.util.Iterator; 定义一个map集合 Map<String, String> map = new HashMap<>(); map.put("id", "1024"); map.put("name", "张三");...
android google map 导航
05-03
2013年更新的google map api v2致使原来的很多类都不能使用了,本人经过研究和翻看api文档整理并写了这个程序,实现了了位置获取,通过地名获取经纬度,输入目的地进行导航路线获取,异步数据处理等功能
基于Google Map Api的Android导航应用
01-19
一、引言 ...　本文提出并实现了一种基于Google Map Api 的Android 导航应用，能够给用户提供人性化和智能化的地图导航服务。 　二、系统体系结构 图1 系统体系结构 　三、UI 界面设计 　Android 应
Android智能终端Thinking Map的研究与实现.pdf
09-21
Android智能终端Thinking Map的研究与实现.pdf
基于Android的地震目录在Google Map中的研究.pdf
09-21
基于Android的地震目录在Google Map中的研究.pdf
尼日利亚约拉 Mautech 的 Android 校园指南回顾-研究论文
06-10
MAUTECH Android Campus Guide应用程序旨在解决新生在寻找办公室、演讲厅和部门时浪费时间的问题。 它还可以作为有兴趣的人的导航系统，他们想在校园里从一个地方到另一个地方移动，但不知道如何移动。 开发了一个...
AndroidMap
05-24
NULL 博文链接：https://eric2007.iteye.com/blog/350509
android map的使用
11-18
详细介绍了android中map地图的使用方法和开发的整个过程
android 变量Map集合
谢岩的博客
12-14 8143
今天，简单讲讲android如何遍历Map集合。 这个其实很简单，但是之前忘记了，查找资料才记起的，所以记录一下。 以下是map遍历的四种方式： // 一、推荐只用value的时候用，都懂的。。。 // Map.values()遍历所有的value，不遍历key for (String v : map.values()) { System.out.prin
遍历Map的四种方法
weixin_41631413的博客
09-24 323
下面是遍历Map的四种方法: public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); map.put(“1”, “value1”); map.put(“2”, “value2”); map.put(“3”, “value3”); //第一种：普遍使用，二次取值 System.out.println(“通过Map.keySet遍历key和value
android map的使用
Zywcd
03-12 1362
一、Map：双列集合，也就是说他所存储的是键值对。 HashTable：哈希表结构，不保证存取顺序，不允许null键或者null值，线程安全，效率较低，已经被HashMap替代 HashMap：哈希表结构，不保证存取顺序，允许null键或者null值，效率较高 LinkedHashMap：带双向链表的哈希表结构，保持存取顺序，允许null键和null值，非线程安全，效率较高。 TreeMap：平衡...
cpp map 获取所有 key_Java学习之Map集合
weixin_39970668的博客
11-20 204
Map 是一个接口，没有继承Collection接口，是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象，只要给出键对象，就会返回对应的值对象，该接口描述了从不重复的键到值的映射。Map的实现类通常在 java.util 程序包中实现，通常我们要实例化一个Map时，可以采取以下方式：public static void main(String[] args) { ////M...
Android Map开发基础知识学习笔记
iteye_1744的博客
06-29 117
注册 Android 地图 API 密钥 运行：keytool -list -keystore ~/.android/debug.keystore 用得到的MD5码到http://code.google.com/intl/zh-CN/android/maps-api-signup.html注册API密钥。参考： http://www.cnblogs.com/feisky/archive...
android map
最新发布
05-30
Android Map 是 Android 平台上的地图应用程序编程接口（API），提供了在应用程序中嵌入地图、添加标记、绘制路线、搜索位置等功能。常用的 Android Map API 包括 Google Maps Android API、百度地图 SDK、高德地图 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学知识拯救世界

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值