String字符串对象的创建以及管理

String字符串对象的创建以及管理
String字符串对象的创建以及管理

(原创)深入研究java对String字符串对象的创建以及管理

(2008-9-27 bbh)

新手初学,不对的地方大家多多指教~

经常看到很多人讨论java中关于String的问题,我也就有点兴趣了,鉴于网上很多人写的都差别很大,

同样的问题都是不同的说法,我很迷糊,花了一晚上读了Java Virtual Machine Specification和

The Java Language Specification的一些章节,做了很多试验,总结了一下关于String的内容,还

有很多内容我也不确定,在下面也都提出来了,希望高手能指正.

Constant Pool常量池的概念:

在讲到String的一些特殊情况时,总会提到String Pool或者Constant Pool,但是我想很多人都不太

明白Constant Pool到底是个怎么样的东西,运行的时候存储在哪里,所以在这里先说一下Constant Pool的内容.

String Pool是对应于在Constant Pool中存储String常量的区域.习惯称为String Pool,也有人称为

String Constant Pool.好像没有正式的命名??

在java编译好的class文件中,有个区域称为Constant Pool,他是一个由数组组成的表,类型

为cp_info constant_pool[],用来存储程序中使用的各种常量,包括

Class/String/Integer等各

种基本Java数据类型,详情参见The Java Virtual Machine Specification 4.4章节.

对于Constant Pool,表的基本通用结构为:

cp_info {

u1 tag;

u1 info[];

}

tag是一个数字,用来表示存储的常量的类型,例如8表示String类型,5表示Long类型,info[]根据

类型码tag的不同会发生相应变化.

对于String类型,表的结构为:

CONSTANT_String_info {

u1 tag;

u2 string_index;

}

tag固定为8,string_index是字符串内容信息,类型为:

CONSTANT_Utf8_info {

u1 tag;

u2 length;

u1 bytes[length];

}

tag固定为1,length为字符串的长度,bytes[length]为字符串的内容.

(以下代码在jdk6中编译)

为了详细理解Constant Pool的结构,我们参看一些代码:

String s1 = "sss111";

String s2 = "sss222";

System.out.println(s1 + " " + s2);

由于"sss111"和"sss222"都是字符串常量,在编译期就已经创建好了存储在class文件中.

在编译后的class文件中会存在这2个常量的对应表示:

08 00 11 01 00 06 73 73 73 31 31 31 08 00 13 01 ; ......sss111.... 00 06 73 73 73 32 32 32 ; ..sss222

根据上面说的String常量结构,我们分析一下

开始的08为CONSTANT_String_info结构中的tag,而11应该是它的相对引用,01为

CONSTANT_Utf8_info的tag,06为对应字符串的长度,73 73 73 31 31 31为字符串对

应的编码,接着分析,会发现后面的是对应"sss222"的存储结构.

经过上面分析,我们知道了11和13是两个字符串的相对引用,就可以修改class 文件

来修改打印的内容,把class文件中的

00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 12 4D

改成

00 6E 00 04 00 03 00 00 00 24 12 10 4C 12 10 4D

程序就会输出sss111 sss111,而不是和原程序一样输出sss111 sss222,因为我们把对"sss222"的相对引用12改成了对"sss111"的相对引用10.

------------分割线

public class Test {

public static void main(String[] args) {

String s1 = "sss111";

String s2 = "sss111";

}

}

在上面程序中存在2个相同的常量"sss111",对于n个值相同的String常量,在Constant Pool中

只会创建一个,所以在编译好的class文件中,我们只能找到一个对"sss111"的表示:

000000abh: 08 00 11 01 00 06 73 73 73 31 31 31 ; ......sss111 在程序执行的时候,Constant Pool会储存在Method Area,而不是heap中.

另外,对于""内容为空的字符串常量,会创建一个长度为0,内容为空的字符串放到Constant Pool中,

而且Constant Pool在运行期是可以动态扩展的.

关于String类的说明

1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能

再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的(immutable).

2.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new

String("i am")实际创建了2个

String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,

一个是编译期,一个是运行期!

3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.

4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.

String的创建方法一般有如下几种

1.直接使用""引号创建.

2.使用new String()创建.

3.使用new String("someString")创建以及其他的一些重载构造函数创建.

4.使用重载的字符串连接操作符+创建.

例1

/*

* "sss111"是编译期常量,编译时已经能确定它的值,在编译

* 好的class文件中它已经在String Pool中了,此语句会在

* String Pool中查找等于"sss111"的字符串(用equals(Object)方法确定),

* 如果存在就把引用返回,付值给s1.不存在就会创建一个"sss111"放在 * String Pool中,然后把引用返回,付值给s1.

*

*/

String s1 = "sss111";

//此语句同上

String s2 = "sss111";

/*

* 由于String Pool只会维护一个值相同的String对象

* 上面2句得到的引用是String Pool中同一个对象,所以

* 他们引用相等

*/

