qt--QByteArray字节数组

QByteArray bb("Hello");  //创建字节数组
    int n=bb.size(); //返回字节数组的大小
    //不包括终止符 
    QByteArray ba;//创建一个空字节数组
    ba.resize(6);//设置字节数组的大小
    //    为终止符
    ba[0] = 0x3c;  //赋值
    ba[1] = 0xb8;
    ba[2] = 0x64;
    ba[3] = 0x18;
    ba[4] = 0xca;

    char* p;

    p=ba.data();  //返回字节数组的指针--char*
    p[5]= 0x31;  //给第5个字节赋值

    char z;
    char z1;
    char z2;
    char z3;
    z=p[2];   //返回第2个字节
    z1=ba[2]; //返回第2个字节
    z2=ba.at(2); //返回第2个字节
    z3=ba.constData()[2];//返回第2个字节

QByteArray ba = QByteArray::fromHex("4142434445"); //把Hex编码转换为char存储到QByteArray
    //参数 16进制的数据  两位一个字节
    QString s=ba.toHex();  //把QByteArray转为Hex编码
    //"4142434445"

    int n = 63;
    s=QByteArray::number(n);  //把数值转换成字符串
    //"63"
    s=QByteArray::number(n,16);
    //参数1：可以是任何类型的数值
    //参数2  进制  默认10进制   取值：可以是2到36之间的任何值
    //"3f"
    s=QByteArray::number(63.89);
    //"63.89"

    ba.setNum(n); //按照指定进制格式直接复制，其中n可以是各类常见数值类型
    //"63"
    ba.setNum(63.7);
    //"63.7"
    ba.setNum(n,16);
    //参数2：进制
    //"3f"

    QByteArray ba1 = QByteArray::number(12.3456, 'G', 3);//把数值按指定格式和小数位转换输出，小数位四舍五入
    /*参数2：指定格式
            E  科学计数法格式    "1.235E+01"
            e  科学计数法格式    "1.235e+01"
            f  浮点数           "12.346"
            g  使用e或f格式，以最简洁的为准    "12.3"
            G  使用E或f格式，以最简洁的为准    "12.3"
    参数3：小数位数  */

    QByteArray ba2=("414243");
    //"414243"

    n=ba2.toInt();  //转换成int
    //414243
    //如果转换失败，则返回0

    bool b;
    n=ba2.toInt(&b,16);
    //4276803
    //参数1：转换失败返回false，转换成功返回true
    //参数2：ba2中数据的进制

    QByteArray ba3("1234.56");
    n=ba3.toInt();  //返回0, 小数均视为0
    n=ba3.toInt(&b,16);  //返回0, 小数均视为0
    float f=ba3.toFloat();  //转换成浮点数
    //1234.56
    double d=ba3.toDouble();  //转换成double
    //1234.56

    //QByteArray若为带大小写的字符串，可通过toUpper()和toLower()方法实现大小写转换
    QByteArray ba4("Qt by THE QT COMPANY");
    QByteArray ba5 = ba4.toLower();//转换成小写
    //"qt by the qt company"

    QByteArray ba6 = ba4.toUpper();//转换成大写
    //"QT BY THE QT COMPANY"

    //QByteArray与QString互转极为简单，二者从本质上类似，都是连续存储，区别是前者可以存无法显示的字符，后者只存可显示的字符
    QByteArray ba7("abc123");
    QString str = ba7; //转换成QString--方法一
    //"abc123"
    QString str1;
    str1.prepend(ba7);// QByteArray转QString方法2
    //"abc123"

    QString str2("hello");
    QByteArray ba8 = str2.toUtf8(); // QString转QByteArray方法1
    //"hello"

    QByteArray ba9 = str2.toLatin1();  // QString转QByteArray方法2
    //"hello"

    QByteArray ba10("Istambul");
    ba10.fill('X', 2); // 用指定的字符填充
    //参数1：填充的字符
    //参数2：填充后的大小；默认值：-1,全部填充
    //"XX"

    QByteArray ba11("lmsticky question");
    QByteArray ba12("sti");
    n=ba11.indexOf(ba12,1);//返回ba11字节数组中第一次出现字节数组ba12的索引位置，从索引位置向前搜索。如果找不到ba12，则返回-1
    //2
    //参数2：开始搜索的位置

    n=ba11.indexOf('t',1);  //返回ba11字节数组中第一次出现char字符的索引位置，从索引位置向前搜索。如果找不到，则返回-1
    //3

    n=ba11.indexOf("st",1);  //搜索字符串

