qt--QByteArray字節數組

QByteArray bb("Hello");  //創建字節數組
    int n=bb.size(); //返回字節數組的大小
    //不包括終止符 \0
    QByteArray ba;//創建一個空字節數組
    ba.resize(6);//設置字節數組的大小
    //  \0  為終止符
    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不夠長用\0填補

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不夠大，會自動填補
    //"limingGDL\x00.."

    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("\n   li\nming \t  ");
    ba3=ba.simplified();//刪除兩頭空白字符，內部的空白字符用空格替換
    //"li ming"
    //C標准中空白字符有：空格（‘ ’）、換頁（‘\f’）、換行（‘\n’）、回車（‘\r’）、水平制表符（‘\t’）、垂直制表符（‘\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("\t   li\nming    \r");
    ba1=ba.trimmed();//刪除兩頭的空白字符
    //"li\nming"

    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";  //可以 邏輯比較