【Qt-容器类】

■ 顺序容器类

■ QList

QList 比较常用的容器类，以数组列表的形式实现，在前、后添加数据非常快。以下为常用方法。
QList<QString> list;

插入：insert()          //list.insert(2, "mm");         // 在位置2插入项目     list << "aa" << "bb" << "cc"; // 插入项目
删除：removeAt(i)  //i 是下标
删除第3个  QString str =  list.takeAt(2); // 从列表中删除第3个项目，并获取它
替换：replace()       //替换第3个元素     list.replace(2, "bc");   
交换:   swap()          // list.swap(1,3);     // 交换项目1和项目3
移动：move()
添加：append()       // list.append("dd");            // 在列表尾部添加
头部添加: prepend("mm")          list.prepend("mm");           // 在列表头部添加
包含:  list.contains("mm");      //列表中是否包含“mm”
列表包含某值个数:  list.count("mm");  包含“mm”的个数 
查找 : list.indexOf("mm");     // 第一个“mm”的位置，默认从位置0开始往前查找 ，返回第一个匹配的项目的位置
往前查找: list.indexOf("mm", 2); // 第二个“mm”的位置，我们指定从位置1开始往前查找

QList<QString> list;
list << "A" << "B" << "C" << "B" << "A";
list.indexOf("B"); // returns 1
list.indexOf("B", 1); // returns 1
list.indexOf("B", 2); // returns 3
list.indexOf("X"); // returns -1
bool QList::empty()  const表为空，则返回true 
list.begin(), list.end()
for(int i=0; i<list.size(); ++i)
{
       qDebug() << list.at(i);   
}

QList<int> z;
z <<1<<2<<3<<4;          // z对应的值z[0] = 1;z[1] = 2;z[2] = 3;z[3] = 4;

QList<int> z;
z <<1<<2<<3<<4;
z.removeAt(1);           //删除下标为1后,z对应的值z[0] = 1;z[1] = 3;z[2] = 4;


#include <QCoreApplication>
#include <QList>
#include <QDebug>
 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);
     QList<QString> list;
     list << "aa" << "bb" << "cc"; // 插入项目
     if(list[1] == "bb") list[1] = "ab";
    list.replace(2, "bc");        // 将“cc”换为“bc”
    qDebug() << "the list is: ";  // 输出整个列表
    for(int i=0; i<list.size(); ++i){
        qDebug() << list.at(i);   // 现在列表为aa ab bc
    }
    list.append("dd");            // 在列表尾部添加
    list.prepend("mm");           // 在列表头部添加
    QString str = list.takeAt(2); // 从列表中删除第3个项目，并获取它
    qDebug() << "at(2) item is: " << str;
    qDebug() << "the list is: ";
    for(int i=0; i<list.size(); ++i)
    {
        qDebug() << list.at(i);   // 现在列表为mm aa bc dd
    }
    list.insert(2, "mm");         // 在位置2插入项目
    list.swap(1,3);               // 交换项目1和项目3
    qDebug() << "the list is: ";
    for(int i=0; i<list.size(); ++i)
    {
        qDebug() << list.at(i);   // 现在列表为mm bc mm aa dd
    }
    qDebug() << "contains 'mm' ?" << list.contains("mm"); // 列表中是否包含“mm”
    qDebug() << "the 'mm' count: " << list.count("mm"); // 包含“mm”的个数
    // 第一个“mm”的位置，默认从位置0开始往前查找，返回第一个匹配的项目的位置
    qDebug() << "the first 'mm' index: " << list.indexOf("mm");
    // 第二个“mm”的位置，我们指定从位置1开始往前查找
    qDebug() << "the second 'mm' index: " << list.indexOf("mm", 1);
    return a.exec();
}

■ QVector

append函数或者<<操作符来在数组最后端添加元素而不用担心溢出问题。
定义 QVector <int>  array(10) ；                 array[5]=4;
加元素 strArray.append("Hello"); //可以这样       
加元素 strArray<<"World!"; //也可以这样   
插入：    strArray.insert(1,"这就是在hello和world之间添加");
删除：    strArray.remove(1); //删除第一个元素，从0开始    strArray.remove(1，3); //从1开始，删除3个元素
复制（取代）：    strArray.replace(1,"LEO"); //删除第一个元素，从0开始
是否含有contains()函数是用来查找向量容器内是否含有某个对象。
count()函数可以找出某个对象出现的次数。
resize()函数可以在任何时候改变QVector向量容器的体积
capacity()函数会告诉你向量容器所占内存的实际大小空间。
判断是否包含某元素  qDebug()<< Array.contains(12);

末端添加元素：
QVector<int> Array;
Array<<3;   //第一种方式
Array.append(5);  //第二种方式

种方式
QVector<int>::iterator num;
for (num=Array.begin(); num!=Array.end(); num++)
{
    qDebug()<< *num;
}

//第二种方式
for (int i=0; i<Array.count(); i++)
{
     qDebug()<< Array[i];
}

QVector<QString> strArray; 

■ QLinkedList

是链式列表，数据项不是连续的内存存储，基于迭代器访问数据项，插入和删除数据项操作时间相同
QLinkedList<QString> list;
list<<"1"<<"2"<<"3"<<"4";
// foreach正序：
QString str;
foreach (str, list)
    qDebug() << str;
    
// 迭代器正序
QLinkedList<QString>::iterator it;
for(it = list.begin(); it != list.end(); ++it){
    qDebug() << *it;
}

// 迭代器倒序
QLinkedList<QString>::const_iterator it = list.constEnd();
while (it != list.constBegin())
{
    --it;
    qDebug()<<*it;
}
移除某个节点
list.removeOne("4");

列表大小
list.size()
链头位置插入
list.push_front("5");


链尾位置插入
list.push_back("5");
清空
list.clear();