QByteArray ba = QByteArray("");
    bool b=ba.isEmpty();//是否空字符；如果字节数组的大小为0，返回true; 否则返回false
    //true
    bool b1=ba.isNull();  //是否为空
    //false

    QByteArray ba1 = QByteArray("414243");
    QByteArray ba2=ba1.left(4);  //返回一个字节数组，该数组包含该字节数组最左边的n个字节。
    //如果n大于size（），则返回整个字节数组

    QByteArray ba3 = QByteArray("liming");
    QByteArray ba4=ba3.leftJustified(9,'.'); //返回一个指定大小的字节数组
    //"liming..."
    //参数1：字节数组的大小
    //参数2：填充字符--当指定的大小比原来的大时，用来填充
    QByteArray ba5=ba3.leftJustified(3,'.');
    //"liming"
    QByteArray ba6=ba3.leftJustified(3,'.',true);
    //参数3：默认为false:当参数1小于原大小时，返回原来的；   为true:当参数1小于原大小时，返回指定大小
    //"lim"

    int n=ba3.length(); //与size相同，返回大小

    QByteArray ba7=ba3.mid(1,3); //截取
    /*
参数1：开始截取的位置
参数2：截取的长度；如果省略一直到末尾
*/

    QByteArray x=QByteArray("88");
QByteArray ba8=ba3.insert(2,x);  //插入QByteArray
//"li88ming"
//参数1：插入的位置
//注意：ba3也改变了

QByteArray ba10=QByteArray("liming");
QByteArray ba11=ba10.insert(2,'x'); //插入一个字符
//注意：ba10也改变了

QByteArray ba12=QByteArray("liming");
QByteArray ba13=ba12.insert(2,3,'x');  //插入n个字符
//参数1：插入的位置
//参数2：插入的个数
//注意：ba12也改变了

QByteArray ba14=QByteArray("liming");
QByteArray ba15=ba14.insert(2,"LG"); //插入一个字符串
//注意：ba14也改变了

QByteArray ba16=QByteArray("liming");
QByteArray ba17=ba16.insert(2,"LGHKD",3); //插入一个指定长度的字符串
//注意：ba16也改变了
//参数3：插入参数2中前n个字符；如果参数2不够长用填补

QByteArray ba18=QByteArray("liming");
QByteArray ba19=QByteArray("ng");
b=ba18.endsWith(ba19); //如果b18字节数组以字节数组ba19结尾，则返回true；否则返回false
b=ba18.endsWith('n');//如果b18字节数组以指定字节结尾，则返回true；否则返回false
b=ba18.endsWith("ing");//如果b18字节数组以指定字节串结尾，则返回true；否则返回false

char c=ba18.front();  //返回第一个字符

    QByteArray ba = QByteArray("liming");
    QByteArray ba1=QByteArray("ABC");
    QByteArray ba2=ba.append(ba1); //尾部追加
    //"limingABC"
    //注意：ba也修改了

    ba = QByteArray("liming");
    ba2=ba.append('K'); //尾部追加
    //注意：ba也修改了

    ba = QByteArray("liming");
    ba2=ba.append("GDL"); //尾部追加
    //注意：ba也修改了

    ba = QByteArray("liming");
    ba2=ba.append("GDL",6); //尾部追加
    //注意：ba也修改了
    //参数2：追加参数1中前n个字节;如果参数1不够大，会自动填补
    //"limingGDLx00.."

    ba = QByteArray("liming");
    char c=ba.back(); //返回字节数组中的最后一个字符

    int n=ba.capacity();  //可以存储在字节数组中的最大字节数
    int nn=ba.size();

    ba.chop(2);//从字节数组的末尾删除n个字节
    //"limi"

    ba = QByteArray("liming");
    ba2=ba.chopped(2);//从字节数组的末尾删除n个字节
    //ba不改变

    ba2.clear();//清空

    ba1=QByteArray("Liming");
    n=ba.compare(ba1,Qt::CaseInsensitive); //比较
    /*
返回值：
    如果  ba>ba1   大于0
    如果  ba=ba1   等于0
    如果  ba<ba1   小于0
参数2：Qt::CaseSensitive  区分大小写
      Qt::CaseInsensitive  不区分大小写
*/

    ba1=QByteArray("ming");
    bool b=ba.contains(ba1); //如果ba字节数组包含字节数组ba1，则返回true；否则返回false
    b=ba.contains('m'); //如果ba字节数组包含指定字符，则返回true；否则返回false
    b=ba.contains("li"); //如果ba字节数组包含指定字符串，则返回true；否则返回false

    ba = QByteArray("liming AB liming KU");
    n=ba.count(ba1); //返回ba字节数组中字节数组ba1的出现次数

    n=ba.count('i'); //返回ba字节数组中出现指定字符的次数
    n=ba.count("ming"); //返回ba字节数组中出现指定字符串的次数

    n=ba.count(); //返回大小，与size相同

