QT容器

QString类

隐式共享:

隐式数据共享机制去最大化资源有效利用和最小化复制克隆操作。

隐式数据共享类当作为函数参数传递的时候，不仅安全而且效率很高，因为传递的时候只是传递了数据的指针，数据本身只当自己被修改的时候才会去复制。简称写时复制。

数据相同时，执行浅拷贝，仅复制指向数据块的指针，数据不同时则执行深拷贝。

隐式共享技术可以大大降低对内存的开销以及，CPU资源的消耗，很大程度提高应用程序的运行效率。

QString类保存了16位的Unicode值(宽字节)，Unicode把所有语言都统一到一套编码里，Unicode提供UTF-8、UTF-16、UTF-32编码方式。

UTF-8以字节为单位对Unicode进行编码，对不同范围的字体使用不同长度的编码。对于0x00-0x7F之间的字符，UTF-8编码与ASCII编码完全相同。

代码示例

    QString s = "Hello";//Hello数据块引用计数为1
    QString s1 = s;//Hello数据块引用计数为2
    QString s2 = s;//Hello数据块引用计数为3
    //其中一个进行球盖
    s2 = "He";//不在引用Hello这个数据块，Hello数据块引用-1，He数据块引用计数为1
    QString s3 = s;//Hello数据块引用计数为3
    QString s4 = s2;//He数据块引用计数为2
    QString s5 = s2;//He数据块引用计数为2

初始化

    //const char* 初始化
    QString s = "hello";
    QString str("test");
    //QChar数组初始化
    QChar cHi[3] = {'h','i'};
    QString strHi(cHi,2);Z
    //类对象初始化
    QString s1 = s;

转换

  //QString转数字
    QString strAge("18");
    int nAge = strAge.toInt();//默认是10进制
    QString strRate("3.14");
    float nRate = strRate.toFloat();
    QString strDouble("3.333");
    double strD = strDouble.toDouble();
    //数字转QString
    int year = 2022;
    float height = 1.70f;
    QString strYear;
    strYear =  strYear.number(year);
    QString strHeight;
    strHeight = strHeight.number(height);
    QString strTest;
    strTest = strTest.setNum(year);
    //QString转QByteArray
    QString strTom = "Tom";
    QByteArray tomArray = strTom.toUtf8();
    const char* cTom = tomArray.data();
    //QString转QDataTime
    QString strTime = "1949-10-01 10:00:00";
    QDateTime dtTime = QDateTime::fromString(strTime,"yyyy-MM-dd hh:mm:ss");
    //QDateTime转QString
    QDateTime dtCurrent = QDateTime::currentDateTime();
    QString strCurrent = dtCurrent.toString("yyyy-MM-dd hh:mm:ss");

常用方法

//QString的拼接
    QString s = "对不起";
    s += "我是警察。";
    s.append("Sorry。");// 结尾添加
    //QString格式化
    QString s0;
    s0.sprintf("%s%d%s","我",19,"岁了。");
    QString s1;
    s1 = QString("%1%2%3").arg("我").arg(19).arg("岁了。");
    //以索引方式访问
    QChar qc1= s1.at(1);
    //插入字符
    QString s2= "我岁了。";
    QString s3 = "19";
    s2.insert(1,s3.toUtf8());
    //在字符串起始位置插入
    s2.prepend("今年");
    //指定位置进行替换
    s2.replace(0,2,"去年");
    //去除字符串两端的空格,中间的空格变为一个空格
    s2.trimmed();

    //查询字符
    QString s4 = "哔哩哔哩关注快乐的威猛先生";
    //查询是否以xx开头,BOOL
    qDebug()<<s4.startsWith("哔哩哔哩");
    QString s5 = "tom";
    qDebug()<<s5.startsWith("tom",Qt::CaseSensitive);//大小写敏感
    //查询是否以xx结尾
    qDebug()<<s5.endsWith("威猛先生");//同样可以表明大小写是否敏感
    //是否包含
   qDebug()<<s5.contains("o");//同样可以表明大小写是否敏感
   //比较
    qDebug()<<QString::compare("Tom","tom",Qt::CaseInsensitive);//判断字符串是否相等，大小写是否敏感
    //分割字符串
    QString strTime =  "2022/1/17";
    QStringList timeList = strTime.split("/");
    foreach (QString ss,timeList) {//循环读取容器中的元素，用一个变量来接收读取到的数据
       qDebug()<<ss;
    }
    //截取字符串
    QString sFriends = "EnvyuskenyS";
    qDebug()<<sFriends.mid(1,1);
    //判断NULL字符串isNull()，采用默认构造函数，或者用const char*xx ='\0'来对QString进行构造
	//判断空字符传isEmpty()