■ QStack

类似于堆栈，后入先出的特点，push()和pop()用于数据进出栈。
QStack <int> s;                   　　   //定义一个int型栈
s. isEmpty();                        　　 //返回栈是否为空
s.size();                                //返回当前栈中元素的个数  
s.push();                                //在栈顶上堆进一个元素
s.pop();                                 //删除掉栈顶上的元素,并返回这个元素
s.top();                                //返回栈顶的元素,并不会删除  
T &  operator[] ( int i );        　　  //以数组形式访问队列元素

QStack<int> stack;
stack.push(1);   
stack.push(2);
stack.push(3);
 
while(!stack.isEmpty())
    stack.pop();

■ QQueue

它的父类是QList,是个模板类 
类似于队列，先入先出的特点，enqueue()和dequeue()用于操作数据进出队列。
QQueue<int> Q;           　  //定义一个int型队列
Q.isEmpty();                 //返回队列是否为空
Q.size();                    //返回队列元素个数
Q.clear();                   //清空队列
Q.enqueue();                 //在队列尾部添加一个元素, 比如插入数字5: Q.enqueue(5)
Q.dequeue();                 //删除当前队列第一个元素,并返回这个元素
Q.head();                    //返回当前队列第一个元素
Q.last();                    //返回当前队列尾部的元素
T &  operator[]( int i );    //以数组形式访问队列元素

QQueue<int> queue;
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
 
while(!queue.isEmpty())
    queue.dequeue();

■ 关联容器类

■ QSet

基于散列表的集合模板类，存储数据的顺序不定，查找速度非常快。
QSet类是一个模板类，他是一个哈希表集合。QSet<T>是Qt的一个普通容器类。QSet存储的值是不指明顺序的，QSet对这些值提供了快速检索的功能。他和QHash很像PS：Set就是键值一样的Hash
QSet<QString> set;
set.insert("one");
set.insert("three");
set << "twelve" << "fifteen" << "nineteen";

使用contains()判断set中是否存在某一项：
if (!set.contains("ninety-nine"))

遍历整个set
QSetIterator<QWidget *> i(set);
while (i.hasNext())
qDebug() << i.next();

QSet<QWidget *>::const_iterator i = set.constBegin();
  while (i != set.constEnd()) {
      qDebug() << *i;
      ++i;
  }

QSet<QString> set;
foreach (const QString &value, set)
qDebug() << value;

#include <QtCore/QCoreApplication>
#include <QSet>
#include <QDebug>
 
class Data{ 
public: 
    Data(const QString &strVal, const int &intVal){ 
        StrVal = strVal;
        IntVal = intVal;
    } 
    QString StrVal;
    int IntVal; 
    friend QDebug operator << (QDebug os, Data data){
 
        os << "(" << data.StrVal << " ,"
           << data.IntVal << ")"; 
        return os;
    }
}; 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    QSet<Data*> dataSet;
    dataSet.insert(new Data("ABC", 0));
    dataSet.insert(new Data("DEF", 1));
    dataSet << new Data("AAA", 2);
    dataSet << new Data("CCC", 3);
 
    //Java style
    QSetIterator<Data *> i(dataSet);
    while(i.hasNext())
        qDebug() << *(i.next());
 
    //STL style
    QSet<Data*>::const_iterator stlI = dataSet.constBegin();
    while(stlI != dataSet.constEnd()){
        
        qDebug() << **stlI;
        delete *stlI;
        stlI++;
    } 
    return a.exec();
}

■ QMap

QMap存储数据按照键的顺序来存储的，一个键映射一个值。

QMap<int,int> map;
map[1] = 1;
map[2] = 2;
map[3] = 3;
//或者使用insert
QMap<int,int> map;
map.insert(1,1);
map.insert(2,2);
map.insert(3,3);

int num = map[1]; //或者 int num2 = map.value[2];

■ QMultiMap

是QMap的子类，一个键可以对应多个值。
QMultiMap<int,int> map;
map.insert(1,1);
map.insert(1,2);
//map.size() == 2 

■ QHash

基于散列表来实现的,查找速度非常快。
和QMap比较
QHash查找速度更快
QMap是按键顺序排序的，QHash数据项任意排序

创建,键值对的方式插入，数据类型随意，这里以键int，值QString示例。
QHash<int,QString> qhash;

//方式一
qhash[1] = "1";
qhash[2] = "2";
qhash[3] = "3";

//方式二
qhash.insert(4, “4”);
通常，QHash 每个键只允许有一个值。如果用已经存在的键调用 insert()，先前的值将被删除 
qhash.insert(4,"10);
最后键为4的值将变成“10”。

取值；
//方式一   
QString str1=qhash.value(1);//str1="1";

//方式二
QString str2=qhash[2];//str1="2";

如果qhash里面没有该键值，则返回默认构造值；比如：QString str3=qhash.value(5);//str3="";

检索某个值是否在里面
if(qhash.contains(9))
{
    return false;
}

if(qhash.contains(1))
{
    return true;
}

查找某个字并获取，一般推荐contains结合value重载函数来实现，

QString str;
if(qhash.contains(1))
{
    str=qhash.value(1);      
}
else
{
    str=qhash.value(1,"wert");
    //如果哈希表中不存在指定键的元素，该函数使用第2个参数作为默认值
}


QHash<int,QString>::const_iterator it = qhash.constBegin();
while (it != qhash.constEnd()) {
    cout << it.key() << ": " << it.value() << Qt::endl;
    ++i;
}
当然不用const_iterator也可以，直接iterator;

删除,下面两种都可以
qhash.erase(it);//这里的it是迭代器哦
qhash.remove(key);

■ QMultiHash

QMultiHash是QHash的子类，用于处理多值映射的类，与QMultiMap类似。