标签: map

我的STL有点生疏,请原谅我提出一个可能微不足道的问题.考虑以下代码:

map<int,int> m;
...
for (auto itr = m.begin(); itr != m.end(); ++itr) {
    if (itr->second == 0) {
        m.erase(itr);
    }
}

问题是:在循环地图时擦除元素是否安全？

任何人都可以为Java推荐一个轻量级,快速且有希望稳定的B树(或类似)库吗？

基本上我正在寻找磁盘上的地图; BerkeleyDB JE除了我不需要事务之外,对于只读并发很好,需要大约1/10大小(BSD或Apache许可证也很好).

需要纯Java,所以没有东京/京都机柜.

实现相关Collections接口将是一个加号(或者,原始类型的模板化接口也会很好).

JDBM看起来相当不错,但它似乎在2005年被放弃了(1.0,不低于).

还有DiskBackedMap,但他们一年前发布了一个alpha版本,此后一无所获.

还有别的吗？或者上述任何经历？

我不想要的东西:

• 进程间关系数据库(所以没有H2,Derby,SQLite等)
• 分布式键值存储(没有Redis,Memcachedb,Cassandra,Voldemort,Dumbledore等)

为什么java.util.Map接口不扩展java.util.Collection接口？不是java.util.MapKey-Value对的集合吗？

我想在R中创建美国地图,其中状态颜色以基于度量的热图类型的方式编码.我知道如何使用googleVis api做到这一点,但我不能使用代码,没有翻转它不是那么好.完成这项工作的最快方法是什么？我熟悉地图包,但我无法让颜色合作.我相信这被称为等值区域图.

我想知道是否有关于重复调用(在Java中)Method.getAnnotation(Class)和Field.getAnnotation(Class)方法的性能的比较/研究,与存储(在程序启动时)一个预先计算的Map以及类的元数据信息并重复查询它后来.哪一个可以提供最佳的运行时性能？

在Java 5,6和7下,这种性能是一样的吗？

我编写了一个类来充当顺序容器(std::vector/ std::queue/ std::list)的包装器std::map,以便在使用少量小对象时具有a的接口.鉴于已有的算法,编码非常简单.这段代码显然是从我的完整代码高度修剪,但显示问题.

template <class key_, 
          class mapped_, 
          class traits_ = std::less<key_>,
          class undertype_ = std::vector<std::pair<key_,mapped_> >
         >
class associative
{
public:
    typedef traits_ key_compare;
    typedef key_ key_type;
    typedef mapped_ mapped_type;
    typedef std::pair<const key_type, mapped_type> value_type;
    typedef typename undertype_::allocator_type allocator_type;
    typedef typename allocator_type::template rebind<value_type>::other value_allocator_type;
    typedef typename undertype_::const_iterator const_iterator;

    class value_compare {
        key_compare pred_;
    public:
        inline value_compare(key_compare pred=key_compare()) : pred_(pred) {}
        inline bool operator()(const value_type& left, const value_type& right) const {return pred_(left.first,right.first);} …

可能重复:
为什么在STL映射中用作值的类需要...中的默认构造函数？

当我使用地图时,值肯定会被初始化为默认值,还是我不应该依赖它？

例如,假设我有以下代码:

map<string, int> myMap;
cout << myMap["Hey"];

这将使用我的编译器输出"0".这是保证的行为吗？这可能不会总是初始化为0吗？

我有以下代码:

#include <functional>   // std::less
#include <map>
#include <iostream>
using namespace std;

class Key
{
public:
        Key() {cout << "Key Constructor" << endl;}
        ~Key() {cout << "Key Destructor" << endl;}
        Key(const Key& key) {cout << "Key Copy Constructor" << endl;}

        bool operator < (const Key& k1) {return true;}
};
int main()
{
        map<Key, int> mymap;
        Key k;

        cout << "operator[]"<<endl;
        mymap[k] = 1;

        map<Key, int> mymap2;
        cout << "insert"<<endl;
        mymap2.insert(std::make_pair(k, 1));
        cout << "=========" << endl;

}

输出是:

$ g++ …

有办法吗？

a = b.map{ |e| #return multiple elements to be added to a }

而不是为每个要添加的迭代返回单个对象,a可以返回多个对象.

我目前正在实现这一目标:

a = []
b.map{ |e| a.concat([x,y,z]) }

有没有办法在单行中进行此操作而无需事先声明a = []？

我正在编写一个应用程序,其中内存以及在较小程度上的速度至关重要.我从剖析中发现,我花了很多时间在Map和Set操作中.虽然我在考虑减少调用这些方法的方法,但我想知道是否有人在编写或遇到过显着改进访问时间或内存开销的实现？或者至少,在某些假设的情况下,这可以改善这些事情吗？

从JDK源代码来看,我无法相信它不能更快​​或更精简.

我知道Commons Collections,但我不相信它有任何实现,其目标是更快或更精简.Google Collections也是如此.

更新:应该注意到我不需要线程安全.