---

QStringList

QString类型的链表

常用操作。

    QStringList weekList;
    weekList<<"星期一"<<"星期二"<<"星期三"<<"星期四"<<"星期五"<<"星期六";
    weekList.append("星期天");//尾插
    qDebug()<<weekList;
    //for遍历链表
    for(int i = 0 ;i < weekList.size();i++)
    {
         qDebug()<<weekList.at(i);
    }
   //foreach遍历链表
    foreach (QString ss, weekList) {
       qDebug()<<ss;
    }
    //STL风格迭代器
    QStringList::iterator it = weekList.begin();
    for(;it !=  weekList.end();it++)
    {
        qDebug()<<*it;
    }
    //JAVA风格迭代
    QListIterator<QString>itr(weekList);
    while (itr.hasNext()) {
        qDebug()<<itr.next();//java风格的迭代器初识位置在第一个元素的前一个位置
    }
    //查看链表中是否包含某个元素
    qDebug()<<weekList.contains("星期八");
    //插入元素
    weekList.insert(0,"星期零");
    weekList.append("星期八");
    //删除元素
    weekList.removeFirst();
    weekList.removeLast();
    weekList.removeOne("星期一");
    weekList.removeAt(0);
    weekList.clear();

---

QList

QList< T >是最常用的容器类。QList以列表形态存储并管理数据，并能进行基于快速索引的访问，也可以进行快速的数据删除操作。继承自QList类的子类有QItemSelection、QQueue、QStringList、QTestEventList.

可用运算符<< 、append()、prepend()进行添加元素，insert()进行插入。QList< T >维护了一个指针数组，数组元素指向每一个链表项，因此QList< T > 提供了基于下标的快速访问。

Java风格迭代器迭代点位置：第一个列表项前、两个列表项中间、最后一个列表项之后。STL风格迭代器迭代点位置：直接指向列表项。

QString中可以通过[]来访问元素。因为里面放的是指针，通过指针访问元素。

相关操作示例

QList<int>list;
    //添加与元素
    list<<1<<2<<3<<4<<5;
    list.append(0);
    list.prepend(6);
    list.insert(0,99);
    //查找元素
   list.at(2);
   list[2];
    //查看是否包含
   list.contains(8);
    //修改元素
    list.replace(1,66);
    list[2] = 77;
    //删除元素
    list.removeFirst();
    list.removeLast();
    //删除指定位置元素
    list.removeAt(2);
    //指定元素删除
    list.removeOne(66);
    //清空链表
    list.clear();

迭代器

JAVA风格迭代器

 //JAVA风格迭代器
    QList<int>montList;
    QMutableListIterator<int> it_mrw(montList);
    for(int i = 0 ; i <   12; i++)
    {
        it_mrw.insert(i);
    }
    //反遍历
    //将迭代器移到结尾，判断前面是否有数据
    for(it_mrw.toBack();it_mrw.hasPrevious();)
    {
        qDebug()<<it_mrw.previous();
    }
    //正遍历
    for(it_mrw.toFront();it_mrw.hasNext();)
    {
        qDebug()<<it_mrw.next();
    }
    //删除、修改
    for(it_mrw.toFront(); it_mrw.hasNext();)
    {
         int month = it_mrw.next();
         if(month== 0)
         {
              it_mrw.remove();
         }
         if(month == 11)
        {
              it_mrw.setValue(12);
        }

    }
    qDebug()<<montList;
    //只读迭代器
    QListIterator<int>it_mr(montList);
    //正遍历
    for(it_mr.toFront();it_mr.hasNext();)
    {
        qDebug()<<it_mr.next();
    }
    //反遍历
    for(it_mr.toBack();it_mr.hasPrevious();)
    {
        qDebug()<<it_mr.previous();
    }