System.out.println(s1 == s2); //结果为true

例2

/*

* 在java中,使用new关键字会创建一个新对象,在本例中,不管在

* String Pool中是否已经有值相同的对象,都会创建了一个新的

* String对象存储在heap中,然后把引用返回赋给s1.

* 本例中使用了String的public String(String original)构造函数. */

String s1 = new String("sss111");

/*

* 此句会按照例1中所述在String Pool中查找

*/

String s2 = "sss111";

/*

* 由于s1是new出的新对象,存储在heap中,s2指向的对象

* 存储在String Pool中,他们肯定不是同一个对象,只是

* 存储的字符串值相同,所以返回false.

*/

System.out.println(s1 == s2); //结果为false

例3

String s1 = new String("sss111");

/*

* 当调用intern方法时,如果String Pool中已经包含一个等于此String 对象

* 的字符串(用 equals(Object)方法确定),则返回池中的字符串.否则,将此

* String对象添加到池中,并返回此String对象在String Pool中的引用. */

s1 = s1.intern();

String s2 = "sss111";

/*

* 由于执行了s1 = s1.intern(),会使s1指向String Pool中值为"sss111" * 的字符串对象,s2也指向了同样的对象,所以结果为true

*/

System.out.println(s1 == s2);

例4

String s1 = new String("111");

String s2 = "sss111";

/*

* 由于进行连接的2个字符串都是常量,编译期就能确定连接后的值了,

* 编译器会进行优化直接把他们表示成"sss111"存储到String Pool中, * 由于上边的s2="sss111"已经在String Pool中加入了"sss111",

* 此句会把s3指向和s2相同的对象,所以他们引用相同.此时仍然会创建出 * "sss"和"111"两个常量,存储到String Pool中.

*/

String s3 = "sss" + "111";

/*

* 由于s1是个变量,在编译期不能确定它的值是多少,所以

* 会在执行的时候创建一个新的String对象存储到heap中,

* 然后赋值给s4.

*/

String s4 = "sss" + s1;

System.out.println(s2 == s3); //true

System.out.println(s2 == s4); //false

System.out.println(s2 == s4.intern()); //true

例5

这个是The Java Language Specification中3.10.5节的例子,有了上面的说明,这个应该不难理解了

package testPackage;

class Test {

public static void main(String[] args) {

String hello = "Hello", lo = "lo";

System.out.print((hello == "Hello") + " ");

System.out.print((Other.hello == hello) + " "); System.out.print((other.Other.hello == hello) + " ");

System.out.print((hello == ("Hel"+"lo")) + " "); System.out.print((hello == ("Hel"+lo)) + " ");

System.out.println(hello == ("Hel"+lo).intern()); }

}

class Other { static String hello = "Hello"; }

package other;

public class Other { static String hello = "Hello"; }

输出结果为true true true true false true,请自行分析!

结果上面分析,总结如下:

1.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中.

2.使用new String("")创建的对象会存储到heap中,是运行期新创建的.

3.使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中.

4.使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中.

6.使用"aa" + s1以及new String("aa" + s1)形式创建的对象是否加入到String Pool中我不太确定,可能是必须

调用intern()方法才会加入,希望高手能回答 @_@

还有几个经常考的面试题:

1.

String s1 = new String("s1") ;

String s2 = new String("s1") ;

上面创建了几个String对象?

答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.

2.

String s1 = "s1";

String s2 = s1;

s2 = "s2";

s1指向的对象中的字符串是什么?

答案: "s1"

C++中字符数组与string的相互转换及字符串拼接(字符串知识点总结)

【字符数组转化成string类型】 Char ch[]=”ABCDEFG” String str(ch);//也可string str=ch; 或者 Char ch[]=”ABCDEFG” String str; Str=ch;//在原有基础上添加可以用str+=ch; 【string类型转换为字符数组】 Char buf[10] String str(“ABCDEFG”); Length=str.copy(buf,9); Buf[length]=’\0’; 或者 Char buf[10]; String str1(“ABCDEFG”); strcpy(buf,str1.c_str());//strncpy(buf,str1.c_str(),10); 【字符串拼接】 一、string类字符串 重点:函数append的用法: (1)向s1-string的后面加s2-string (1个参数)

s.append(s2); 或s1+=s2; 也可直接将字符串拼接:如 string s=“hello”; s.append(" world");//“hello"后面拼接”world" (2)(2个参数) 1.向s1-string的后面加s2-string的一部分 s1.append(s2,n); // 把字符串s2的前n个字符连接到当前字符串结尾 2.向string后面加多个字符 string s1 = "hello "; s1.append(4,’!’); //在当前字符串结尾添加4个字符! s1 = “hello !!!”; (3).向string的后面加string的一部分(3个参数) 1.string s1 = "hello ", s2 = "beautiful world "; s1.append(s2, 11, 5); //把字符串s2中从11开始的5个字符连接到当前字符串的结尾得s1 = “hello world”; 2.string s1 = "hello ", s2 = “beautiful world”; s1.append(s2.begin()+11, s2.end()); //把s2的迭代器begin()+11和end()之间的部分连接到当前字符串的结尾得“hello world”; 二、char数组类字符串 重点:strcat()函数,该函数接受两个字符串作为参数,该函数把第2个字符串

