字符

如下方法 //const unsigned short *p = (const unsigned short *)apBulkBuf; //const WORD *p = (const WORD *)apBulkBuf; if (*(unsigned short *)apBulkBuf == kSynWordDeviceInfoValue) //if (*p == kSynWordDeviceInfoValue) { // TODO: // 1 //QString qstrContent; //unsigned char* uszContent = (unsigned char *)qstrContent.toUtf8().data(); QString qstrContent = QString::fromUtf8(QByteArray((char*)apBulkBuf)); // 2 std::string str = std::string((const char *)apBulkBuf); // 3 QString str4 = QString::fromLocal8Bit((const char *)apBulkBuf, aNBufSize); //QByteArray byteArrayTempInfo; //byteArrayTempInfo.toHex(); // 4 std::string str2(apBulkBuf, apBulkBuf + aNBufSize); // 5 QString str3 = (char*)apBulkBuf; // 6 char* strTemp = new char[aNBufSize]; memcpy(strTemp, apBulkBuf, aNBufSize); std::string str6 = strTemp; // 7 QString str7 = QString(QLatin1String((char*)apBulkBuf)); // 写文件 std::ofstream out("\temp\out.txt"); if (out.is_open()) { out << "1. " << str << " "; out << "2. " << str2 << " "; out << "3. " << str3.toStdString() << " "; out << "4. " << str4.toStdString() << " "; out << "5. " << qstrContent.toStdString() << " "; out << "6. " << str6 << " "; out << "7. " << str6 << " "; out.close(); } std::ofstream fout("\temp\a.dat", std::ios::binary); fout.write((char*)apBulkBuf, sizeof(char) * (aNBufSize)); fout.close(); QLinesSemaphores::m_FreeBytes.release(); return; }

可以用==该类还有一个成员函数CompareNoCase可以用来忽略大小写的比较中文无非是每个字占2个字节（ASCII编码）

字符是单个的，字符串一般有多个，但也可以是单个，甚至可以是空的char c;c="a";字符a，注意使用单引号string c="abcd";string c1="a";单个字符，但是双引号char *s="abcd"

可以用==该类还有一个成员函数CompareNoCase可以用来忽略大小写的比较中文无非是每个字占2个字节（ASCII编码）

字符串的实际长度在缓冲区的第2个字节中，取出它即可。缓冲区的结构为：BUF DB <max_len>, <act_len>, max_len DUP(?)

利用DOS的OAH功能从键盘输入一串字符,并将此字符串在显示屏上显示出来。;-------------------------------------DATA SEGMENT STRING1 DB "Press any keys please: ", 10, 13, 24H STRING2 DB 13, 10, "The string is: ", 10, 13, 24H BUF1 DB 100 DB ? DB 100 DUP(?)DATA ENDS;-------------------------------------CODE SEGMENT ASSUME CS:CODE, DS:DATA, ES:DATA START: MOV AX, DATA MOV DS, AXL: MOV AH, 09H ;输入提示 LEA DX, STRING1 INT 21H MOV AH, 0AH LEA DX, BUF1 ;键盘输入到缓存区 INT 21H;------------------------------ MOV AH, 09H ;输入提示 LEA DX, STRING2 INT 21H LEA SI, BUF1 ;键盘输入缓存区 INC SI MOV CL, [SI] ;取出实际输入个数 MOV CH, 0 INC SIL3: MOV AH, 02H ; 显示 MOV DL, [SI] INT 21H INC SI LOOP L3;------------------------------EXIT: MOV AH, 4CH INT 21HCODE ENDS END START;-------------------------------------

0dH：回车 " "oaH：换行 " "

0DH对应 回车，0AH对应 换行。

利用DOS的OAH功能从键盘输入一串字符,并将此字符串在显示屏上显示出来。;-------------------------------------DATA SEGMENT STRING1 DB "Press any keys please: ", 10, 13, 24H STRING2 DB 13, 10, "The string is: ", 10, 13, 24H BUF1 DB 100 DB ? DB 100 DUP(?)DATA ENDS;-------------------------------------CODE SEGMENT ASSUME CS:CODE, DS:DATA, ES:DATA START: MOV AX, DATA MOV DS, AXL: MOV AH, 09H ;输入提示 LEA DX, STRING1 INT 21H MOV AH, 0AH LEA DX, BUF1 ;键盘输入到缓存区 INT 21H;------------------------------ MOV AH, 09H ;输入提示 LEA DX, STRING2 INT 21H LEA SI, BUF1 ;键盘输入缓存区 INC SI MOV CL, [SI] ;取出实际输入个数 MOV CH, 0 INC SIL3: MOV AH, 02H ; 显示 MOV DL, [SI] INT 21H INC SI LOOP L3;------------------------------EXIT: MOV AH, 4CH INT 21HCODE ENDS END START;-------------------------------------

在regular文件中搜索不包含“小妞”字符的行使用如下命令：grep-v"小妞"regular。使用find命令查找文件，并把查找结果重定向至grep程序，由grep程序在每个文件内容里查找是否包含xxx字符串[root@zcwyou~]#find/-name"*"|xargsgrep"xxxx"或者直接使用grep，指定要查找的字符串内容[root@zcwyou~]#grep"这里输入要匹配的字符串"./-Rn-l。关于命令后面的参数，本文后面会提及。如果要查找出包含2个字符串的文件的文件名：grep"目标字符串1"./-Rn|grep"目标字符串2"./-Rn-l。即在当前目录下，使用一个命令查找带目标字符串1的文件或带目标字符串2的文件。命令grep部分选项解释：表示当前目录所有文件，也可以是某个文件名，可省略。-r：递归查找相关文件。-n：打印时带行号。-R：查找所有文件包含子目录。-i：忽略大小写，默认情况区分大小写。-l：只列出匹配的文件名。-L：列出不匹配的文件名。-w：只匹配整个单词，而不是字符串的一部分（如匹配"magic"，而不是"magical"）。-Cnumber：匹配的上下文分别显示[number]行。

URLConnection context = url.openConnection();InputStream in = context.getInputStream();BufferedReader br = new BufferedReader(new InputStreamReader(in, "gbk"));包装流的时候要加入网站的编码 ，gbk和utf-8都试试最近我也在做爬虫，今天也遇到这个问题了。

用反斜杠“”试试,在windows系统中用来表示目录你的斜杠都被解释成双引号了，没遇到过这个问题如果还不行那就都用双引号，然后遇到url时反编译一下

#include<stdio.h> #include<string.h> void main() { char p1="d"; char p2[4]="abc";char p[2]; p[0]=p1; p[1]=""; strcat(p2,p); printf("%s ",p2); }

科学技术与工程一版面2000字左右一般刊物一个版面的字数在2000字左右,除文字外,还包括标点符号、空格等,如果作者的文章包括图表,图表也是会占用一定空间的,也是需要算字数的,举个例子,比如某刊物一个版面是2300字,作者的文章中有一张表格,大致占用300字符的空间,

看看String 的 substring方法

解密一共分两种：一种公开秘钥，算起来比较复杂；一种秘钥只有双方知道。貌似不好解