STL风格迭代器

    //STL风格迭代器
   QList<int>numList;
   numList<<10<<11<<12<<13;
   //读写迭代器
    QList<int>::iterator it_numRW;
    for( it_numRW = numList.begin();it_numRW != numList.end();it_numRW++)
    {
        *it_numRW =*it_numRW *  10;
         qDebug()<<*it_numRW;
    }
    qDebug()<<"---";
    //只读迭代器
    QList<int>::const_iterator it_numR;
    //constEnd方法返回的迭代器指向最后一个元素之后，是虚拟的。
    for( it_numR = numList.constBegin();it_numR != numList.constEnd();it_numR++)
    {
            qDebug()<<*it_numR;
    }
      qDebug()<<"---";

---

QLinkedList

更加高效，大量数据情况下运行速度更快。是一个更加"纯粹"的链表。

不支持下标访问，不用维护那个指针数组。

  QLinkedList<QString>weekList;
   for(int j = 1; j < 8 ;j ++ )
   {
        weekList<<QString("%1%2").arg("星期").arg(j);
   }
    //JAVA风格只读迭代器
    QLinkedListIterator<QString>it_wr(weekList);
    for(it_wr.toFront();it_wr.hasNext();)
    {
        qDebug()<<it_wr.next();
    }
    //Java风格读写迭代器
    QMutableLinkedListIterator<QString>it_wrw(weekList);
    for(it_wrw.toFront();it_wrw.hasNext();)
    {
        QString day = it_wrw.next();
        if(day == "星期3")
        {
            it_wrw.setValue("星期三");
        }
        if(day == "星期5")
        {
            it_wrw.setValue("星期五");
        }
        if(day == "星期6")
         {
            it_wrw.insert("星期六6");//插入到当前位置的后面
        }
    }
    for( it_wrw.toFront();it_wrw.hasNext();)
    {
         qDebug()<<it_wrw.next();
    }
    //QLinkedList不能支持下标访问

---

QVector

QVector在相邻的内存中存储给定数据类型T的一组数据。在QVector前部或中间位置插入操作速度都很慢，因为会导致内存中大量数据的移动。访问数据可使用下标，也可以使用迭代器。继承自QVector类的子类有QPolygon、QPolygonF、QStack。

   QVector<QString>vStarts;
     //添加元素
    vStarts<<"星期1"<<"星期2"<<"星期3";
    vStarts.append("星期4");
    vStarts.prepend("星期5");
    vStarts.insert(0,"星期6");
    //修改元素
    vStarts.replace(0,"星期六");
    //删除元素
    vStarts.remove(0);
    vStarts.removeFirst();
    vStarts.removeAll("星期日");
    //访问元素
    vStarts[2];
    vStarts.at(2);
    vStarts.contains("星期日");
    //JAVA风格只读迭代
    QVectorIterator<QString>it_sr(vStarts);
    for(it_sr.toFront();it_sr.hasNext();)
    {
        qDebug()<<it_sr.next();
    }
    //JAVA风格读写迭代
    QMutableVectorIterator<QString>it_srw(vStarts);
    for(it_srw.toFront();it_srw.hasNext();)
    {
        QString s = it_srw.next();
        if(!QString::compare(s,"星期1"))
         {
            it_srw.setValue("星期一");
         }
    }
    qDebug()<<vStarts;

---

QMap

QMap与QHash差别：

• QHash比QMap查找速度更快。
• QHash以任意顺序存储，QMap以key顺序存储数据。
• QHash的key必须提供operator==()及一个全局的qHash(key)函数，而QMap必须提供operator<()函数。

存储一键多值数据时可使用QMultiMap< key,T>容器或QMultiHash< key, T>容器