java程序:String字符串处理算法

public class MyString{ public MyString(){ } public int indexOf(String content,String find){ return indexOf(content,find,0); } public int indexOf(String content,String find,int beginIndex){ char[]ca_content=content.toCharArray(); int len_content=content.length(); int len_find=find.length(); for(int i=beginIndex;i

第2章 语言与字符串

第2章 语言与字符串 这个理论中,我们要把问题交为更具体的问题,“给定字符串s 和语言L ,s 是否在 L 中?”进行形式化之前,要先定义几个术语。 字母表(alphabet )记为∑,是个有限集。∑的成员称为符号(symbols )或字符 (characters )。 2.1 字符串 字符串(string )是某个字母表∑中符号的有限序列。给定字母表∑,可以从∑构造的最 短字符串是空串,记为ε。字母表∑中的所有字符串集合记为∑*。这里采用Kleene 星号运算 符,定义如例2.1所示。 例2.1 字母表 字母表名称 字母表符号 例子字符串 英语字母表 {a, b, c, …, z} ε, aabbcg, aaaaa 二进制字母表 {0, 1} ε, 0, 001100 星号字母表 音乐字母表 {} 教材中直接数符号和字符串写成like this 。 2.1.1 字符串函数 字符串s 的长度(length )记为|s |,是s 中的字符个数。例如: |ε| = 0 |1001101| = 7 对任意符号c 和字符串s ,函数#c (s )定义为s 中符号c 出现的次数,例如#a (abbaaa)=4。 接合(concatenation )字符串s 与t 写成s ||t 或st ,就是在s 后面添加t 。例如,如果x = good , y = bye ,则xy = goodbye 。因此|xy | = |x | + |y |。 空串ε在接合字符串时,字符串不变,因此?x (x ε = εx = x )。 接合作为字符串函数是结合性的,因此?s ,t ,w ((st )w = s (tw ))。 下面定义字符串复制(replication )。对每个字符串w 和自然数i ,w i 定义为 w 0 = ε w i +1 = w i w 在

C 中的string常用函数用法总结.

C++中的string常用函数用法总结首先,为了在我们的程序中使用string类型,我们必须包含头文件。 如下: #include //注意这里不是string.h string.h是C字符串头文件 #include using namespace std; 1.声明一个C++字符串 声明一个字符串变量很简单: string Str; 这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。上面的声明没有传入参数,所以就直接使用了string的默认的构造函数,这个函数所作的就是把Str 初始化为一个空字符串。String类的构造函数和析构函数如下: a) string s; //生成一个空字符串s b) string s(str) //拷贝构造函数生成str的复制品 c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值 d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多st rlen”的部分作为字符串的初值 e) string s(cstr) //将C字符串作为s的初值 f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。 g) string s(num,c) //生成一个字符串,包含num个c字符 h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值 i) s.~string() //销毁所有字符,释放内存 都很简单,我就不解释了。

String常见的操作和方法

String常见的操作和方法 String类适用于描述字符串事物 那么它就提供了多个方法对字符串进行操作。 常见的操作有哪些? “afbs” 1、获取 1.1 字符串中包含的字符数,也就是字符串的长度。 int length(): 获取长度。 1.2 根据位置获取位置上某个字符。 char charAt(int index): 1.3 根据字符获取字符在字符串中位置。 int indexOf(int ch): 返回的是ch在字符串中第一次出现的位置。 int indexOf(int ch, int fromIndex): 从fromIndex指定位置开始,获取ch在字符串中出现的位置。 int indexOf(int str): 返回的是str在字符串中第一次出现的位置。 int indexOf(int str, int fromIndex): 从fromIndex指定位置开始,获取str在字符串中出现的位置。 int lastIndexOf(int ch); 2、判断。 2.1 字符串中是否包含某一个子串。 boolean contains(str): 特殊之处:indexOf(str):可以索引str第一次出现的位置,如果返回-1.表示该str不存在字符串中。 所以,也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法既可以判断,又可以获取出现的位置。 2.2 字符串中是否有内容。

boolean ifEmpty(): 原理就是判断长度是否为0. 2.3 字符串是否是以指定内容开头。 boolean startsWith(str); 2.4 字符串是否是以指定内容结尾。 boolean endsWith(str); 2.5判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str); 2.6判断内容是否相同,并忽略大小写。 boolean equalsIgnoreCase(); 3、转换 3.1 将字符数组转成字符串。 构造函数:String(char[]) String(char[],offset,count):将字符数组中的一部分转成字符串。 静态方法: static String copyValueOf(char[]); static String copyValueOf(char[] data,int offset,int count) static String valueOf(char[]): 3.2 将字符串转成字符数组。 char[] toCharArray(): 3.3 将字节数组转成字符串。 String(byte[]) String(byte[],offset,count):将字节数组中的一部分转成字符串。 3.4 将字符串转成字节数组。** byte[] getBytes(): 3.5 将基本数据类型转成字符串。 static String valueOf(int) static String valueOf(double) 3+"";//String.valueOf(3); 特殊:字符串和字节数组在转换过程中,是可以指定编码表的。

第二章:变量、数据类型、运算符

第二章:变量、数据类型、运算符 一、本章目标: 1、掌握变量的概念; 2、掌握常用数据类型; 3、会使用赋值运算符(=)和算术运算符(+、-、*、/); 4、掌握boolean类型和关系运算符的使用; 5、会进行数据类型转换; 6、掌握键盘输入; 二、存储器: 1、硬盘:容量大、存取速度比内存慢、介质(材料)便宜、永久存储。 2、内存:容量小、存取速度快、介质(材料)贵、瞬时存储(断电即消失)。 三、内存如何存储数据: 1、变量:一个数据存储空间的表示。不同的变量在内存中相互独立。 2、内存地址:变量在内存中存储位置(一般是一个16进制的数字),可以通过内存地址找到变量。 3、变量——————房间 变量名——————房间名 变量类型——————房间类型 变量值——————入住客人 四、java中常用的数据类型: 1、int:整型; 2、double:非整型;双精度浮点型 3、char:单个字符;用单引号,只能存储单个字符 4、String:字符串(一串字符);用双引号,可以存储多个字符 五、使用变量存储数据的步骤:(变量的定义方式:先声明后赋值;声明同时赋值) 1、确定房间类型(确定数据类型);

2、开房间(在内存中申请空间,取变量名); 3、入住(存储数据)。 *常用快捷键: 1、ctrl + s :保存; 2、ctrl + x :剪贴; 3、ctrl + c :复制; 4、ctrl + v :粘贴; 六、变量的命名规则: 变量名可以由数字、字母、下划线、美元符号及人民币符号(字、下、美、人)组成,且首字母不能是数字,不能使用关键字。 变量的命名规范:简短且清楚的表明变量的作用(语义化),首字母小写,后面的单词首字母大写(小驼峰命名规范); 七、常见错误: 1、局部变量(写在方法里面的变量),必须先赋值才能使用。 2、局部变量不能同名。 八、赋值运算符:= 把右边的值(复制)给到左边的变量。 九、表达式: 1、表达式就是符合(如:+ - * /)和操作数(可以是数值也可以是变量)的组合。 2、表达式的值:表达式里的操作数按照符号运算后得到的值。 十、算术运算符: 1、+ - * / (也叫二元运算符/双目运算符)。“/“:整除(求商) 2、%:求余运算符。 3、++、--:单目运算符(例:i++等价于i=i+1;i--等价于i=i-1);

Swift中文教程第二章-2.3字符串和字符

字符串和字符 (Strings and Characters) 本页包含内容: 字符串字面量 初始化空字符串 字符串可变性 字符串是值类型 使用字符 计算字符数量 连接字符串和字符 字符串插值 比较字符串 字符串大小写 Unicode String是例如 "hello, world", "海贼王" 这样的有序的Character (字符) 类型的值的集合,通 过String类型来表示。 Swift 的String和Character类型提供了一个快速的,兼容 Unicode 的方式来处理代码中的文本信息。创建和操作字符串的语法与 C 语言中字符串操作相似,轻量并且易读。字符串连接操作只需要简单地通过+号将两个字符串相连即可。与 Swift 中其他值一样,能否更改字符串的值,取决于其被定义为常量还是变量。 尽管语法简易,但String类型是一种快速、现代化的字符串实现。每一个字符串都是由独立编码的Unicode 字符组成,并提供了以不同 Unicode 表示 (representations) 来访问这些字符的支持。 Swift可以在常量、变量、字面量和表达式中进行字符串插值操作,可以轻松创建用于展示、存储和打印的自定义字符串。 注意: Swift 的String类型与 Foundation NSString 类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作。所有NSString API 都可以调用您创建的任意String类型的值。除此之外,还可以使用本章介绍的String特性。您也可以在任意要求传入NSString实例作为参数的 API 中使用String类型的值作为替代。 更多关于在 Foundation 和 Cocoa 中使用String的信息请查看Using Swift with Cocoa and Objective-C。 字符串字面量

c++中string的用法

之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作,== 进行比较,+ 做串联(是不是很简单?)。我们尽可以把它看成是C++的基本数据类型。 首先,为了在我们的程序中使用string类型,我们必须包含头文件 。如下: #include //注意这里不是string.h string.h是C字符串头文件 1.声明一个C++字符串 声明一个字符串变量很简单: string Str; 这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。上面的声明没有传入参数,所以就直接使用了string的默认的构造函数,这个函数所作的就是把Str 初始化为一个空字符串。String类的构造函数和析构函数如下: a) string s; //生成一个空字符串s b) string s(str) //拷贝构造函数生成str的复制品 c) string s(str,stridx) //将字符串str内"始于位置stridx"的部分当作字符串的初值 d) string s(str,stridx,strlen) //将字符串str内"始于stridx且长度顶多strlen"的部分作为字符串的初值 e) string s(cstr) //将C字符串作为s的初值 f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。 g) string s(num,c) //生成一个字符串,包含num个c字符 h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值 i) s.~string() //销毁所有字符,释放内存 都很简单,我就不解释了。 2.字符串操作函数 这里是C++字符串的重点,我先把各种操作函数罗列出来,不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数,再到后面看他的详细解释。 a) =,assign() //赋以新值 b) swap() //交换两个字符串的内容 c) +=,append(),push_back() //在尾部添加字符 d) insert() //插入字符 e) erase() //删除字符 f) clear() //删除全部字符 g) replace() //替换字符 h) + //串联字符串 i) ==,!=,<,<=,>,>=,compare() //比较字符串 j) size(),length() //返回字符数量 k) max_size() //返回字符的可能最大个数 l) empty() //判断字符串是否为空 m) capacity() //返回重新分配之前的字符容量

String中的方法

1,获取。 1.1 获取字符串中字符的个数。 int length(): 1.2 通过指定的位置,获取该位置上的字符。 char charAt(index): 1.3 通过字符串获取到索引位。 int indexOf(int ch):通过指定的字符获取该字符在字符串中的第一次出现的位置。 如果不存在。返回-1. 也就是说,我们可以通过结果为-1判断指定的字符是否在字符串中存在 int indexOf(int ch,int fromIndex):从指定的fromIndex位置开始查找ch第一次出现的位置。 int indexOf(String str) :索引字符串在指定的字符串中出现的第一次位置 int indexOf(String str,,int fromIndex) int lastIndexOf(int ch) :反向索引。 返回指定字符在此字符串中最后一次出现处的索引。 int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。 int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。 int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。 1.4 获取字符串中一部分字符串。也就是子串。 String substring(int beginIndex, int endIndex) :包含头,不包含尾。 String substring(int beginIndex) 2,判断。 2.1 两个字符串是否相同。 boolean equals(string); 2.2 这个字符串是否是以指定的字符串开头 boolean startsWith(string): 2.3 这个字符串是否是以指定的字符串结尾 boolean endsWith(string): 2.4 字符串中是否包含指定的字符串 boolean contains(string): 2.5 字符串中是否有字符 boolean isEmpty():原理其实就是在判断字符串的长度是否为0. 3,转换。 3.1 将字符串转成字符数组。

string

string字符串库 一、字符串基础 编程最重要的基础技术就是操作字符串,所以我们首先向大家介绍字符串库. 字符串就是由多个字符组成的字符串,注意字符与字符串是不同的.字符只是字符串中一个最小的单位。 一个英文字符、在内存中占用一个8bit位的字节(8个二进制位),在计算机内部字符实际上就是一个8bit 位的数值。 字符在内存中的数值数据称为字节码。 str = "ABCD"; bit = string.byte( str,1 );--我们用string.byte函数取第一个字符的字节码 win.messageBox(bit);-->显示A的字节码65 --实际上在内存中A与65并没有太大的区别 而一个中文字符,通常占两个字节(16个二进制位) str = "中文字"; size = string.len( str);--我们用string.len取字符串的长度 win.messageBox("字符长度 "..size);-->显示6个字符 通常在其他的编程语言中,字符串指一段文本。文本总是以"\0"(字节码等于0)表示结束。 所以字符串也就不可能包括"\0"。这也是普通文本与二进制数据的最大区别。 但是在LAScript中,字符串指的是二进制数据,而不是单纯的文本。允许包括"\0"。 即可以处一普通的文本,也可以处理二进制数据。这在其他编程语言里似乎不可思议。 string库的函数可以分析处理任何二进制数据。 二、基本函数 n = string.len(str) 返回字符串str的长度n,也可以直接写n = #str; str2 = string.rep(str, n) 返回重复n次字符串s的串; 类似于c++中的lpsz = char[n],在调用WinAPI的时候,我们可以用这个函数分配字符串缓冲区。 chr = string.byte(str, i) 取字符串str的第i个字符的字节码(整数值); 第二个参数可以省略(使用默认值1)。 chr = string.byte('A'); win.messageBox(chr);-->显示65 str = string.char(chr[,...]) 参数为0个或多个整数值,将每个整数作为字符的字节码连接成字符串。 例如:

String 中字符(串)查找

String的用法 String类仅仅查找操作就为我们提供了6种查找函数,每种函数以不同形式的find命名。 find、r find、find_first_of 、find_first_not_of、find_last_of 、find_last_not_of 这些都是const成员函数,const 也就是说,它们只是为了针对某种用途去寻找子串的位置,并不能够改变它们所作用的那个串的值。 这些操作全都返回string::size_type类型的值,也就是说,返回的结果是一个unsigned值(即,无符号整形)。要么是以下标形式查找匹配所发生的位置(也就是返回当前查找到的子串下标);或者返回一个名为string::npos 类型的值,说明查找没有匹配,也就是找不到你所查找的字符。就这么两种形式,要么是返回下标,要么返回npos。 每个查找操作都有4个重载版本,每个版本使用不同的参数形式。基本上,这些操作的不同之处在于查找的到底是单个字符,还是另一个string字符串,或者c风格的以空字符结束的字符串,还是用字符数组给出的特定数目的字符集合。 比如说: size_type find(const basic_string &s , size_type i=0) const; const修饰函数参数是它最广泛的一种用途,它表示函数体中不能修改参数的值(包括参数本身的值或者参数其中包含的值)。 注: basic_string::npos An unsigned integral value initialized to –1 that indicates either "not found" or "all remaining characters" when a search function fails. static const size_type npos = -1; 1、Find 查找子串第一次出现的位置 Searches a string in a forward direction for the first occurrence of a substring that matches a specified sequence of characters 最简单的查找操作就是find函数了。用于寻找实参指定的内容。如果能找到的话,则返回第一次匹配的下标值;如果找不到,则返回npos。 在此,我们首先定义一个字符串。 String s(“hello world”); //定义一个string变量s String::size_type pos= s.find(args); //args –>参数 if (pos!= string::npos ) cout<

字符串类String的使用

字符串类String的使用 视频002 字符串类String的使用 1.1 String类概述 .NET Framework中表示字符串的关键字为string,它是String类的别名。string类型表示Unicode字符的字符串。String类类似于string类型,但是功能更强。虽然String类功能很强,但是它也是不可改变的。这就是说一旦创建String对象,就不能够修改。表面看来能够修改字符串的所有方法实际上不能够修改。它们实际上返回一个根据所调用的方法修改的新的String。当需要大量的修改时,可使用StringBuilder类。 1.2 String类的使用 字符串是Unicode字符的有序集合,用于表示文本。String对象是System.Char对象的有序集合,用于表示字符串。String对象的值是该有序集合的内容,并且该值是不可变的。正是字符构成了字符串,根据字符在字符串中的不同位置,字符在字符串中有一个索引值,可以通过索引值获取字符串中的某个字符。字符在字符串中的索引从零开始。例如,字符串“Hello World”中的第一个字符为H,而“H”在字符串中的索引顺序为0。 字符串与字符的关系相当于公司与职员的关系,每个职员都有自己的编号,相当于字符串的索引号。 说明: String类所定义的变量是一个引用类型,可以对String类型的变量进行null赋值。 例003 String类的使用 创建一个控制台应用程序,声明一个字符串变量,然后获取字符串中的某个字符,代码如下。static void Main(string[] args) { string Str1 = "用一生下载你"; //声明一个字符串变量Str1 char Str2 = Str1[1]; //获取字符串Str1的第二个字符 char Str3 = Str1[2]; //获取字符串Str1的第三个字符 Console.WriteLine("字符串Str1中的第二个字符是:{0}", Str2); //输出第二个字符Console.WriteLine("字符串Str1中的第三个字符是:{0}", Str3); //输出第三个字符Console.ReadLine(); } 程序的运行结果如图1所示。 代码中采取在字符串变量后面加一个括号,并在括号中给出索引顺序的方法获取相应的字符。这是数组变量通用的索引方法。Str1[1]获得的是Str1中的第二个字符,依此类推。 1.3 比较字符串 在C#中最常见的比较字符串的方法有Compare、CompareTo和Equals方法等,这些方法都归属于String类。下面对这3种方法进行详细的介绍。 1.Compare方法 Compare方法用来比较两个字符串是否相等,它有很多个重载方法,其中最常用的两种方法

剑指offer第二章测试用例答案

第二章 P48:测试用例 #include "stdafx.h" #include /*length 为字符数组string的总容量*/ void ReplaceBlank(char string[], int length) { if(string == NULL && length <= 0) return; /*originalLength 为字符串string的实际长度*/ int originalLength = 0; int numberOfBlank = 0; int i = 0; while(string[i] != '\0') { ++ originalLength; if(string[i] == ' ') ++ numberOfBlank; ++ i; } /*newLength 为把空格替换成'%20'之后的长度*/ int newLength = originalLength + numberOfBlank * 2; if(newLength > length) return; int indexOfOriginal = originalLength; int indexOfNew = newLength; while(indexOfOriginal >= 0 && indexOfNew > indexOfOriginal) { if(string[indexOfOriginal] == ' ') { string[indexOfNew --] = '0'; string[indexOfNew --] = '2'; string[indexOfNew --] = '%'; } else { string[indexOfNew --] = string[indexOfOriginal]; }

String方法大全

String 构造方法 1、String() 初始化一个新创建的 String 对象,使其表示一个空字符序列。 2、String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。3、String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte 子数组,构造一个新的 String。 offset - 要解码的第一个 byte 的索引 length - 要解码的 byte 数 4、String(byte[] bytes, int offset, int length, Charset charset) String。 5、String(byte[] bytes, int offset, int length, String charsetName) String。 6、String(byte[] bytes, String charsetName) 通过使用指定的charset解码指定的 byte 数组,构造一个新的 String 7、String(char[] value) 分配一个新的 String,使其表示字符数组参数中当前包含的字符序列。 value - 字符串的初始值 8、String(char[] value, int offset, int count) 分配一个新的 String,它包含取自字符数组参数一个子数组的字符。 value - 作为字符源的数组。 offset - 初始偏移量。 count - 长度。 9、String(int[] codePoints, int offset, int count) 分配一个新的 String,它包含 Unicode 代码点数组参数一个子数组的字符。 codePoints - 作为 Unicode 代码点的源的数组。 offset - 初始偏移量。 count - 长度。 10、String(String original) 初始化一个新创建的 String 对象,使其表示一个与参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的副本。 11、String(StringBuffer buffer) 分配一个新的字符串,它包含字符串缓冲区参数中当前包含的字符序列。 12、String(StringBuilder builder) 分配一个新的字符串,它包含字符串生成器参数中当前包含的字符序列。 构造方法共12种常用的四种多。

C++课程设计之string字符串类

课程名称: C++程序设计 课程代码:05 题目: 字符串类的设计 年级/专业/班: 软件工程2班 学生姓名: 学号: 指导教师: 袁辉勇 开题时间: 2011 年 5 月 15 日 完成时间: 2011 年 6 月 5 日 —湖南人文科技学院计算机系

目录 一引言 (3) 二设计目的与任务 (3) 三设计方案 (4) 1 总体设计 (4) 2 详细设计 (4) 四程序清单 (4) 五程序调试与体会 (10) 六运行结果 (14) 七结论................................................. 错误!未定义书签。八参考文献............................................... 错误!未定义书签。

摘要 本设计通过定义字符串类来实现对字符串的赋值、连接、复制、查找、交换操作。首先定义一个字符串类,通过调用字符串类中成员函数,对字符串类进行赋值,然后实现了字符串类之间的连接,字符串类之间的相互复制,字符串类之间的交换,最后可以对该字符串类中的字符串进行查找。 关键字:字符串;类;成员函数;对象 Abstract By defining the design of this type of string to string to the realization of the assignment, to connect, copy, find, exchange operations. First of all, the definition of a type of string, by calling members of the String class function, the type of string for assignment, and then realized the connection between the type of string, string-type between the copy, between string-type In exchange, the last class to the string of string to find. Keywords: string; category; members of the function; object 。

《Java知识点总结系列》第二章——语法篇

内容预览 注释 包 jar命令 标识符 变量与字面值 局部变量 表达式与运算符 String字符串初探 Java的注释 (说明性质的文字增强程序的可读性不被编译器编译直接忽略) 任意一种语言都支持单行、多行注释 Java注释的分类: 1. 单行注释(//) a) 可以书写在任何位置 b) 反斜杠后写一行描述性文字 2. 多行注释(/* */) a)不允许嵌套 3. javadoc注释(/** */)实现注释和代码分离 a) 只能写在类、方法上面,不能写在方法内部 b) 区别:只给用户看注释,不给用户看源代码 Java: 企业级软件ERP CRM 行业软件eg:医院只给软件使用权不需要给用户看源代码 c) javadoc命令可以抽取注释生成html文件 d) javadoc命令格式 javadoc –d doc HelloWorld.java -d:目录(directory) doc:特定文件夹(html文件放在doc里面) 用户查看index.html文件 e) 生成javadoc文件,必须是公共类 格式: /** *类名: *作者: *开发日期: *作用: *修复日期: *原因:

*/ 4. 总结Java的注释 a) 注释的3种写法 b) javadoc注释的作用 c) JavaSE API文档Application Interface 包 1. 包的概念(解决类名冲突类似于操作系统的文件夹但实际上不是) 2. 包的创建与package关键字 带有包的编译javac –d .HelloWorld.java java p1.HelloWorld a) 写在类代码的第一行,大小写区分 b) 不一定要写,极大程度解决类名命名冲突 c) 属性从属于包------>全限定名(包名+类名) 3. 子包的概念(文件夹的嵌套) a) javac –d . HelloWorld.java b) 一个包里可以有多个类(不要同名) c) 不能够手工创建文件夹充当包 4. 带有包的使用和import语句 a) p1.p2.HelloWorld hw;声明时全限定名 带包时,按层级结构,严格书写,最深层 b) 相同包下的类,不用写包 c) 使用的类多次使用import import p1.p2.HelloWorld;预先声明 import p1.p2.*; 所有的类 5. JavaSE中的包 a) java lang(System,String)https://www.360docs.net/doc/d27911084.html,ng中的包不用import 直接使用 b) java.util c) java.sql d) java.io e) 后续学习其中的类 6. java包的命名要求 a) 不要以java开头 b) 建议:以公司的域名反写作为java类的包 c) 一般包名全部小写package com.oralce.项目.模块 d) 自己写的类可以带*,但Java API里的类用哪个导入哪个 jar命令 1. jar包(保存、压缩.class文件文件的压缩格式) 防止病毒感染传输速率快 tar: Linux zip: Windows、Linux

