python、c++和java字符串处理比较

python、c++和java字符串处理比较

1、python：

a、格式化字符串：“{序号：<填充><对齐><宽度><，>< . 精度><类型>}.format（变量名）
python字符串常用方法：
方法及描述（常用方法排序）

len(string)返回字符串长度
split(str="", num=string.count(str))以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回string中str的开始索引值，否则返回-1
rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找.
index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常。
rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始.
replace(old, new [, max])把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
count(str, beg= 0,end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
strip([chars])在字符串上执行 lstrip()和 rstrip()
lstrip()截掉字符串左边的空格或指定字符。
rstrip()删除字符串字符串末尾的空格.
max(str)返回字符串 str 中最大的字母。
min(str)返回字符串 str 中最小的字母。
join(seq)以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
python字符串不常用方法：
capitalize()将字符串的第一个字符转换为大写
center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
bytes.decode(encoding="utf-8", errors="strict")Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
encode(encoding='UTF-8',errors='strict')以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
endswith(suffix, beg=0, end=len(string))检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
isalpha()如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()如果字符串只包含数字则返回 True 否则返回 False..
islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()如果字符串中只包含空白，则返回 True，否则返回 False.
istitle()如果字符串是标题化的(见 title())则返回 True，否则返回 False
isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
lower()转换字符串中所有大写字符为小写.
maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
splitlines([keepends])按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
startswith(substr, beg=0,end=len(string))检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
swapcase()将字符串中大写转换为小写，小写转换为大写
title()返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
translate(table, deletechars="")根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()转换字符串中的小写字母为大写
zfill (width)返回长度为 width 的字符串，原字符串右对齐，前面填充0
isdecimal()检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

2、c++：

常见方法：assign（），size（），lenth（），append（），substr（），swap（），replace（），erase（），insert（）

1. 构造函数
   string 类有多个构造函数，用法示例如下：

string s1();  // si = ""
string s2("Hello");  // s2 = "Hello"
string s3(4, 'K');  // s3 = "KKKK"
string s4("12345", 1, 3);  //s4 = "234"，即 "12345" 的从下标 1 开始，长度为 3 的子串

为称呼方便，本教程后文将从字符串下标 n 开始、长度为 m 的字符串称为“子串(n, m)”。

string 类没有接收一个整型参数或一个字符型参数（单引号）的构造函数。下面的两种写法是错误的：

string s1('K');
string s2(123);

2. 对 string 对象赋值
   可以用 char* 类型的变量、常量，以及 char 类型的变量、常量对 string 对象进行赋值。例如：

string s1;
s1 = "Hello";  // s1 = "Hello"
s2 = 'K';  // s2 = "K”

string 类还有 assign 成员函数，可以用来对 string 对象赋值。assign 成员函数返回对象自身的引用。例如：

string s1("12345"), s2;
s3.assign(s1);  // s3 = s1
s2.assign(s1, 1, 2);  // s2 = "23"，即 s1 的子串(1, 2)
s2.assign(4, 'K');  // s2 = "KKKK"
s2.assign("abcde", 2, 3);  // s2 = "cde"，即 "abcde" 的子串(2, 3)

3. 求字符串的长度
   length 成员函数返回字符串的长度。size 成员函数可以实现同样的功能。
4. string对象中字符串的连接
   除了可以使用+和+=运算符对 string 对象执行字符串的连接操作外，string 类还有 append 成员函数，可以用来向字符串后面添加内容。append 成员函数返回对象自身的引用。例如：

string s1("123"), s2("abc");
s1.append(s2);  // s1 = "123abc"
s1.append(s2, 1, 2);  // s1 = "123abcbc"
s1.append(3, 'K');  // s1 = "123abcbcKKK"
s1.append("ABCDE", 2, 3);  // s1 = "123abcbcKKKCDE"，添加 "ABCDE" 的子串(2, 3)

5. string对象的比较
   除了可以用 <、<=、==、!=、>=、> 运算符比较 string 对象外，string 类还有 compare 成员函数，可用于比较字符串。compare 成员函数有以下返回值：
   小于 0 表示当前的字符串小；
   等于 0 表示两个字符串相等；
   大于 0 表示另一个字符串小。

例如：

string s1("hello"), s2("hello, world");
int n = s1.compare(s2);
n = s1.compare(1, 2, s2, 0, 3);  //比较s1的子串 (1,2) 和s2的子串 (0,3)
n = s1.compare(0, 2, s2);  // 比较s1的子串 (0,2) 和 s2
n = s1.compare("Hello");
n = s1.compare(1, 2, "Hello");  //比较 s1 的子串(1,2)和"Hello”
n = s1.compare(1, 2, "Hello", 1, 2);  //比较 s1 的子串(1,2)和 "Hello" 的子串(1,2)

6. 求 string 对象的子串
   substr 成员函数可以用于求子串 (n, m)，原型如下：
   string substr(int n = 0, int m = string::npos) const;
   调用时，如果省略 m 或 m 超过了字符串的长度，则求出来的子串就是从下标 n 开始一直到字符串结束的部分。例如：

string s1 = "this is ok";
string s2 = s1.substr(2, 4);  // s2 = "is i"
s2 = s1.substr(2);  // s2 = "is is ok"

7. 交换两个string对象的内容
   swap 成员函数可以交换两个 string 对象的内容。例如：

string s1("West”), s2("East");
s1.swap(s2);  // s1 = "East"，s2 = "West"

8. 查找子串和字符
   string 类有一些查找子串和字符的成员函数，它们的返回值都是子串或字符在 string 对象字符串中的位置（即下标）。如果查不到，则返回 string::npos。string: :npos 是在 string 类中定义的一个静态常量。这些函数如下：
   find：从前往后查找子串或字符出现的位置。
   rfind：从后往前查找子串或字符出现的位置。
   find_first_of：从前往后查找何处出现另一个字符串中包含的字符。例如：
   s1.find_first_of(“abc”); //查找s1中第一次出现"abc"中任一字符的位置
   find_last_of：从后往前查找何处出现另一个字符串中包含的字符。
   find_first_not_of：从前往后查找何处出现另一个字符串中没有包含的字符。
   find_last_not_of：从后往前查找何处出现另一个字符串中没有包含的字符。

下面是 string 类的查找成员函数的示例程序。

#include <iostream>
#include <string>
using namespace std;
int main()
{
    string s1("Source Code");
    int n;
    if ((n = s1.find('u')) != string::npos) //查找 u 出现的位置
        cout << "1) " << n << "," << s1.substr(n) << endl;
    //输出 l)2,urce Code
    if ((n = s1.find("Source", 3)) == string::npos)
        //从下标3开始查找"Source"，找不到
        cout << "2) " << "Not Found" << endl;  //输出 2) Not Found
    if ((n = s1.find("Co")) != string::npos)
        //查找子串"Co"。能找到，返回"Co"的位置
        cout << "3) " << n << ", " << s1.substr(n) << endl;
    //输出 3) 7, Code
    if ((n = s1.find_first_of("ceo")) != string::npos)
        //查找第一次出现或 'c'、'e'或'o'的位置
        cout << "4) " << n << ", " << s1.substr(n) << endl;
    //输出 4) l, ource Code
    if ((n = s1.find_last_of('e')) != string::npos)
        //查找最后一个 'e' 的位置
        cout << "5) " << n << ", " << s1.substr(n) << endl;  //输出 5) 10, e
    if ((n = s1.find_first_not_of("eou", 1)) != string::npos)
        //从下标1开始查找第一次出现非 'e'、'o' 或 'u' 字符的位置
        cout << "6) " << n << ", " << s1.substr(n) << endl;
    //输出 6) 3, rce Code
    return 0;
}

9. 替换子串
   replace 成员函数可以对 string 对象中的子串进行替换，返回值为对象自身的引用。例如：

string s1("Real Steel");
s1.replace(1, 3, "123456", 2, 4);  //用 "123456" 的子串(2,4) 替换 s1 的子串(1,3)
cout << s1 << endl;  //输出 R3456 Steel
string s2("Harry Potter");
s2.replace(2, 3, 5, '0');  //用 5 个 '0' 替换子串(2,3)
cout << s2 << endl;  //输出 HaOOOOO Potter
int n = s2.find("OOOOO");  //查找子串 "00000" 的位置，n=2
s2.replace(n, 5, "XXX");  //将子串(n,5)替换为"XXX"
cout << s2 < < endl;  //输出 HaXXX Potter

10. 删除子串
    erase 成员函数可以删除 string 对象中的子串，返回值为对象自身的引用。例如：

string s1("Real Steel");
s1.erase(1, 3);  //删除子串(1, 3)，此后 s1 = "R Steel"
s1.erase(5);  //删除下标5及其后面的所有字符，此后 s1 = "R Ste"

11. 插入字符串
    insert 成员函数可以在 string 对象中插入另一个字符串，返回值为对象自身的引用。例如：

string s1("Limitless"), s2("00");
s1.insert(2, "123");  //在下标 2 处插入字符串"123"，s1 = "Li123mitless"
s1.insert(3, s2);  //在下标 2 处插入 s2 , s1 = "Li10023mitless"
s1.insert(3, 5, 'X');  //在下标 3 处插入 5 个 'X'，s1 = "Li1XXXXX0023mitless"

12. 将 string 对象作为流处理
    使用流对象 istringstream 和 ostringstream，可以将 string 对象当作一个流进行输入输出。使用这两个类需要包含头文件 sstream。

示例程序如下：

#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main()
{
    string src("Avatar 123 5.2 Titanic K");
    istringstream istrStream(src); //建立src到istrStream的联系
    string s1, s2;
    int n;  double d;  char c;
    istrStream >> s1 >> n >> d >> s2 >> c; //把src的内容当做输入流进行读取
    ostringstream ostrStream;
    ostrStream << s1 << endl << s2 << endl << n << endl << d << endl << c <<endl;
    cout << ostrStream.str();
    return 0;
}

程序的输出结果是：

Avatar Titanic 123
5.2 K

第 11 行，从输入流 istrStream 进行读取，过程和从 cin 读取一样，只不过输入的来源由键盘变成了 string 对象 src。因此，“Avatar” 被读取到 s1，123 被读取到 n，5.2 被读取到 d，“Titanic” 被读取到s2，‘K’ 被读取到 c。

第 12 行，将变量的值输出到流 ostrStream。输出结果不会出现在屏幕上，而是被保存在 ostrStream 对象管理的某处。用 ostringstream 类的 str 成员函数能将输出到 ostringstream 对象中的内容提取出来。
13. 用 STL 算法操作 string 对象
string 对象也可以看作一个顺序容器，它支持随机访问迭代器，也有 begin 和 end 等成员函数。STL 中的许多算法也适用于 string 对象。下面是用 STL 算法操作 string 对象的程序示例。
纯文本复制

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
    string s("afgcbed");
    string::iterator p = find(s.begin(), s.end(), 'c');
    if (p!= s.end())
        cout << p - s.begin() << endl;  //输出 3
    sort(s.begin(), s.end());
    cout << s << endl;  //输出 abcdefg
    next_permutation(s.begin(), s.end());
    cout << s << endl; //输出 abcdegf
    return 0;
}

3、java处理字符串：

字符串是常量，一旦被创建就不能改变，这是因为字符串的值是存放在方法区的常量池里面，但是引用可以改变。
如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。
String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

//以下为常量池
String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
//以下创建在堆，且开辟两个空间
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

方法描述

char charAt(int index)返回指定索引处的 char 值。
contains(CharSequence chars)判断是否包含指定的字符系列。
isEmpty()判断字符串是否为空。
String trim()返回字符串的副本，忽略前导空白和尾部空白。
String replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String concat(String str)将指定字符串连接到此字符串的结尾。
boolean equals(Object anObject)将此字符串与指定的对象比较。
String[] split(String regex, int limit)根据匹配给定的正则表达式来拆分此字符串。
String substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串。
int compareTo(Object o)把这个字符串和另一个对象比较。
int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引。
int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
int compareTo(String anotherString)按字典顺序比较两个字符串。
int compareToIgnoreCase(String str)按字典顺序比较两个字符串，不考虑大小写。
boolean contentEquals(StringBuffer sb)当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
static String copyValueOf(char[] data)返回指定数组中表示该字符序列的 String。
static String copyValueOf(char[] data, int offset, int count)返回指定数组中表示该字符序列的 String。
boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。
boolean equalsIgnoreCase(String anotherString)将此 String 与另一个 String 比较，不考虑大小写。
byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes(String charsetName)使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)将字符从此字符串复制到目标字符数组。
int hashCode()返回此字符串的哈希码。
String intern() 返回字符串对象的规范化表示形式。
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。
boolean regionMatches(int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。
String replaceAll(String regex, String replacement)使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始。
boolean startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
char[] toCharArray()将此字符串转换为一个新的字符数组。
String toLowerCase()使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
String toString() 返回此对象本身（它已经是一个字符串！）。
String toUpperCase()使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String toUpperCase(Locale locale)使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
static String valueOf(primitive data type x)返回给定data type类型x参数的字符串表示形式。