ascii码共有256个字符。ascii码占用一个字节，可以有0～255共256个取值。前128个为常用的字符如运算符，字母，数字等键盘上可以显示的后128个为特殊字符是键盘上找不到的字符。32～126（共95个）是字符（32sp是空格），其中48～57为0到9十个阿拉伯数字；65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。ASCII是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是最通用的信息交换标准，并等同于国际标准ISO/IEC 646。ASCII第一次以规范标准的类型发表是在1967年，最后一次更新则是在1986年，到目前为止共定义了128个字符。

ASCII码划分为两个集合：128个字符的标准ASCII码（7位二进制编码）和附加的128个字符的扩展ASCII码（8位二进制编码）。 ASCII是英文American Standard Code for Information Interchange的缩写。ASCII码是目前计算机最通用的编码标准。ASCII码：美国(国家)信息交换标准(代)码，一种使用7个或8个二进制位进行编码的方案，最多可以给256个字符(包括字母、数字、标点符号、控制字符及其他符号)分配(或指定)数值。ASCII码于1968年提出，用于在不同计算机硬件和软件系统中实现数据传输标准化，在大多数的小型机和全部的个人计算机都使用此码。因为计算机只能接受数字信息，ASCII码将字符作为数字来表示，以便计算机能够接受和处理。比如大写字母M的ASCII码是77。标准ASCII码中，第0～32号及第127号是控制字符，常用的有LF(换行)、CR(回车)；第33～126号是字符，其中第48～57号为0～9十个阿拉伯数字；65～90号为26个大写英文字母，97～122号为26个小写英文字母，其余的是一些标点符号、运算符号等。标准ASCII编码是7位的，所以有2^7=128个字符（包括一些不可显示字符）。但是电脑里1 Byte = 8 bit，有8位。早期的电脑不太可靠，数据经常出错，所以这1 Byte 的8位中最高位就用来做数据校验，一般是奇偶校验。在标准ASCII中，其最高位(b7)用作奇偶校验位。所谓奇偶校验，是指在代码传送过程中用来检验是否出现错误的一种方法，一般分奇校验和偶校验两种。奇校验规定：正确的代码一个字节中1的个数必须是奇数，若非奇数，则在最高位b7添1；偶校验规定：正确的代码一个字节中1的个数必须是偶数，若非偶数，则在最高位b7添1。但是后来的电脑变得可靠了，校验的意义就没有那么大了，因此有了一个扩展ASCII字符集。扩展ASCII字符集包含2^8=256个字符，编码是8位的。扩展ASCII字符集中的前128个字符与原来的ASCII字符集相同（就是原来的ASCII字符集的7位编码前面加一个0），而后面128个字符高位都是1。许多基于x86的系统都支持使用扩展（或“高”）ASCII。扩展ASCII 码允许将每个字符的第8 位用于确定附加的128 个特殊符号字符、外来语字母和图形符号。