默认从小到大排序。

   QMap<QString,QString>infoMap;
    infoMap.insert("哈哈哈哈","鸡汤来喽");
    infoMap.insert("芜湖","起飞");
    infoMap["哔哩哔哩"]="快乐的威猛先生";
    infoMap["CSDN"]="半生瓜のblog";
    //通过key查找value
    qDebug()<<infoMap["哔哩哔哩"];
    //通过value找key
    qDebug()<<infoMap.key("快乐的威猛先生");
    //JAVA风格只读迭代器
    QMapIterator<QString,QString>it_r(infoMap);
    for(it_r.toFront();it_r.hasNext();)
    {
        it_r.next();
        qDebug()<<it_r.key()<<":"<<it_r.value();
    }
    //JAVA风格读写迭代器
    QMutableMapIterator<QString,QString>it_rw(infoMap);
    for(it_rw.toFront();it_rw.hasNext();)
    {
        it_rw.next();
        if(it_rw.key()=="哔哩哔哩")
         {
            it_rw.setValue("关注快乐的威猛先生");
        }
    }

     //STL风格只读迭代器
    QMap<QString,QString>::const_iterator i_r;
    i_r = infoMap.constBegin();
    for(;i_r != infoMap.constEnd();i_r++)
    {
        qDebug()<<i_r.key()<<":"<<i_r.value();
    }
    //STL风格读写迭代器
    QMap<QString,QString>::iterator i_rw;
    for(i_rw = infoMap.begin();i_rw != infoMap.end();i_rw++)
    {
           if(i_rw.key() == "哔哩哔哩")
           {
               i_rw.value() = "快关注威猛先生";
           }
    }
    i_rw = infoMap.find("哔哩哔哩");
    i_rw.value() ="bilibili";
    for(i_rw = infoMap.begin();i_rw != infoMap.end();i_rw++)
    {
        qDebug()<<*i_rw;//value
    }
    //一个键对应多个值
    QMultiMap<QString,QString>wMap1;//一个key对应多个value
    wMap1.insert("spring1","5°C");
    wMap1.insert("spring2","15°C");
    wMap1.insert("spring2","16°C");
    wMap1.insert("spring2","17°C");
    wMap1.insert("spring3","25°C");
    wMap1.insert("spring4","35°C");
    wMap1.insert("spring4","36°C");
    wMap1.insert("spring4","37°C");
    //指定元素删除
    wMap1.remove("spring1","5°C");
    //查询指定value
    wMap1.values("spring2");

    //JAVA风格只读迭代
    QMapIterator<QString,QString>it_r1(wMap1);
    for(it_r1.toFront();it_r1.hasNext();)
    {
        qDebug()<<it_r1.key()<<":"<<it_r1.next().value(); //这个迭代器看起来比较变扭，先拿key,然后通过下一个迭代点拿value
    }

    qDebug()<<wMap1;

---

QHash

无序。

  //QHash类
    QHash<int,QString>moneyHash;
    moneyHash.insert(1,"一块钱");
    moneyHash.insert(10,"十块钱");
    moneyHash.insert(20,"二十块钱");
    moneyHash.insert(50,"五十块钱");
    moneyHash[50]  = "50";
    moneyHash.insertMulti(50,"50块钱");//插入多个value
    qDebug()<<moneyHash;
    //JAVA风格只读迭代器
    QHashIterator<int,QString>it_mr(moneyHash);
    for(it_mr.toFront();it_mr.hasNext();)
    {
        qDebug()<<it_mr.key()<<it_mr.next().value();
    }
    //JAVA风格读写迭代器
    QMutableHashIterator<int,QString>it_mrw(moneyHash);
    //修改数据
    if(  it_mrw.findNext("十块钱"))
    {
        it_mrw.setValue("10元");
    }
    for(it_mrw.toFront();it_mrw.hasNext();)
    {
        qDebug()<<it_mrw.key()<<":"<<it_mrw.next().value();
    }
    qDebug()<<moneyHash;

---

QVariant类

QVariant类能保存很多Qt类型的值，包括QColor,QBrush,QFont,QRect,QString及QSize等等，而且能存放Qt的容器类型值。

可采用toT()将QVariant对象转换为T类型数据并获取其值。如toInt()，toFloat(),toString(),可用type方法获取数据类型。对于GUI模块中定义的数据类型没有相应的转换函数，即没有toColor(),没有toImage()这样的函数提供，可通过value()方法实现转换，判断两种类型是否可以转换可通过用type方法获取数据类型，判断方法的返回值判断。

QVariant vNum(100);
qDebug()<<vNum.toInt();
QVariant vPi(3.1415f);
qDebug()<< vPi.toFloat();
QVariant vStr("Hello");
qDebug()<<vStr.toString();
QVariant vb(true);
qDebug()<<vb.toBool();

QColor c = QColor(Qt::red);
QVariant VC = c;
qDebug()<<VC.type();
qDebug()<<VC.value<QColor>();

QVariant vss = vStr;
qDebug()<<vss.canConvert(QVariant::Int);//返回数据类型转换能力，QVariant的转换能力
qDebug()<<vss.convert(QVariant::Int);//false,转换失败，数据清空
//转换成功的条件:有转换能力，且数据类型匹配。