字符串常用方法

计算字符串的长度* string myString = "This is a test!"; Console.WriteLine("Text is :{0}",myString); Console.WriteLine("Text's long is :{0}",myString.Length); * 转换大小写* myString = myString.ToLower(); //所有字符转换成小写 myString = myString.ToUpper(); //所有字符转换成大写 * 删除前后空格* myString = myString.Trim(); //同时删除字符串前后的空格 char[] trimChars = {' ','e','s'}; //准备删除的字符 myString = myString.Trim(trimChars); //删除所有指定字符 myString = myString.TrimEnd(); //删除字符串后的空格 myString = myString.TrimStart(); //删除字符串前的空格 * 添加空格* myString = myString.PadRight(14,' '); //当字符串长度不够14位时,在他的右边用指定字符填充myString = myString.PadLeft(14,' '); //当字符串长度不够14位时,在他的左边用指定字符填充 * 拆分字符串* string[] nStrs = myString.Split(' ',3); //按照空格进行拆分,并且返回前三个字符串 * 获取子字符串* string a = myString.Substring(2,2); //从myString字符串的第三位开始获取两个字符,因为索引 起始位是0 * 替换字符串中的字符* string a = myString.Replace("i","o"); //将这个字符串中的所有“i”替换成“o” C#中字符串实际上是Char变量的只读数组。可以用下面的方法访问字符串中每一个字符,但是不能修 改他们。 string myString = "This is a test!"; foreach (char myChar in myString) { Console.Write("{0}",myChar); } 要想得到一个可读写的字符数组,你可以这样。 char[] myChars = myString.ToCharArray();

