[QT] QMap使用详解

大家好，又见面了，我是你们的朋友全栈君。

一. 目录

1. 实例化QMap对象
2. 插入数据
3. 移除数据
4. 遍历数据
5. 由键查找对应键值
6. 由键值查找键
7. 修改键值
8. 查找是否包含某个键
9. 获取所有的键和键值
10. 一个键对应多个值
11. 自定义QMap类

1. 实例化QMap对象

    /* 创建QMap实例, 第一个参数为QString类型的键，第二个参数为int类型的值 */
    QMap<QString, int> map;

2. 插入数据

    /* 插入数据 两种方式*/
    map["math"] = 100;
    map.insert("English", 99);

打印输出: QMap((“English”, 99)(“math”, 100))
3. 移除数据

    /* 移除数据 */
    map.remove("math");

打印输出：QMap((“English”, 99))
4. 遍历数据

    /* 遍历数据 (先随便插入几个)*/
    map.insert("Math", 100);
    map.insert("Chinese", 98);
    map.insert("physical", 97);
    map.insert("chemical", 96);
    map.insert("biological", 95);
    
    /* 遍历数据要使用迭代器，QT提供了两种方式的迭代 */
    /* 第一种是Java类型的迭代 */
    QMapIterator<QString, int> iterator(map);
    while (iterator.hasNext()) { 
   
        iterator.next();
        qDebug() << iterator.key() << ":" << iterator.value();
    }

    /* 第二种是STL类型的迭代 */
    QMap<QString, int>::const_iterator iterator_1 = map.constBegin();
    while (iterator_1 != map.constEnd()) { 
   
        qDebug() << iterator_1.key() << ":" << iterator_1.value();
        ++iterator_1;
    }

打印输出：两种方法输出一样
“Chinese” : 98
“English” : 99
“Math” : 100
“biological” : 95
“chemical” : 96
“physical” : 97
5. 由键查找对应键值

     map.value("Math");

打印输出：100
6. 由键值查找键

map.key(100);

打印输出：“Math”
7. 修改键值

    /* 通常一个键只对应一个值，如果再次调用insert()方法，会覆盖以前的值 */
    map.insert("Math", 120);
    qDebug() << map.value("Math");

打印输出：120
8. 查找是否包含某个键

    bool isok = map.contains("Math");
    qDebug() << isok;

打印输出：true
9. 获取所有的键和键值

    QList<QString> allKeys = map.keys();
    qDebug() << allKeys;
    QList<int> allValues = map.values();
    qDebug() << allValues;

打印输出：
(“Chinese”, “English”, “Math”, “biological”, “chemical”, “physical”)
(98, 99, 120, 95, 96, 97)

10. 一个键对应多个值

    /* 使用QMultiMap类来实例化一个QMap对象 */
    QMultiMap<QString, QString> multiMap;
    multiMap.insert("People", "Name");
    multiMap.insert("People", "Gender");
    multiMap.insert("People", "Age");
    multiMap.insert("People", "Height");
    multiMap.insert("People", "Weight");
    qDebug() << multiMap;
    /* 从打印结果可以看出multiMap仍为一个QMap对象 */

打印输出：QMap((“People”, “Weight”)(“People”, “Height”)(“People”, “Age”)(“People”, “Gender”)(“People”, “Name”))

    qDebug() << multiMap.count("People");
    qDebug() <<  multiMap.value("People");
    qDebug() <<  multiMap.values("People");
    qDebug() <<  multiMap.values("People")[4];

打印输出：
5
“Weight”
(“Weight”, “Height”, “Age”, “Gender”, “Name”)
“Name”
通过上面输出可以看出，直接使用value()方法的得到的是最后插入的项；而通过values()方法可以得到所有的键值；如果要得到某个确定的键值可以使用.at()方法。

11. 自定义QMap类
QMap仅有键和键值，作为一个容器，它只能使两个数据产生一一对应关系，但是目前我有三个数据需要关联起来，一开始我是这样做的

    QMap<QString, int> mapOfId; 
    QMap<QString, QDateTime>mapOfTime;