QByteArray ba = QByteArray("ABmi  KG liming");
QByteArray ba1 = QByteArray("mi");

int n=ba.lastIndexOf(ba1);//在ba中从后往前搜索ba1,返回找到的索引号
//如果找不到ba1，则返回-1

n=ba.lastIndexOf(ba1,6);//在ba中从后往前搜索ba1,返回找到的索引号
//如果找不到ba1，则返回-1
//参数2：开始搜索的位置；默认-1，表示末尾开始


n=ba.lastIndexOf('B',6);//在ba中从后往前搜索指定字符,返回找到的索引号
//如果找不到ba1，则返回-1
//参数2：开始搜索的位置；默认-1，表示末尾开始

n=ba.lastIndexOf("Bm",6);//在ba中从后往前搜索指定字符串,返回找到的索引号
//如果找不到ba1，则返回-1
//参数2：开始搜索的位置；默认-1，表示末尾开始


ba = QByteArray("liming");
ba1 = QByteArray("AB");
QByteArray ba2=ba.prepend(ba1); //在ba的前面追加ba1
//注意：ba  ba2 都改变了
//"ABliming"

ba = QByteArray("liming");
ba2=ba.prepend('K'); //在ba的前面追加字符
//注意：ba  ba2 都改变了

ba = QByteArray("liming");
ba2=ba.prepend("KG"); //在ba的前面追加字符串
//注意：ba  ba2 都改变了