JAVA中STRING的常用方法总结

JAVA中STRING的常用方法总结 JAVA中STRING的常用方法总结 一、创建并初始化一个字符串 Stringb="hello"; 使用构造方法创建并初始化一个字符串 String();//初始化字符串,表示空字符序列 String(value);//利用已存在的字符串常量创建一个新的对象String(char[]value);//利用一个字符数组创建一个字符串 String(char[]value,intoffset,intcount);//截取字符数组offset到count的字符创建一个非空串 String(StringBufferbuffer);//利用StringBuffer对象初始化String对象 二、String类主要方法的使用: 1、获取长度*.length();//这与数组中的获取长度不同, *.length; 2、比较字符串(1)equals()//判断内容是否相同 (2)compareTo()//判断字符串的大小关系 (3)compareToIgnoreCase(Stringint)//在比较时忽略字母大小写 (4)==//判断内容与地址是否相同 (5)equalsIgnoreCase()//忽略大小写的情况下判断内容是否相同

如果想对字符串中的部分内容是否相同进行比较,可以用 (6)reagionMatches()//有两种 publicbooleanregionMatches(inttoffset,Stringother,intooffse t,intlen);表示如果String对象的一个子字符串与参数other的一个子字符串是相同的字符序列,则为true.要比较的String对象的字符串从索引toffset开始,other的字符串从索引ooffset开始,长度为len。 publicbooleanreagionMatches(booleanignoreCase,inttoffset ,Stringother,intooffset,intlen);//用布尔类型的参数指明两个字符串的比较是否对大小写敏感。 三、查找字符串中某个位置的字符 publiccharcharAt(intindex);//返回指定索引index位置上的字符,索引范围从0开始 四、查找指定字符串在字符串中第一次或最后一词出现的'位置 在String类中提供了两种查找指定位置的字符串第一次出现的位置的方法 (1)publicintindexOf(Stringstr);//从字符串开始检索str,并返回第一次出现的位置,未出现返回-1 (2)publicintindexOf(Stringstr,intfromIndex);//从字符串的第fromIndex个字符开始检索str 查找最后一次出现的位置有两种方法 (1)publicintlastIndexOf(Stringstr); (2)publicintlastIndexOf(Stringstr,intfromIndex); 如果不关心字符串的确切位置则可使用publicbooleancontains(CharSequences); 五、检查字符串的起始字符和结束字符

相关文档
最新文档