ASCII码是指美国标准信息交换码，选用了常用的128个字符，其中包括32个控制符、10个十进制数（指字符形态的数）、52个英文大写和小写字母、34个专用符号。ascii码可以表示52种英文字符。分别是26个大写英文字母，26个小写英文字母。ascii码是最通用的信息交换标准，并等同于国际标准ISO/IEC646。基本ASCII码包含128个不同的字符。ASCII是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是最通用的信息交换标准，并等同于国际标准ISO/IEC646。ASCII值为10和13分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依不同的应用程序，而对文本显示有不同的影响。32～126(共95个)是字符(32是空格），其中48～57为0到9十个阿拉伯数字。E就是A后4位，也就是01000001+401000001+100010000101。ASCII是美国制定的一个关于用二进制数表示字符的标准，相当于ISO或者GB。因为标准ASCII码用7位二进制数来表示一个字符的编码，所以总共可以表示2^7=128个不同的字符。

ASCII取值0～255可表示256个字符

么是ASCII码？字符“A”、“a”、数字“0”的空格的ASCII码值是多少？

不大会改

怎么用什么字都是注册不了呢

是随机出现吗？？？组合问题？？

无论ASCII码还是UNICODE码，英文字母都编码在某一范围里，只要判断一个字符的变量数值是否在这个范围里即可。

这个还真不太好弄如果你知道都有哪些非法字符的话用replace改一下吧譬如你知道的非法字符有*和&和#update表名set字段名=replace(字段名,"*",""),字段名=replace(字段名,"#",""),字段名=replace(字段名,"&","");

using (StreamReader sr = new StreamReader(f, Encoding.Default)) { while (true) { string sLine = sr.ReadLine(); if (sLine == null) break; sw.WriteLine(sLine); } }

#include #include int main(){ char sLine[1024] = ""; scanf("%s",sLine); std::map mapCount; for(int i=0;sLine[i]!=0;i++){ mapCount[sLine[i]]++; } std::map::iterator it = mapCount.begin(); for(;it!=mapCount.end();it++) { printf("%c is %d ",it->first,it->second); } return 0;}

可以把一个字符串replace掉关键字再和原字符串对比，一样则不包含，不一样则包含

#include #include int main(){ char sLine[1024] = ""; scanf("%s",sLine); std::map mapCount; for(int i=0;sLine[i]!=0;i++){ mapCount[sLine[i]]++; } std::map::iterator it = mapCount.begin(); for(;it!=mapCount.end();it++) { printf("%c is %d ",it->first,it->second); } return 0;}

英文字符编码为65-90,97-122

D4=SUM(IF(ISNUMBER(FIND(CHAR(ROW($A$1:$A$26)+{64,96}),C4)),1,0))数组公式向下复制【数组公式，公式输完后，光标放在公式编辑栏同时按下CTRL+SHIFT+回车键，使数组公式生效】或者D4=SUMPRODUCT(LEN(C4)-LEN(SUBSTITUTE(C4,CHAR(ROW($A$1:$A$26)+{64,96}),)))不等于0的含有英文字母。

char cChar = GetChar();if( cChar >= 65 && cChar <= 123 ){ // It"s is a characters.}

可以使用正则表达式来判断，要使用到re模块代码如下：>>> import re>>> s = "safasdfas">>> s2 = "15130351535">>> rt = re.findall("[a-zA-Z]+", s)>>> len(rt)1>>> rt["safasdfas"]>>> rt = re.findall("[a-zA-Z]+", s2)>>> rt[]>>> len(rt)0>>> 如果返回有内容，则说明包含有英文，如上例中s，如果为空列表则说明不包含，如s2

这是我刚刚学C++的时候经常写的

修改字符串的目的是为了得到新的字符串，类String和类StringBuffer都提供了相应的方法。 1．String类提供的方法： 　　concat( ) 　　replace( ) 　　substring( ) 　　toLowerCase( ) 　　toUpperCase( ) 　　◇ public String contat(String str); 　　用来将当前字符串对象与给定字符串str连接起来。 　　◇ public String replace(char oldChar,char newChar); 　　用来把串中出现的所有特定字符替换成指定字符以生成新串。◇ public String substring(int beginIndex)； 　　public String substring(int beginIndex,int endIndex); 　　用来得到字符串中指定范围内的子串。 　　◇ public String toLowerCase(); 　　把串中所有的字符变成小写。 　　◇ public String toUpperCase(); 　　把串中所有的字符变成大写。

字符串对象.equalsIgnoreCase（对比的对象）

String str = “asdfgh”int a ；String test = str.subString(5)System.out.put(test);结果为"h"

来说有些类似于字符的数组。在java这个面向对象的语言中，字符串，无论是常量还是变量，都是用类的对象来实现的。程序中需要用到的字符串可以分为两大类:（1）、一类时创建之后不再做修改和变动的字符串常量；（2）、另一类时创建之后允许再做修改和变化的字符串变量。对于字符串常量，由于程序中经常需要对它做比较、搜索之类的操作，所以通常把它放在一个具有一定名称的对象之中，由程序对该对象完成上述操作。在java中，存放字符串常量的对象属于String类。对于字符串变量，由于程序中经常需要对它做添加、插入、修改之类的操作，所以一般都存放在StringBuffer类的对象中。1 String类字符串常量用String类的对象表示。在前面的程序中，以多次使用了字符串常量。这里首先强调一下字符串常量与字符常量不同。字符常量是用单引号括起的单个字符，例如"a"，" "等。而字符串常量是用双引号括起的字符序列，例如”a”，” ”，”Hellow ”等。Java中的字符串常量，表面上与其他语言中的字符串常量没有什么不同，但在具体实现上却有较大的差异。Java的字符串常量，通常是作为String类的对象存在，由专门的属性来规定它的长度。实际上，对于所有用双引号括起的字符串常量，系统会把它创建一个无名的String类型对象。 （1）、创建字符串常量string对象由于string类的对象表示的是字符串常量，所以一般情况下，一个String字符串一经创建，无论其长度还是其内容，都不能够再更改了。因而，在创建String对象时，通常需要向String类的构造函数传递参数来指定所创建的字符串内容。下面简单列出string类的构造函数及其使用方法。（1）pulic String()这个构造函数用来创建一个空的字符串常量。（2）public String(String value）这个构造函数利用一个已经存在的字符串常量创建一个新的String对象，该对象的内容与给出的字符串常量一致。这个字符串常量可以是另一个String对象，也可以是一个用双引号括起来的直接常量。（3）public string(stringBuffer buffer)这个构造函数利用已经存在的字符数组的内容初始化新建的String对象。创建string对象与创建其他类的对象一样，分为对象的声明和对象的创建两步。这两步可以分成两个独立的语句，也可以在下一个语句中完成。例如下面的句子仅声明一个String对象s:String s;此时s的值为null，要想使用s ,还必须为它开辟内存空间。String s=new String ("ABC");这样，通过调用上面的第二个构造函数，字符串s被置为"ABC"。上述两个语句也可以合并成一个语句如下：String s=new String ("ABC");在java中，还有一种非常特殊而常用的创建String对象的方法。这种方法直接利用双引号括起来的字符串常量为新的String对象“赋值”：String s="ABC";其实这里的“赋值”只是一种特殊的省略写法，前面已经提到，java系统会自动为每一用双引号括起来的字符串常量创建一个String对象，所以这个语句的实际含义与效果与前一个句子完全一致。2、字符串产量的操作String类中所包含的字符串常量的操作很多，如：求字符串的长度。具体方法如下：public int length();用它可以获得当前字符串对象中字符的个数。例如运行下面的代码：String s="Hello!"System.out.println(s.length())；屏幕将显示6，因为字符串"Hello!"的长度为6。需要注意的是在java中，因为每个字符都是占用16个比特的Unicode字符，所以汉字与英文或其他符号相同，也只用一个字符表示就足够了。如果把上面的字符串替换为“近来身体好吗”，则字符串的长度不变，仍然是6。3、判断字符串的前缀和后缀public boolean startsWith(String prefix);public boolean endsWith(String prefix);这两个方法可以分别判断当前字符串的前缀和后缀是否是字符子串。区分字符串的前缀及后缀在某些情况下是非常有用的操作。又例如，居民身份证号码的最后一位代表了居民的性别，奇数为男性，偶数为女性。假设String对象s是某位居民的身份证号码，则下面语句将判断出它的性别：if(s.endsWith("0")||s.endsWith("2")||s.endsWith("4")||s.endsWith("6")||s.endsWith("8")){ System.out.println("此人是女性");}startWith和endWith这两个方法的一个突出优点是不限制所判断的前缀、后缀的长度。例如前一个例子中若需判断的前缀从“6278”变换到“627”，则原方法仍然有效，不需要更改程序。4、字符串中单个字符的查找public int indexOf(int ch);public int indexOf(int ch,int fromIndex);上述两个方法查找当前字符串中某个特定字符出现的位置。第一个方法查找字符ch在当前字符串中的一次出现的位置，即从头向后查找，并返回字符ch出现的位置。如果找不到则返回-1。例如下面的语句将把值0赋给整型量idx:String s="java是面向对象的语言，javaScript是脚本语言";int idx=s.indexOf((int)"J");第二个方法查找字符ch时，在当前字符串中自fromIndex位字符之后向后查找，并返回该字符首次出现的位置。下面语句将查找处指定字符在字符串中的所有出现位置：String s="java是面向对象的语言，javaScript是脚本语言";int i=-1;do{ i=s.indexOf((int)"a",i++); system.out.print(i+" ");}while(i!=-1);运行结果是：1 3 14 16 -1下面的两个方法也是查找字符串中单个字符的方法，不同的是它们从字符串的结尾向字符串的开始部分查找，这里就不再举例了。public int lastIndexOf(int ch);public int lastIndexOf(int ch,int fromIndex);5、字符串中子串的查找public int indexOf(string str);public int indexOf(string str,int fromIndex);public int lastIndexOf(string str);public int lastIndexOf(string str,int fromIndex);在字符串中查找字符子串与在字符串中查找单个字符非常相似，也有四种可供选择的方法，它就是把查找单个字符的四个方法中指定的字符ch换成了指定字符串str。下面的例子从字符串尾部向前，顺序查找所有子串出现的位置：String s="java是面向对象的语言，javaScript是脚本语言";String sub="语言";for (int i=s.length();i!=-1){ i=s.lastIndexOf(sub,i-1); system.out.print(i+" ");}上述程序运行的结果是：26 10 -1另外，还定义有获取字符串中的某个字符的方法：public char charAt(int index);这个方法获取当前字符串第index个字符并返回这个字符（index从0算起）。6、比较两个字符串public int conpareTo(string anotherString);public boolean equals(Object anObject);public boolean equalsIgnoreCase(string anotherString);String类中有三个方法可以比较两个字符串是否相同。方法equals是重载Object类的方法，它将当前字符串与方法的参数列表中给出的字符串乡比较，若两字符串相同，则返回其真值，否则返回假值。方法equalsIgnoreCase与方法equals的用法相似，只是它比较字符串时不计字母大小写的差别。例如，在下面的语句中，分别用equals方法和equalsIgnoreCase方法比较两字符串，则在第一语句中由于区分大小写，所以比较结果为假，而在第二个语句中由于不区分大小写，所以比较结果为真：string s1="Hello!World"; s2="hello!world";boolean b1=s1.equals(s2);boolean b2=s1.equalsIgnoreCase(s2);比较字符串的另一个方法是compareTo(),这个方法将当前字符串与一个参数字符串乡比较，并返回一个整型量。如果当前字符串与参数字符串完全相同，则compareTo()方法返回0；如果当前字符串按字母序大与参数字符串，则compareTo()方法返回一个大于0的整数；反之，若compareTo()方法返回一个小于0的整数，则说明当前字符串按字母序小与参数字符串。在下面的例子中，compareTo比较了三对字符串。String s="abc",s1="aab",s2="abd",s3="abc";int i,j,k;i=s.compareTo(s1);j=s.compareTo(s2);k=s.compareTo(s3);语句执行的结果是分别给i,j,k三个变量赋值1，-1，0。7、连接字符子串public String concat(String str);这个方法将参数字符串连接在当前字符串的尾部，并返回这个连接而成的长字符串，但是当前字符串本身并不改变。如下面的例子：String s="Hello!";System.out.println(s.concat("World!"));System.out.println(s);运行结果是：Hello!World! //连接后的新字符串Hello! //原字符串没有改变2 StringBufferjava中用来实现字符串的另一个类是 StringBuffer类，与实现字符串常量的String类不同，StringBuffer类的对象可以扩充和修改的字符串变量。（1）、创建字符串变量-- StringBuffer对象由于 StringBuffer表示的事可扩充、修改的字符串，所以在创建 StringBuffer类的对象时并不一定要给出初值。 StringBuffer类的构造函数有以下几个：public StringBuffer();public StringBuffer(int length);public StringBuffer(String str);第一个函数创建了一个空的 StringBuffer对象。第二个函数给出了新建的 StringBuffer对象的长度，第三个函数利用一个已经存在的字符串String对象来初始化StringBuffer对象。下面语句是用三种不同的方法创建字符串的例子。StringBuffer MyStrBuff1=new StringBuffer();StringBuffer MyStrBuff2=new StringBuffer(5); StringBuffer MyStrBuff3=new StringBuffer("Hello,Guys!");需要注意的是，其中第一个对象MyStrBuff1并没有相应的内存单元，需扩充之后才能使用。（2）、字符串变量的扩充、修改与操作StringBuffer类有两组用来扩充其中所包含的字符的方法，分别是：public StringBuffer append(参数对象类型 参数对象名);public StringBuffer insert(int 插入位置，参数对象类型 参数对象名);append方法将指定的参数对象转化成字符串，附加在StringBuffer字符串之后，而insert方法则在指定的位置插入给出的参数对象所转化而得的字符串。附加或插入的参数对象可以使各种数据类型的数据，如int,double,char,String等。参看下面的例子：StringBuffer MyStrBuff1=new StringBuffer();MyStrBuff1 append("Hello,Guys!");System.out.println(MyStrBuff1.toString());MyStrBuff1.insert（6，30）；System.out.println(MyStrBuff1.toString());上述执行的结果是：Hello,Guys!Hello,30 Guys!需要注意的是，若希望StringBuffer在屏幕上显示出来，则必须首先调用toString方法把它变成字符串常量，因为PrintStream的方法println()不接受StringBuffer类型的参数。StringBuffer还有一个较有用的方法来修改字符串：public void setCharAt(int index,char ch);这个方法可以将指定位置的字符用给定的另一个字符来替换。例如下面的语句将愿意为“山羊”的字符串变成“外套”：StringBuffer MyStrBuff=new StringBuffer("goat");MyBuff.setCharAt(0,"c");（3）、字符串的赋值和加法字符串是经常使用的数据类型，为了编程方便，java编译系统中引入了字符串的加法和赋值。参看下面的例子：String MyStr="Hello,";MyStr=MyStr+"Guys!";这两个语句出看似乎有问题，因为String是可变的字符串常量，实际上它们是合乎语法规定的，分别相当于：String MyStr=new StringBuffer().append("Hello").toString();MyStr=new StringBuffer().append(MyStr).append("Guys!").toString();由于这种赋值和加法的简便写法非常方便实用，所以在实际编程中用的很多。3 Java Application命令行参数Java Application是用命令行来启动的，命令行参数就成为向Java Application传入数据的常用而有效的手段。现通过下例来考察如何使用命令行参数。见例程UseComLParameter.java该例的功能是从命令行利用命令行参数读入两个整数，再把它们相乘后输出。假设将上述程序保存为一个 UseComLParameter.java文件，经编译后生成 UseComLParameter.class文件，则执行这个程序的命令行应该是如下格式：java UseComLParameter 52 -4这里，java是用来运行字节码的java解释器，UseComLParameter是所运行的字节码文件名（即所执行的类名），52和-4分别是两个命令行参数。可以看出，java的命令行参数跟在命令行主类名的后面，参数之间用空格分隔。如果命令行参数本身就带有空格，则可以用双引号将整个参数括起来以示区别，例如“a dog”就是一个完整的命令行参数。Java Application程序中用来接受命令行参数的数据结构的是main()方法的参数args[]，这个参数是一个字符串数组，其中的每个元素都是一个字符串，这些字符串来自于用户与类名同时输入的命令行参数，每个字符串保存一个命令行参数供程序使用，用户输入了几个命令行参数，数组args[]就有几个元素。另外需要注意的是，所有命令行参数都以字符串String类型的对象形式存在，如果希望把参数作为其他类型的数据使用，则还需要作相应的类型转换。 可见，命令行参数是提供该整个程序的参数，每次运行时使用不同的命令行参数，就有不同的运行结果；使用命令行参数可以提高程序的灵活性和适应性。不过在使用命令行参数时要注意数组越界问题，程序运行是系统将自动检查用户输入了多少个命令行参数并逐个地保存在args[]中，但是如果程序不检查用户到底数入了多少个命令行参数而直接访问args[]某下标地数组元素，则可能造成数组越界异常。

告诉你一个想法，设置三个变量表示数字，字母和其他字符。使用输入流。每个输入字符，判断这个字符的asc码，尽可能多的字母，数字的号码的数量。根据每次的一个相应的变量1，最后的输出变量，分别

楼上的说法都很正确，我就不用再回答了

java中两个字符串如何比较大小 有三种方法实现 第一种直接用字符串类的pareTo方法： String t1="20131011"; String t2="20131030"; int result = t1pareTo(t2);第二种是把这个日期字符串转换成long： SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd"); Date d1 = sdf.parse(t1); Date d2 = sdf.parse(t2); long result = d1.getTime()-d2.getTime();第三种是把日期字符串转换成整形int：int int1 = Integer.parseInt(t1); int int2 = Integer.parseInt(t2); int result = int1-int2;注：result大于0，则t1>t2； result等于0，则t1=t2； result小于0，则t1 字符串大小比较的规则? 比较的时候，从字符串左边开始，一次比较每个字符，直接出现差异、或者其中一个串结束为止。 比如ABC与ACDE比较，第一个字符相同，继续比较第二个字符，由于第二个字符是后面一个串大，所以不再继续比较，结果就是后面个串大。 再如ABC与ABC123比较，比较三个字符后第一个串结束，所以就是后面一个串大。 所以，长度不能直接决定大小，字符串的大小是由左边开始最前面的字符决定的。 java怎么比较字符串大小？ 比较两个字符串的的大小 str1和str2分别是两个字符串str1==str2或者是 str1.equals(str2)如果要是两个字符串忽略大小写的话用 str1.equalsIgnoreCase(str2)也可以是 str1pareTo(str2) 第二个用加号连接起来就可以了 C语言中字符串的大小指的是什么 以字符是ASCII值确定，憨较规则是，从第一个字符开始，顺次向后直到出现不同的字符为止，然后以第一个不同的字符的ASCII值确定，例如上面的”abc”和"aabdfg"，由于第一个字符相同，都是"a"所以看下一个字符，第二个字符，一个是"b",一个是‘a"，由于b的ASCII值比a的ASCII值大，所以，这二个字符串的比较结果是"abc">"aabdfg" c语言中比较字符串的strcmp函数是怎么比较大小的？ strcmp（s1,s2） 对两个字符串进行比较,逐一比较字符的ascii码，a为97,A为65 所以a>A;分出大小后面不再比较； 如果s1>s2，返回1； 如果s1=s2，返回0； 如果s1 在C语言中字符串的大小怎么比较啊？ strcmp 原型：extern int strcmp(char *s1,char * s2); 用法：#include 功能：比较字符串s1和s2。 说明： 当s1 当s1=s2时，返回值=0 当s1>s2时，返回值>0 即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇 ""为止。如： "abcdefg"和"12"，首先比较"a"和"1"，"a"的ASC码是97，"1"的ASC码是49，所以"abcdefg"> "12",返回值是97-49=48 "abc"和"ABC"，首先比较"a"和"A"，"a"的ASC码是97，"A"的ASC码是65，所以"abc"> "ABC",返回值是97-65=32 "1000"和"2"，首先比较"1"和"2"，"1"的ASC码是49，"2"的ASC码是50，所以"1000"< "2",返回值是49-50=-1 字符串大小比较 如果单纯比较长度,直接调用类似于strlen()之类的函数就可以,加以比较即可. 如果比较字符串的大小,则比较的是字符的ASCII编码的大小.你搜索一下ASCII码表就可以得知每一个ASCII字符的大小. 参考wpyz/noip/11-1.asp 在比较时,设置一个计数器,从零开始,一直循环到最短的那个字符结束,一位一位进行比较, 1.如果 字符串1的第n位的ASCII码值 等于 字符串2的第n位的ASCII码值 则 继续比较下一位 2.如果 字符串1的第n位的ASCII码值 大于 字符串2的第n位的ASCII码值 则 输出结果:1,表示字符串1 > 字符串2; 3.如果 字符串1的第n位的ASCII码值 小于 字符串2的第n位的ASCII码值 则 输出结果:-1 表示字符串1 < 字符串2; 4.如果 每一位的ASCII码值都相等,而且长度相同, 则 输出结果:0 表示字符串1 == 字符串2; 5.如果 字符串1是字符串2的前m位,例如 abcd 与abcdef 比较, 则 字符串1 原因是,到第5位时,字符串1的ASCII值是0,而字符串2的ASCII值为"e",即十进制的101,当然是字符串2大了. 具体到 cds和lesoqd 从第一位开始,"c"和"l"比较,当然是"c" < "l"了,所以,"cds" < "lesoqd" 常用的几位ascii的顺序从小到大为: 0..9, A..Z, a..z. 谁编个比较2个字符串大小的程序 我这个简单 #include bi(char a[],char b[]) { int x,y; x=0; y=0; while(a[x]==b[x]&&a[x]!="") x++; if(a[x]==""&&b[x==""]) y=0; else y=a[x]-b[x]; if(y==0) printf(" s1=s2 "); else if(y>0) printf(" s1>s2 "); else printf(" s1 } void main() { char s1[100],s2[100]; gets(s1); gets(s2); bi(s1,s2); } C++字符串比较大小 字符串的比较是逐个相应字符进行比较（比较他们的ASCII码），直到有两个字符不相等为止，ASCII码大的字母所在字符串就大，与字符串长度无关。对两个相等长度的字符串，若每个字符都比较完毕后仍相等，则两字符串相等；对不等长的字符串，若当短的字符串比较完毕时所有字符仍相等，则长度较长的字符串大！

.equalsIgnoreCase()

字符串值就是该字符串的值，如果想赋值直接赋值就可。

假设要比较的字符串为s1,s21.string.Equals(string1, string2, StringComparison.OrdinalIgnoreCase) 这就相当于java的equalsIgnoreCase() 但它是静态方法 并不由要比较的字符串调用，避免了null异常2.s1.ToLower()==s2.ToLower() 这个方法可能引发null异常 必须保证两个字符串都不为空 而且效率较低

解释一下==号，他比较的是一个对象在内存中的地址值，比如2个字符串对象String s1 = new String("str");String s2 = new String("str");如果用==号比较，会返回false，因为创建了两个对象，他们在内存中地址的位置是不一样的。equals的情况比较复杂，它是java.lang.Object类中的一个方法。因为java中所有的类都默认继承于Object，所以所有的类都有这个方法。在Object类源码中是这样写的。public boolean equals(Object obj) { return (this == obj);}他同样使用==号进行内存地址的比较。但是许多java类中都重写了这个方法，比如String。public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = count; if (n == anotherString.count) { char v1[] = value; char v2[] = anotherString.value; int i = offset; int j = anotherString.offset; while (n-- != 0) { if (v1[i++] != v2[j++]) return false; } return true; } } return false; }String里的方法，如果==号比较不相等，还会进行一下值的比较。所以equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的。如果没有重写该方法，那么他和==号等价。

equals 区分大小写 abc==ABC falseequalsIgnoreCase 不区分 abc==ABC true

equals 区分大小写equalsIgnoreCase 不区分大小写

字节跳动和抖音不是一个公司，字节跳动属于北京字节跳动科技有限公司，抖音属于北京微播视界科技有限公司，北京字节跳动科技有限公司和抖音创始人均为张一鸣。北京字节跳动科技有限公司，成立于2012年3月，是最早将人工智能应用于移动互联网场景的科技企业之一，是中国北京的一家信息科技公司，地址位于北京市海淀区知春路甲48号。抖音短视频，是一款音乐创意短视频社交软件，由今日头条孵化，该软件于2016年9月20日上线，是一个面向全年龄的音乐短视频社区平台。用户可以通过这款软件选择歌曲，拍摄音乐短视频，形成自己的作品，会根据用户的爱好，来更新用户喜爱的视频。扩展资料字节跳动人工智能实验室成立于2016年，旨在针对人工智能相关领域的长期性和开放性问题进行探索，帮助公司实现对未来发展的构想。其独立研发的“今日头条”客户端，通过海量信息采集、深度数据挖掘和用户行为分析，为用户智能推荐个性化信息，从而开创了一种全新的新闻阅读模式。2020年1月8日，火山小视频和抖音正式宣布品牌整合升级，火山小视频更名为抖音火山版，并启用全新图标。参考资料来源：百度百科-北京字节跳动科技有限公司参考资料来源：百度百科-抖音

1，首字符必须是字母且长度为6到12的正则：var re = /^[a-zA-Z].{5,11}$/;这里点是匹配所有的字符，如果只想匹配 a-z0-9A-Z_ 就把中间的点换成w ，一般如果是用户名之类的基本都是w了。2，失去焦点的事件是 onblur。

#include<stdio.h>int main(){int i;char a[7]="Smile!";printf("%s%s%s ",a,a,a);printf("%s%s ",a,a);printf("%s ",a);return 0;}

例如：JSON字符串:var str1 = "{ "name": "cxh", "sex": "man" }";JSON对象:var str2 = { "name": "cxh", "sex": "man" };一、JSON字符串转换为JSON对象要使用上面的str1，必须使用下面的方法先转化为JSON对象：//由JSON字符串转换为JSON对象var obj = eval("(" + str + ")");或者var obj = str.parseJSON(); //由JSON字符串转换为JSON对象或者var obj = JSON.parse(str); //由JSON字符串转换为JSON对象然后，就可以这样读取：Alert(obj.name);Alert(obj.sex);特别注意：如果obj本来就是一个JSON对象，那么使用eval（）函数转换后（哪怕是多次转换）还是JSON对象，但是使用parseJSON（）函数处理后会有问题（抛出语法异常）。

不知道，

QS：隔离开关FU：熔断器KM：接触器KA：继电器KI：过流(欠流)继电器KT：时间继电器SB：按钮开关SQ：限位开关

百度一下

如图，调出查找替换窗口，在查找内容里输入~*，替换为输入你需要更改后的内容，就可以了。*号前加~就是为了去掉*号的通配符作用。

string.replace(str,"@@","\")就可以了字符替换表 = { [""] = "\"; ["""] = ""; ["N"] = "n";}str = string.replace( "替换"这里的N",".|:", 字符替换表 )io.open(); io.print( str )

可以使用trim()方法去掉空格

确定无疑是分成数组的 自己可以测试的嘛 这么一个函数

使用[//,//;]

split 使用一个或多个解析字符串（默认情况下为空格）将字符串变量 strvar 的内容拆分为一个或多个部分，以便生成新的字符串变量。 因此，拆分对于分离“字”或字符串变量的其他部分很有用。 strvar 本身没有修改。 为 v 的每个单词创建变量v＃，用空格分隔 同上所述，但在逗号上分成单词或短语并生成变量 newv＃ 同上所述，但不要修剪前导或尾随空格 无论可能的新变量数量是多少，都只创建newv1，newv2和newv3 同上所述，并尽可能转换为数字类型 generate(stub) ：用 stub 开始新的变量名; 默认是strvar。 parse(parse_strings)：解析指定的字符串; default是解析空格。 limit(#) ：最多创建#new变量 notrim ：不修剪原始变量的前导或尾随空格。 destring：将 destring 应用于新的字符串变量，尽可能用数字变量替换初始字符串变量 ignore("chars")：删除指定的非数字字符强制将非数字字符串转换为缺失值。 float： 生成数值变量为float类型。 percent ：将百分比变量转换为小数形式。 generate(stub) 指定新变量名的起始字符，以便生成新变量 stub1 ，stub2 等。 stub 默认为 strvar 。 parse(parse strings) 指定解析使用一个或多个解析字符串，而不是使用空格。 最常见的是，将指定一个标点字符串。 例如，如果指定了parse（，），则“1,2,3”被分成“1”，“2”和“3”。 您还可以指定1）两个或多个字符串，它们是“单词”的替代分隔符和2）由两个或多个字符组成的字符串。 替代字符串应以空格分隔。 包含空格的字符串应该用“”绑定。 因此，如果指定了解析（，“ ”），则“1,2 3”也被分成“1”，“2”和“3”。 特别注意解析（a b）和解析（ab）之间的区别：第一个，a和b都可以作为分隔符，而对于第二个，只有字符串ab是可接受的。 limit(#) 您还可以指定1）两个或多个字符串，它们是“单词”的替代分隔符和2）由两个或多个字符组成的字符串。 替代字符串应以空格分隔 notrim 指定在解析之前不对前导和尾随空格修剪原始字符串变量。 notrim 与空格上的解析不兼容，因为后者意味着要丢弃字符串中的空格。 您可以指定解析字符，或者默认情况下允许修剪。 destring： 将destring应用于新的字符串变量，尽可能用数字变量替换最初作为字符串创建的变量See [D] destring。 ignore(), force, float, percent; see [D] destring. split用于将字符串变量拆分为两个或多个组件部分，例如“words”。 您可能需要更正错误，或者字符串变量可能是您的真正复合 希望在做更多分析之前进行细分。 在给定一个或多个分隔符的情况下，split 应用的基本步骤是在字符串中查找这些分隔符，然后生成一个或多个新的字符串变量，每个变量都包含原始的一部分。 分隔符可以是例如空格或其他标点符号，但它们又可以是包含多个字符的字符串。 默认分隔符是空格。 用于细分字符串变量的键字符串函数，实际上通常是字符串，是strpos（），它查找分隔符的位置，substr（），它提取字符串的一部分。 （参见[FN]字符串函数。）split 是基于这些函数的使用。 如果没有通过拆分分隔符来定义问题，则可能需要直接使用substr（）。 假设您有一个字符串变量 date ，其中包含“21011952”形式的日期，以便最后四个字符定义一年。 该字符串不包含分隔符。 要提取年份，您将使用substr（date，-4,4）。 再次假设过去12个月中每个女性的产科病史都是由含有“nppppppppppbn”等值的str12变量记录的，其中p，b和n表示怀孕，分娩和非怀孕的月份。 再一次，没有分隔符，所以你可以使用 substr（）来细分字符串。 split会丢弃分隔符，因为它假定分隔符与进一步分析无关，或者您可以随意恢复它们。如果这不是您想要的，您可以使用 substr() (和 可能是查找字符串首次出现的位置())。 最后，在我们转向示例之前，将 split 与 egen 函数 ends（）进行比较，它生成字符串的头部，尾部或最后部分。 与所有egen函数一样，此函数仅生成一个新变量。 相反，split 作为一个命令的结果通常会产生几个新变量。 有关更多详细信息和讨论，包括对识别个人姓名的特殊问题的评论, see [D] egen. 当 Stata 的输入以某种方式误读为一个字符串变量时，split可能很有用。 如果您使用剪贴板复制并粘贴到数据编辑器中，例如，在Windows下，但数据是以空格分隔的，您认为单独的变量将被组合，因为数据编辑器需要逗号或制表符分隔的数据。 如果复合变量的某些部分应该是数字字符放入数值变量，你可以同时使用 destring ; 见[D] destring。 这里没有指定generate（）选项，因此新变量将具有名称 var11 ，var12 等。 您现在可能希望使用重命名来生成更具信息性的变量名称。 See[D] rename. 您还可以使用拆分来细分真正的复合材料。 例如，电子邮件地址（例如 tech-support@stata.com ）可能会拆分为“@”： 此序列产生两个新变量：address1，包含“@”之前的电子邮件地址的一部分，例如“tech-support”，以及包含“@”之后的部分的 address2，例如 “ stata.com ” 。 分隔符本身“@”被丢弃。 由于未指定generate（），因此名称地址在命名新变量时用作存根。 split 显示创建的新变量的名称，因此您可以快速查看创建的数字是否符合您的期望。 如果个人的详细信息没有意义，而您只想要机器名称 or 接下来假设一个字符串变量包含应该分为原告和被告变量的法律案件的名称。 分隔符可以是 “V”，“V”，“VS”和“VS.”。（我们假设使用大写和小写的任何不一致都由字符串函数 strupper（）处理; 请参阅[FN]字符串函数。）特别注意我们的前导和尾随空格 分隔符的详细说明：第一个分隔符是“V”，例如，不是“V”，它会错误地将“GOLIATH V DAVID”分成“GOLIATH”，“DA”和“ID”。 给出了替代分离器作为parse（）的参数： 再次使用变量的默认命名并调用分隔符被丢弃，我们期望新变量case1和case2，而不创建case3或其他新变量。 每当找不到指定的分隔符时，case2将具有空值，因此我们可以检查： 假设一个字符串变量包含由制表符分隔的字段。 例如，导入分隔的选项卡保持不变。 知道选项卡是char（9），我们可以输入 p（char（9））不起作用。 parse（）的参数是字面意思，但是动态函数的评估可以作为宏替换的一部分。 最后，假设一个字符串变量包含在括号中绑定的子字符串，如(1 2 3)(4 5 6)。例如,。分割数据,p (“)”) split stores the following in r(): Scalars r(nvars) number of new variables created r(varlist) names of the newly created variables 假设输入在某种程度上被误读为一个字符串变量，例如，当您复制并粘贴到数据编辑器中时，数据是以空格分隔的： 电子邮件地址拆分为“@”： 假设一个字符串变量包含法律案件的名称，应将其分成原告和被告的变量。 分隔符可以是“ V ”，“V”，“VS”和“VS.”。 特别注意我们的分隔符细节中的前导和尾随空格：第一个分隔符是“ V ”，例如，不是“V”，它会错误地将“GOLIATH V DAVID”分成“GOLIATH”，“DA”和“ID” ”。 替代分隔符作为parse（）的参数给出： 问题的迹象是创建两个以上的变量和任何具有空值的变量，因此请检查： 假设字符串变量包含由制表符分隔的字段。 例如，导入分隔的选项卡保持不变。 知道选项卡是char（9），我们可以输入 p（char（9））不起作用。 parse（）的参数是字面意思，但是动态函数的评估可以作为宏替换的一部分。 假设一个字符串变量包含括在括号中的子串，例如（1 2 3）（4 5 6）。 在这里，我们可以拆分右括号，如果需要，可以在之后替换它们。 例如， 将 var1 拆分为两个字符串变量，基于“ ”（空格）作为解析字符 删除新创建的变量 var11 和var12 将 var1 拆分为两个变量，基于“ ”作为解析字符，并将变量命名为 geog1和 geog2 使用逗号作为解析字符将 var1 拆分为两个变量，并将变量命名为geog1 和 geog2 使用逗号后跟空格和空格作为解析字符将日期拆分为变量，并使用ndate 作为新变量名称的前缀 使用逗号作为解析字符将x拆分为变量，并尝试用数字变量替换新的字符串变量

x=split("123456----hdahdkahd----2013.1.1","----")Text1.Text=x(1)

java拆分字符串使用string类的spilt方法，针对某个分隔符来分割一个字符串，示例如下：x0dx0apublic class StringSplit {x0dx0a public static void main(String[] args) {x0dx0a String sourceStr = "1,2,3,4,5";//一个字符串x0dx0a String[] sourceStrArray = sourceStr.split(",");//分割出来的字符数组x0dx0a for (int i = 0; i < sourceStrArray.length; i++) {x0dx0a System.out.println(sourceStrArray[i]);x0dx0a }x0dx0ax0dx0a // 最多分割出3个字符串x0dx0a int maxSplit = 3;x0dx0a sourceStrArray = sourceStr.split(",", maxSplit);x0dx0a for (int i = 0; i < sourceStrArray.length; i++) {x0dx0a System.out.println(sourceStrArray[i]);x0dx0a }x0dx0a }x0dx0a}x0dx0a输出结果为：x0dx0ax0dx0a2x0dx0a4x0dx0a1x0dx0a3,4,5

#include <stdio.h>#include <string.h>#include <stdlib.h>/*定义结构体word内存放单词和个数*/typedef struct{ char *str1[20]; int strC; }WordAndCnt;//定义total函数计算总的单词个数void total(char* str,WordAndCnt* wac){ //int sum=0,i; int i,j; wac->strC=0; for(i=0,j=0;str[i]!="#" && str[i]/*避免忘记输#的尴尬*/;i++) //你程序的输入是以字符"#"结尾的吧？不管了，你写的是这样，我就默认"#"结尾 { if((str[i]>="a" && str[i]<="z") || (str[i]>="A" && str[i]<="Z"))//确定起始字符的位置 { if(i==0 || !((str[i-1]>="a" && str[i-1]<="z") || (str[i-1]>="A" && str[i-1]<="Z"))) { j=i; } //j++; } if(i>0 && !((str[i]>="a" && str[i]<="z") || (str[i]>="A" && str[i]<="Z")) && ((str[i-1]>="a" && str[i-1]<="z") || (str[i-1]>="A" && str[i-1]<="Z")))//结束字母的位置 { wac->str1[wac->strC]=(char*)calloc(i-j+1,sizeof(char));//分配空间 并初始化 strncpy(wac->str1[wac->strC],str+j,i-j); wac->strC++; } } if(i!=j)//把最后一个字符串也拷贝到str1里 { wac->str1[wac->strC]=(char*)calloc(i-j+1,sizeof(char));//分配空间 并初始化 strncpy(wac->str1[wac->strC],str+j,i-j); wac->strC++; } printf("total=%d ",wac->strC); //return(sum);}void main(){ char str[1000]; WordAndCnt wac; memset(str,0,1000); printf("输入一串英文： "); gets(str); total(str,&wac); printf(" "); if(wac.strC>0) { for(int i=0;i<wac.strC;i++) { printf("输入的第%d个单词是:%s ",i+1,wac.str1[i]); } }}

?号代表一个字符。*号代表任意个字符，包括0个字符。查找的时候记得勾上单元格查找，不然你找王某的话，王某某的单元格也会被找到，因为该单元格包含王某。

举个例子：做Docker构建镜像的练习，写了下面这个 Dockerfile 文件，其中 yum install tomcat 执行过程中需要用键盘输入两次字符”y”以便确认选项，Dockerfile 脚本命令如下：FROM centosMAINTAINER quicmous "xuyeping@yeah.net"RUN yes y | head -2 | yum install tomcat -yRUN echo "Hi, I am in your container"EXPOSE 8012345其中 yes 命令可以无限重复产生其后面的字符”y”，head 命令只选择其中两次重复输入，也就是两个字符”y”。命令行yes y | head -2 | yum install tomcat -y可以自动完成全部操作，中间过程不需要人工干预。

你的第三个测试用例有些问题>>> remove_duplicates("The quick brown fox jumps over the lazy dog")"The quck borwn fx jmps v t lazy dg"应该是>>> remove_duplicates("The quick brown fox jumps over the lazy dog")"The quick brown fx jmps v t lazy dg"==============================================================#coding: utf-8import stringdef remove_duplicates(raw):"""Returns a string which is the same as the argument except only the firstoccurrence of each letter is present. Upper and lower case letters aretreated as different. Only duplicate letters are removed, other characterssuch as spaces or numbers are not changed>>> remove_duplicates("Mississippi")"Misp">>> remove_duplicates("apple")"aple">>> remove_duplicates("The quick brown fox jumps over the lazy dog")"The quick brown fx jmps v t lazy dg">>> remove_duplicates("121 balloons 2 u")"121 balons 2 u""""ret = []for l in raw:if l in string.letters and l in ret:continueret.append(l)return "".join(ret)if __name__ == "__main__":import doctestdoctest.testmod()

普通字符串可以用多种方式编码成unicode字符串，具体要看你究竟选择了哪种编码：unicodestring=u"helloworld"#将unicode转化为普通python字符串："encode"utf8string=unicodestring.encode("utf-8")asciistring=unicodestring.encode("ascii")isostring=unicodestring.encode("iso-8859-1")utf16string=unicodestring.encode("utf-16")#将普通python字符串转化为unicode："decode"plainstring1=unicode(utf8string,"utf-8")plainstring2=unicode(asciistring,"ascii")plainstring3=unicode(isostring,"iso-8859-1")plainstring4=unicode(utf16string,"utf-16")assertplainstring1==plainstring2==plainstring3==plainstring4

没有的

指针实现:char *mystrcat(char *s,char *ct) //字符串连接{ while(*(s++)); s--; while(*ct) *(s++) = *(ct++); return s;}数组实现:#include<stdio.h>void mystrcat(char s[],char ct[]) //字符串连接{ int i; int length1 = 0,length2 = 0; while(s[length1++]); while(ct[length2++]); length1--; for(i = length1;i < length1+length2;i++) s[i] = ct[i-length1];}int main(){ char s[100] = "123456"; char ct[] = "dfhjk"; mystrcat(s,ct); printf("%s ",s); return 0;}

可以试一试这个 没有其他的函数#include "stdio.h"void main(){ char str1[21], str2[21],str3[41]; scanf("%s", str1); scanf("%s", str2); int a; for(int i=0;i<21;i++) { if(str1[i]=="") a=i; } for(int j=0;j<41;j++) { if(j<a) str3[j]=str1[j]; if(j>=a) str3[j]=str2[j-a]; } printf(str3);}

#include<stdio.h>void main(){char s1[80],s2[40];int i=0,j=0;printf(" input stringl:");scanf("%s",s1);printf("input string2:");scanf("%s",s2);while(s1[i]!="")i++;while(s2[j]!="")s1[i++]=s2[j++];s1[i]="";printf("The new string is:%s ",s1);}扩展资料：main函数用法1、C++中的main函数C++继承了C语言的大部分特性，因此保留了“程序总是从main函数开始执行，且总是默认从main函数的return语句或结尾处结束运行”这一传统，但是要注意，C++中的main函数要想作为程序执行的出入口，必须写在全局(Global)范围，不能写成某个结构体或某个类的成员。虽然main函数可以作为结构体或者类的成员函数，但相应地会失去作为程序出入口的功能。C++中全局main函数的书写格式与C语言完全相同，功能也完全相同，且同一C++程序同样只能有一个全局main函数。2、Java中的main函数Java同样是以main函数作为程序执行出入口的，但Java作为“更纯洁”的面向对象语言，它的main函数与C/C++有很大的不同。首先，返回值的概念淡化，在Java Application中main不允许返回值，因此int main是被禁止的，必须使用void main，int main仅限在JavaBean中使用。其次，Java中所有的函数必须属于类，没有什么全局函数一说，因此main函数不能是全局成员，必须是某个类的成员。第三，由于main函数变成了类的成员函数，因此要想直接被系统调用，还必须使用public static使其成为静态函数并具有公开权限。第四，main函数的参数被简化，只需要提供字符串数组即可，不需要提供参数个数(这是由于Java的数组具有下标检查功能的原因)Java Application中的main函数一般格式如下(类名可以自定义，但保存为Java源码时，主文件名必须与类名相同，否则可能无法运行)public class MainDemo{public static void main(String[]args){//TODO:在此处写入主函数的内容}}Java Applet的运行机制与Java Application完全不同，因此不需要main函数3、C#中的main函数C#中的main函数与Java大同小异，同样必须是类成员，同样使用字符串数组作唯一参数，同样是静态函数，同样的void main，与之不同的是：main的首字母变成了大写，即"Main函数“，且是否限定为public级别已经无所谓了(默认没有public，但某些场合可能还是需要public)另外，需要注意的是，C#中不再有”类名必须与主文件名同名“的限制，即使类名不和主文件名相同，程序照样可以运行。C#应用程序中的main函数默认是这样的(注意main的首字母已是大写)C#和C/C++、java不同的是C#不在拘泥于必须从main()函数开始执行，C#是属于事件触发。class Program{static void Main(string[]args){

char *strcat(char *dest,const char *src){char *addr=dest;int i=0,j=0;if(dest==NULL)return NULL;while(*(dest+i)!="")i++;while(*(src+j)!=""){*(dest+i++)=*(src+j++);}*(dest+i)="";return addr;}

肯定不能了，，strcat是把第二个字符串接在一个第一个字符串结尾，它并不会关心是否破坏其他数据，，这都数组越界了，，有可能会造成错误

char *p;char a[MAX],b[MAX];int i,j,cur;for(i=0;i<=MAX;i++){ if(!a[i])cur=i}j=0;whlie(!b[j]){ if(cur+j>=MAX)return 1; a[cur+j+1]=b[j]; j++;}return 0;

void strcat(char s1[],char s2[]){int i,j; for(i=0;s1[i]!="";i++); for(j=0;s2[j]!="";j++) s1[i++]=s2[j]; s1[i]="";}void strcpy(char a[],char b[]){ int i=0,j=0; while((a[i++]=b[j++])!="");}int strcmp(char s1[],char s2[]){int i;for(i=0;s1[i]!=""&&s2[i]!="";i++){ if(s1[i]>s2[i]) return 1; else if(s1[i]<s2[i]) return -1;}if(s1[i]==""&&s2[i]=="") return 0;else if(s1[i]=="") return -1;else return 1;}int strlen(char s[]){ int len=0 ,i; for(i=0;s[i]!="";i++) len++;return len;}

这只是一个单词的前几个字母 外国人也是为了方便好记啊

string a="abcd";string b="qwer";char c[256];strcat(a,b);//a="abcdqwer"c=&a;

有啊，第一的没了

把p1从下标为2的地方开始，和p2下标为1的地方开始拼接为一个字符串；结果是cdBCD;再拷贝到str下标为1的地方开始；p1的ab比没有在拼接字符串的范围内，