ba = QByteArray("liming");
ba2=ba.prepend("KGABC",2); //在ba的前面追加字符串
//注意：ba  ba2 都改变了
//参数2:追加的字节数

    QByteArray ba = QByteArray("liming");
    QByteArray ba1 = QByteArray("AB");
    ba.push_back(ba1); //尾部追加

    ba = QByteArray("liming");
    ba.push_back("ABC"); //尾部追加

    ba = QByteArray("liming");
    ba.push_back('Q'); //尾部追加


    ba = QByteArray("liming");
    ba.push_front('Q'); //前面追加

    ba = QByteArray("liming");
    ba.push_front("AB"); //前面追加

    ba = QByteArray("liming");
    ba.push_front(ba1); //前面追加

    ba = QByteArray("liming");
    QByteArray ba3=ba.remove(1,2);  //移除
    //从数组中移除len字节，从索引位置pos开始，并返回对数组的引用。如果pos超出范围，则不会发生任何事情。如果pos有效，但pos+len大于数组的大小，则在pos处截断数组
    //注意：ba ba3都改变了
    //参数1:pos  移除的起始位置
    //参数2:len 移除的字节数

    ba = QByteArray("liming");

    ba3=ba.repeated(2); //返回重复指定次数的字节数组
    //如果参数小于1，则返回空字节数组
    //"limingliming"

    ba3=ba.replace(2,4,ba1); //替换
    //注意：ba ba3都改变了
    //参数1：起始位置
    //参数2：替换的字节数
    //参数3：替换的内容

    ba = QByteArray("liming");
    ba3=ba.replace(2,4,"KG"); //替换
    //注意：ba ba3都改变了
    //参数1：起始位置
    //参数2：替换的字节数
    //参数3：替换的内容

    ba = QByteArray("liming");
    ba3=ba.replace(2,4,"KGABC",2); //替换
    //注意：ba ba3都改变了
    //参数1：起始位置
    //参数2：替换的字节数
    //参数3：替换的内容
    //参数4：从参数3中取出指定字节数去替换

    ba = QByteArray("liming");
    ba3=ba.replace('i',"LM"); //替换--将前面出现的每个字符替换为后面的字符串
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符
    //参数2：用来替换的字符串

    ba = QByteArray("liming");
    ba3=ba.replace('i',ba1); //替换--将前面出现的每个字符替换为后面的字节数组
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符
    //参数2：用来替换的字节数组

    ba = QByteArray("liming");
    ba3=ba.replace("ming","xueqian"); //替换--将前面出现的字符串换为后面的字节串
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符串
    //参数2：用来替换的字节串

    ba = QByteArray("liming");
    ba3=ba.replace("ming",4,"xueqian",3); //替换--将前面出现的字符串换为后面的字节串
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符串
    //参数2：要被替换掉的字节数
    //参数3：用来替换的字符串
    //参数4：用来替换的字节数
    //"lixue"

    ba = QByteArray("liming");
    ba1 = QByteArray("ming");
    QByteArray ba2 = QByteArray("xueqian");

    ba3=ba.replace(ba1,ba2); //替换--将前面字节数组的内容换为后面字节数组的内容
    //注意：ba ba3都改变了
    //"lixueqian"

    ba = QByteArray("liming");
    ba3=ba.replace(ba1,"xue"); //替换--将前面字节数组的内容替换为后面的字符串
    //注意：ba ba3都改变了
    //"lixue"

    //QByteArray&  replace(const char *before, const QByteArray &after)
    //QByteArray&  replace(char before, char after)
    //QByteArray&   replace(const QString &before, const char *after)
    //QByteArray&  replace(char before, const QString &after)
    //QByteArray&  replace(const QString &before, const QByteArray &after)


    ba = QByteArray("liming");
    ba3=ba.right(4);//返回一个字节数组，该数组包含该字节数组最右边的len字节。如果len大于size（），则返回整个字节数组

    ba3=ba.rightJustified(4,'.',false);//返回一个字节数组，该数组包含该字节数组最右边的最多len字节
   /*
参数1：len  当len大于ba原大小时，返回len字节数组，左边用参数2填充   "...liming"
参数3：true时：当len小于原大小时，返回左边的len字节数(4)  "limi"
    false时(默认)：当len小于原大小时，返回ba的原内容
    */

    ba = QByteArray("
   li
ming 	  ");
    ba3=ba.simplified();//删除两头空白字符，内部的空白字符用空格替换
    //"li ming"
    //C标准中空白字符有：空格（‘ ’）、换页（‘f’）、换行（‘
’）、回车（‘
’）、水平制表符（‘	’）、垂直制表符（‘v’）六个

    ba = QByteArray("liming|lixueqian|lixiuyan");
    QList<QByteArray> lb=ba.split('|');  //分割
    //参数：分割字符
    //("liming", "lixueqian", "lixiuyan")

    ba = QByteArray("liming");
    ba1=QByteArray("li");
    bool b=ba.startsWith(ba1);//如果ba字节数组以字节数组ba1开头，则返回true；否则返回false
    b=ba.startsWith('l');//如果ba字节数组以指定字符开头，则返回true；否则返回false
    b=ba.startsWith("li");//如果ba字节数组以指定字符串开头，则返回true；否则返回false

    ba.swap(ba1); //交换

    ba = QByteArray("	   li
ming    
");
    ba1=ba.trimmed();//删除两头的空白字符
    //"li
ming"

    ba = QByteArray("liming");
    ba.truncate(2);//截取前n字节
    //"li"

    ba = QByteArray("liming");
    ba1 = QByteArray("AB");
    ba+=ba1;  //ba的尾部追加ba1
    //"limingAB"

    ba+='C'; //ba的尾部追加字符
    //"limingABC"

    ba+="DE"; //ba的尾部追加字符串
    //"limingABCDE"

    b=ba<"Li";  //可以 逻辑比较