使用两个Qmap就能达到要求，后面发觉还是有点麻烦，索性用QList自定义了一个能存储三个值的容器
美其名曰 CMAP

新建->Library–>C++ Library–>自定义库名称
cmap.h 函数声明
cmap.cpp 函数定义
点击运行，生成静态链接库

cmap.h文件实现

#ifndef CMAP_H
#define CMAP_H

#include "CMAP_global.h"
#include <QStringList>
#include <QDebug>
#include <QList>

class CMAP_EXPORT CMAP
{ 
   
public:
    CMAP();

    void insert(int key, QString value1, int value2); /* 插入一行数据 */
    void insert(QList<int> keys, QStringList value1s, QList<int> value2s); /* 插入多行数据 */
    QList<int> keys() const; /* 获取所有键 */
    QStringList value1s() const; /* 获取所有值1 */
    QList<int> value2s() const; /* 获取所有值2 */
    QString value1(int key) const; /* 由键值得到对应值1 */
    int value2(int key) const; /* 由键值得到对应值2 */
    int key(QString value1) const; /* 由值1获取键值 */
    bool contains(int key) const; /* 判断是否包含键 */
    bool contains(QString value1) const; /* 判断是否包含值1 */
    bool remove(int key);  /* 通过键删除一行数据 */
    bool remove(QString value1); /* 通过值1删除一行数据 */
    void clear(); /* 清除map */
    int size() const; /* 返回map长度 */
    void print() const; /* 打印所有<键，值1，值2> */

private:

    QList<int> key_list;
    QStringList value1_list;
    QList<int> value2_list;


};

#endif // CMAP_H

cmap.cpp文件实现

#include "cmap.h"

CMAP::CMAP()
{ 
   
    clear();
}

void CMAP::insert(int key, QString value1, int value2)
{ 
   
    key_list << key;
    value1_list << value1;
    value2_list << value2;
}

void CMAP::insert(QList<int> keys, QStringList value1s, QList<int> value2s)
{ 
   
    Q_ASSERT(keys.size() == value1s.size());
    Q_ASSERT(keys.size() == value2s.size());
    key_list << keys;
    value1_list << value1s;
    value2_list << value2s;
}

QList<int> CMAP::keys() const
{ 
   
    return key_list;
}

QStringList CMAP::value1s() const
{ 
   
    return value1_list;
}

QList<int> CMAP::value2s() const
{ 
   
    return value2_list;
}


bool CMAP::contains(int key) const
{ 
   
    if(key_list.contains(key)) return true;
    else return false;
}

bool CMAP::contains(QString value1) const
{ 
   
    if(value1_list.contains(value1)) return true;
    else return false;
}

bool CMAP::remove(int key)
{ 
   
    if(!this->contains(key)) return false;

    int i = key_list.indexOf(key);
    key_list.removeAt(i);
    value1_list.removeAt(i);
    value2_list.removeAt(i);
    return true;
}

bool CMAP::remove(QString value1)
{ 
   
    if(!this->contains(value1)) return false;

    int i = value1_list.indexOf(value1);
    key_list.removeAt(i);
    value1_list.removeAt(i);
    value2_list.removeAt(i);
    return true;
}

void CMAP::clear()
{ 
   
    key_list.clear();
    value1_list.clear();
    value2_list.clear();
}

int CMAP::size() const
{ 
   
    return key_list.size();
}

void CMAP::print() const
{ 
   
    for(int i = 0; i < size(); i++) { 
   
        qDebug() << QString("key:%1 value1:%2 value2:%3").
                    arg(key_list.at(i)).
                    arg(value1_list.at(i)).
                    arg(value2_list.at(i));
    }
}


QString CMAP::value1(int key) const
{ 
   
    if(!this->contains(key)) return "";

    int i = key_list.indexOf(key);
    return value1_list.at(i);
}

int CMAP::value2(int key) const
{ 
   
    if(!this->contains(key)) return -1;

    int i = key_list.indexOf(key);
    return value2_list.at(i);
}

int CMAP::key(QString value1) const
{ 
   
    if(!this->contains(value1)) return -1;
    int i = value1_list.indexOf(value1);
    return key_list.at(i);
}