java.lang.string(java.lang.string什么意思)

String类是Java编程中运用最广泛的类,所以每一位程序员都应该细心研究一番String类的内部完成,这样对咱们理解String目标的作业机制、避免过错和提高代码功率有很大优点。你若翻开Java言语标准(Java9),能够看到4.3.3节中对String目标的简述[1]:

String目标的实例,表明Unicode码的序列。

一个String目标,有一个稳定不变的值。

字符串字面量是对String实例的引证。

十分量表达式时,“+“操作符衔接两个String目标,总是会隐式地发生一个新的String目标。

p.s.所谓常量表达式的界说,在Java中有一系列标准,对于String,简略地说,便是形如下面这种表达式:

“Theinteger”+Long.MAX_VALUE+”ismightybig.”

即仅由一系列字符串字面量或许字符串常量组成的表达式。

下面,就详细研究String类。

1.不行变类—-String

String目标是不行变的,所谓不行变便是指一个目标,在它创立完结之后,不能再改动它的状态。假如你细心检查了String的源码或许API文档,就会发现String类中的一切改动String内容的办法,实际上都new了一个新的String目标,例如subsring()办法,该办法截取片段如下所示:

publicStringsubstring(intbeginIndex,intendIndex){undefined

……

……return((beginIndex==0)&&(endIndex==value.length))?this:newString(value,beginIndex,subLen);

}

留意到,return语句中的newString(value,beginIndex,subLen)语句,实际上便是创立了一个新的String目标返回给用户。

String的不行变本质上便是经过封装和躲藏完成以及操控访问权限来完成的。检查String源码,能够看到:

publicfinalclassString

implementsjava.io.Serializable,Comparable,CharSequence{undefined

……

/**Thevalueisusedforcharacterstorage.*/

privatefinalcharvalue[];

……

publicString(Stringoriginal){undefined

this.value=original.value;

this.hash=original.hash;

}

}

实际上,String目标持有一个char数组的引证,而这个数组便是String字面量所引证的值。该数组界说为privatefinal,private使外部不能访问该数组,final则表明该数组的引证一旦初始化就不能改动。此外,String类本身界说为final的,不行被继承,一切属性均为private,由此,完成了String的不行变性质。

可是,String目标真的不行变么?换句话说,有没有办法改动value[]的值,能不能把[‘a’,’b’,’c’]改为[‘a’,’b’,’d’]?答案是必定的,经过反射机制,能够获取value[]的访问权限并更改数组中的值。可见,反射是强壮的但不是安全的,一般运用开发中,尽或许避免运用反射。

2.String衔接操作符”+”

2.1操作符”+”对发生目标的影响

在诸如:op1+op2+op3的表达式中,只需有一个操作数是String类型,其它操作数都会在运转时转换成String类型,成果是一个新创立的String目标的引证(除非是常量表达式)。举一个例子来解释一下这句话的意义。

1publicclassOperationAddOnString{2publicstaticvoidmain(String[]args){3Stringa=”hello”+”world”;//(1)

4Stringb=”hello”;//(2)

5Stringc=”world”;//(3)

6Stringd=b+c;//(4)

7Stringe=”helloworld”;//(5)

8System.out.println(e==a);//(6)运转成果:true

9System.out.println(a==d);//(7)运转成果:false

10}11}

(1)首要,创立一个引证a,指定为String类型,其次字面量“hello”的String目标和“world”的目标别离被创立于堆内存中的字符串常量池中,现在,创立了两个目标。终究,操作符“+”将常量池中的两个目标“hello”,“world”相衔接,创立了一个字面量为“helloworld”的新String目标,并贮存于字符串常量池中。即,榜首行一共创立了三个目标,且都贮存于常量池中。

(2)创立一个引证b,指向字符串常量池中字面量为“hello“的目标,没有创立新的String目标。

(3)同上。

(4)创立一个String类型的引证d,将b引证指向的目标和c指向的目标相连,由于此表达式不是常量表达式,编译器不能承认b和c所指向的目标,所以,b+c运转时创立了一个新的String目标,贮存于堆内存中(十分量池)。这行创立了一个新目标,这个目标的字面量为”helloworld”,与a相同,可是一个存于字符串常量池,另一个存储于堆中。

(5)创立一个String类型的引证e,由于字面量“helloworld”的目标已存在于常量池,将e指向其即可。这行没有创立新的目标。

(6)e和a都指向常量池中的“helloworld”,所以成果是true。

(7)a和d指向不同的目标,所以成果是false。

假如想让(7)的成果为true,有什么办法?前面章节说过,假如表达式是常量表达式,“+”操作符就不会发生新的目标,因而,只需要将引证b和c声明为final的即可

publicclassOperationAddOnString{publicstaticvoidmain(String[]args){undefined

Stringa=”hello”+”world”;finalStringb=”hello”;finalStringc=”world”;

Stringd=b+c;//由于b,c是final的,此为常量表达式,编译时就能承认字符串字面量,指向a引证所指向的常量池中的目标

System.out.println(a==d);//true

}

}

2.2编译器对”+”操作的优化

假设表达式中有多个“+”,依照上述逻辑,一个表达式中或许发生多个String目标,而许多String目标只是作为中心目标,并不在终究成果中体现,这无疑是一种糟蹋。为了降低中心String目标所带来的的性能和内存糟蹋,Java编译器选用StringBuilder类或许类似的技能。StringBuilder目标是可变目标,创立一个StringBuilder目标之后,能够改动其所代表的字符串字面量。例如:

1publicclassStringCatenation1{2publicstaticvoidmain(String[]args){3Stringa=”a”;4Stringb=”b”;5Stringc=”c”;6Stringd=a+b+c;7System.out.println(d);8}9}

第6行拼接了多个字符串目标,且是十分量表达式,将新的字符串目标指向给引证d。运用javap-cStringCatenation1后反汇编StringCatenation1.class后,成果如下:

1publicclassstrings.StringCatenation1{2publicstrings.StringCatenation1();3Code:40:aload_051:invokespecial#1//Methodjava/lang/Object.””:()V

64:return

7

8publicstaticvoidmain(java.lang.String[]);9Code:100:ldc#2//Stringa

112:astore_1123:ldc#3//Stringb

135:astore_2146:ldc#4//Stringc

158:astore_3169:new#5//classjava/lang/StringBuilder

1712:dup1813:invokespecial#6//Methodjava/lang/StringBuilder.””:()V

1916:aload_12017:invokevirtual#7//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

2120:aload_22221:invokevirtual#7//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

2324:aload_32425:invokevirtual#7//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

2528:invokevirtual#8//Methodjava/lang/StringBuilder.toString:()Ljava/lang/String;

2631:astore4

2733:getstatic#9//Fieldjava/lang/System.out:Ljava/io/PrintStream;

2836:aload4

2938:invokevirtual#10//Methodjava/io/PrintStream.println:(Ljava/lang/String;)V

3041:return

31}

反编译后类似于汇编言语,可是你不需要理解每一行的意思,这里主要看标红的行,#5表明创立一个StringBulder目标,#7则是别离stringBuilder.append(a),stringBuilder.append(b),stringBuilder.append(c),#8是调用stringBuilder.toString()办法,将终究的成果String目标赋予引证d。经过编译器自动运用StringBuilder的技能,就能够处理字符串拼接发生很多中心String目标的问题,降低内存损耗。

下面看另一个关于字符串拼接的问题,在循环中拼接字符串。依据上面内容,咱们知道,编译器在拼接字符串变量时,会隐式地创立StringBuilder目标来进行,那么,咱们是否就无需忧虑在循环中随意用String目标来拼接字符串了呢?

1publicclassStringCatenation2{2publicStringimplicit(String[]fields){3Stringresult=””;4for(inti=0;i<fields.length;i++){5result+=fields[i];6}7returnresult;8}9}

在循环之外声明一个String变量result,并赋予空字符串,将参数传过来的字符串数组遍历拼接到result上。将该代码反汇编之后的成果如下:

1publicjava.lang.Stringimplicit(java.lang.String[]);2Code:30:ldc#2//String

42:astore_253:iconst_064:istore_375:iload_386:aload_197:arraylength108:if_icmpge38

1111:new#3//classjava/lang/StringBuilder

1214:dup1315:invokespecial#4//Methodjava/lang/StringBuilder.””:()V

1418:aload_21519:invokevirtual#5//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

1622:aload_11723:iload_31824:aaload1925:invokevirtual#5//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

2028:invokevirtual#6//Methodjava/lang/StringBuilder.toString:()Ljava/lang/String;

2131:astore_22232:iinc3,1

2335:goto5

2438:aload_22539:areturn

留意#5,的确如咱们所料,编译器自动创立了StringBuilder目标,可是留意35行goto关键字,goto表明跳跃到指定的行,这里指向第5行iload_3,不需要理解这是什么意思,只需要知道,从5行到35行,是一个循环,或许会履行屡次即可,那么第11行的newStringBuilder目标也会履行屡次,创立多个StringBuilder目标,这样,就没有到达消灭中心目标的作用。对于这种循环拼接字符串的场景,咱们应该在循环外层,显式界说StringBuilder目标,在循环中显式运用StringBuilder.append()办法来拼接目标,如下所示:

1publicclassStringCatenation2{2publicStringexplicit(String[]fields){3StringBuilderbuilder=newStringBuilder();4for(inti=0;i<fields.length;i++){5builder.append(fields[i]);6}7returnbuilder.toString();8}9}

反汇编后:

1publicjava.lang.Stringexplicit(java.lang.String[]);2Code:30:new#3//classjava/lang/StringBuilder

43:dup54:invokespecial#4//Methodjava/lang/StringBuilder.””:()V

67:astore_278:iconst_089:istore_3910:iload_31011:aload_11112:arraylength1213:if_icmpge30

1316:aload_21417:aload_11518:iload_31619:aaload1720:invokevirtual#5//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

1823:pop1924:iinc3,1

2027:goto10

2130:aload_22231:invokevirtual#6//Methodjava/lang/StringBuilder.toString:()Ljava/lang/String;

2334:areturn

现在,反汇编后,咱们发现,newStringBuilder过程在循环之外了,只创立一个StringBuilder目标。

3.String真身

从本质上来说,Java中的String便是字符的数组,在String类源码中,String的榜首个属性便是:

privatefinalcharvalue[];//final润饰value,表明其引证不行变但能够改动数组内部内容,private使其不行见,所以String为不行变类。当然,上面提到过能够选用反射来修改数组内容然后让String不再“不行变”。

用来存储字符串字面量的字符,比如Stringday=”hello”中,被引号括起来的“Hello,world!”是字符串字面量,以上表达式,创立了一个String目标,其字面量是“Hello,world!”,那么value中存储的是

[‘h’,’e’,’l’,’l’,’o’]

除此之外,还能够是用new关键字来调用结构器创立String目标,String有多达十几种结构器,每种结构器允许程序员传入不同类型或许不同数量的参数来结构String目标,比如用字符数组来结构String目标:

1char[]words={‘h’,’e’,’l’,’l’,’o’};2Stringsay=newString(words);3System.out.println(say);

源码中,这一结构器便是把字符数组words仿制一份赋值给String的属性value而已,可见,字符数组便是String的本质。留意到,结构器中运用Arrays.copyOf(value,value.length)赋值并创立了一个新的字符数组目标,在本篇文章开篇榜首节中我就强调String是不行变类,创立一个新的数组目标便是避免用户修改原来的数组然后修改到String目标所持有的数组而违反了不行变的宗旨。

1/**

2*Allocatesanew{@codeString}sothatitrepresentsthesequenceof3*characterscurrentlycontainedinthecharacterarrayargument.The4*contentsofthecharacterarrayarecopied;subsequentmodificationof5*thecharacterarraydoesnotaffectthenewlycreatedstring.6*7*@paramvalue8*Theinitialvalueofthestring9*/

10publicString(charvalue[]){11this.value=Arrays.copyOf(value,value.length);12}

已然字符数组便是String的本质,那么对于String目标的一切操作便是对字符数组的操作,比如String供给了获取字符串长度(字符的数量)的办法length(),源码中便是获取字符数组的长度:类似地,charAt(intindex)办法也便是获取数组中的指定位置的字符。

1/**

2*Returnsthelengthofthisstring.3*ThelengthisequaltothenumberofUnicode4*codeunitsinthestring.5*6*@returnthelengthofthesequenceofcharactersrepresentedbythis7*object.8*/

9publicintlength(){10returnvalue.length;11}

1publiccharcharAt(intindex){2if((index<0)||(index>=value.length)){3thrownewStringIndexOutOfBoundsException(index);4}5returnvalue[index];6}

理解“字符串的本质便是字符数组”十分重要,下面就做一个小操练来巩固这一思维:将字符串”hello,world”以相反顺序输出,并创立一个相反顺序的String目标,不得运用任何Java或许第三方工具供给的办法。

1publicclassReverseString{2

3publicstaticvoidmain(String[]args){4Stringorigin=”hello,world”;5intlen=origin.length();6char[]tempChar=newchar[len];7char[]reverseChar=newchar[len];8

9for(inti=0;i<len;i++){10tempChar[i]=origin.charAt(i);11}12

13for(intj=len-1;j>=0;j–){14reverseChar[j]=tempChar[len-j-1];15}16

17System.out.println(Arrays.toString(tempChar));18System.out.println(Arrays.toString(reverseChar));19

20Stringreverse=newString(reverseChar);21System.out.println(origin);22System.out.println(reverse);23}24}25

26=====输出成果=====

27[h,e,l,l,o,,,w,o,r,l,d]28[d,l,r,o,w,,,o,l,l,e,h]29hello,world30dlrow,olleh
图片[1]-java.lang.string(java.lang.string什么意思)-小白之家,java.lang.string什么意思,一、String的用法

String类在java.lang包中,java运用String类创立一个字符串变量,字符串变量属于目标。java把String类声明的final类,不能有子类。String类目标创立后不能修改,由0或多个字符组成,包括在一对双引号之间,下面简略的了解一下其常用的API

java.lang.String

charcharAt(intindex)回来index所指定的字符Stringconcat(Stringstr)将两字符串衔接

booleanendsWith(Stringstr)测验字符串是否以str结束

booleanequals(Objectobj)比较两目标

char[]getBytes将字符串转化成字符数组回来

char[]getBytes(Stringstr)将指定的字符串转成制服数组回来

booleanstartsWith(Stringstr)测验字符串是否以str开始

intlength()回来字符串的长度Stringreplace(charold,charnew)将old用new代替

char[]toCharArray将字符串转化成字符数组StringtoLowerCase()将字符串内的字符改写成小写StringtoUpperCase()将字符串内的字符改写成大写StringvalueOf(Booleanb)将布尔办法b的内容用字符串表明StringvalueOf(charch)将字符ch的内容用字符串表明StringvalueOf(intindex)将数字index的内容用字符串表明StringvalueOf(longl)将长整数字l的内容用字符串表明Stringsubstring(int1,int2)取出字符串内第int1方位到int2的字符串

1.构造办法

//直接初始化Stringstr=”abc”;//运用带参构造办法初始化char[]char={‘a’,’b’,’c’};Stringstr1=newString(“abc”);Stringstr2=newString(str);Stringstr3=newString(char);

2.求字符串长度和某一方位字符

Stringstr=newString(“abcdef”);intstrlength=str.length();//strlength=7charch=str.charAt(4);//ch=e

3.提取子串

用String类的substring办法能够提取字符串中的子串,该办法有两种常用参数:1)publicStringsubstring(intbeginIndex)//该办法从beginIndex方位起,从当时字符串中取出剩下的字符作为一个新的字符串回来。2)publicStringsubstring(intbeginIndex,intendIndex)//该办法从beginIndex方位起,从当时字符串中取出到endIndex-1方位的字符作为一个新的字符串回来。

Stringstr1=newString(“abcdef”);Stringstr2=str1.substring(2);//str2=”cdef”Stringstr3=str1.substring(2,5);//str3=”cde”

4.字符串比较

1)publicintcompareTo(StringanotherString)//该办法是对字符串内容按字典次序进行巨细比较,经过回来的整数值指明当时字符串与参数字符串的巨细联系。若当时目标比参数大则回来正整数,反之回来负整数,持平回来0。2)publicintcompareToIgnoreCase(StringanotherString)//与compareTo办法相似,但疏忽巨细写。3)publicbooleanequals(ObjectanotherObject)//比较当时字符串和参数字符串,在两个字符串持平的时候回来true,否则回来false。4)publicbooleanequalsIgnoreCase(StringanotherString)//与equals办法相似,但疏忽巨细写。

Stringstr1=newString(“abc”);

Stringstr2=newString(“ABC”);inta=str1.compareTo(str2);//a>0intb=str1.compareToIgnoreCase(str2);//b=0booleanc=str1.equals(str2);//c=falsebooleand=str1.equalsIgnoreCase(str2);//d=true

5.字符串链接

publicStringconcat(Stringstr)//将参数中的字符串str衔接到当时字符串的后边,作用等价于”+”

Stringstr=”aa”.concat(“bb”).concat(“cc”);//适当于Stringstr=”aa”+”bb”+”cc”;

6.字符串中单个字符查找

1)publicintindexOf(intch/Stringstr)//用于查找当时字符串中字符或子串,回来字符或子串在当时字符串中从左边起首次呈现的方位,若没有呈现则回来-1。2)publicintindexOf(intch/Stringstr,intfromIndex)//改办法与第一种相似,差异在于该办法从fromIndex方位向后查找。3)publicintlastIndexOf(intch/Stringstr)//该办法与第一种相似,差异在于该办法从字符串的末尾方位向前查找。4)publicintlastIndexOf(intch/Stringstr,intfromIndex)//该办法与第二种办法相似,差异于该办法从fromIndex方位向前查找。

Stringstr=”Ireallymissyou!”;inta=str.indexOf(‘a’);//a=4intb=str.indexOf(“really”);//b=2intc=str.indexOf(“gg”,2);//c=-1intd=str.lastIndexOf(‘s’);//d=6inte=str.lastIndexOf(‘s’,7);//e=7

7.巨细写转化

1)publicStringtoLowerCase()//回来将当时字符串中一切字符转化成小写后的新串2)publicStringtoUpperCase()//回来将当时字符串中一切字符转化成大写后的新串

Stringstr=newString(“abCD”);Stringstr1=str.toLowerCase();//str1=”abcd”Stringstr2=str.toUpperCase();//str2=”ABCD”

8.字符串中字符的替换

1)publicStringreplace(charoldChar,charnewChar)//用字符newChar替换当时字符串中一切的oldChar字符,并回来一个新的字符串。2)publicStringreplaceFirst(Stringregex,Stringreplacement)//该办法用字符replacement的内容替换当时字符串中遇到的第一个和字符串regex相匹配的子串,应将新的字符串回来。3)publicStringreplaceAll(Stringregex,Stringreplacement)//该办法用字符replacement的内容替换当时字符串中遇到的一切和字符串regex相匹配的子串,应将新的字符串回来。

Stringstr=”asdzxcasd”;Stringstr1=str.replace(‘a’,’g’);//str1=”gsdzxcgsd”Stringstr2=str.replace(“asd”,”fgh”);//str2=”fghzxcfgh”Stringstr3=str.replaceFirst(“asd”,”fgh”);//str3=”fghzxcasd”Stringstr4=str.replaceAll(“asd”,”fgh”);//str4=”fghzxcfgh”

9.其他办法

1)Stringtrim()//截去字符串两端的空格,但对于中间的空格不处理。

Stringstr=”abc”;

Stringstr1=str.trim();inta=str.length();//a=6intb=str1.length();//b=4

2)booleanstatWith(Stringprefix)或booleanendWith(Stringsuffix)//用来比较当时字符串的开始字符或子字符串prefix和停止字符或子字符串suffix是否和当时字符串相同,重载办法中一起还能够指定比较的开始方位offset。

Stringstr=”abcdef”;booleana=str.statWith(“ab”);//a=truebooleanb=str.endWith(“ef”);//b=true

3)contains(Stringstr)//判别参数s是否被包括在字符串中,并回来一个布尔类型的值。

Stringstr=”abcdef”;

str.contains(“ab”);//truestr.contains(“gh”);//false

4)String[]split(Stringstr)//将str作为分隔符进行字符串分解,分解后的字字符串在字符串数组中回来。

Stringstr=”abcdefghi”;

String[]str1=str.split(“”);//str1[0]=”abc”;str1[1]=”def”;str1[2]=”ghi”;

10.类型转化

字符串转根本类型java.lang包中有Byte、Short、Integer、Float、Double类的调用办法:

publicstaticbyteparseByte(Strings)

publicstaticshortparseShort(Strings)

publicstaticshortparseInt(Strings)

publicstaticlongparseLong(Strings)

publicstaticfloatparseFloat(Strings)

publicstaticdoubleparseDouble(Strings)

intn=Integer.parseInt(“12”);floatf=Float.parseFloat(“12.34”);doubled=Double.parseDouble(“1.124″);

根本类型转字符串String类中提供了StringvalueOf()放法,用作根本类型转化为字符串类型

staticStringvalueOf(chardata[])

staticStringvalueOf(chardata[],intoffset,intcount)

staticStringvalueOf(booleanb)

staticStringvalueOf(charc)

staticStringvalueOf(inti)

staticStringvalueOf(longl)

staticStringvalueOf(floatf)

staticStringvalueOf(doubled)

//将char’8’转化为int8Stringstr=String.valueOf(‘8’);

intnum=Integer.parseInt(str);

进制转化运用Long类中的办法得到整数之间的各种进制转化的办法:

Long.toBinaryString(longl)//二进制

Long.toOctalString(longl)//十进制

Long.toHexString(longl)//十六进制

Long.toString(longl,intp)//p作为恣意进制

二、String特性

这一部分介绍String的一些特性,涉及到字符串常量池、String.intern()以及咱们常常遇到的“==”和“equals()”问题。下面咱们将经过不同的比如来解释:

比如1:

Stringa=”HelloWorld!”;Stringb=”HelloWorld!”;Stringc=newString(“HelloWorld!”);Stringd=”Hello”+””+”World!”;

System.out.println(a==b);//trueSystem.out.println(a==c);//falseSystem.out.println(a==d);//true

咱们应该明白:

首要String不属于8种根本数据类型,String是一个目标。由于目标的默认值是null,所以String的默认值也是null;但它又是一种特别的目标,有其它目标没有的一些特性。

在这里,咱们先不谈堆,也不谈栈,只先简略引进常量池这个简略的概念。常量池(constantpool)指的是在编译期被确认,并被保存在已编译的.class文件中的一些数据。它包括了关于类、办法、接口等中的常量,也包括字符串常量。

Java会确保一个字符串常量只有一个复制。由于比如中的a和b都是字符串常量,它们在编译期就被确认了,所以a==b为true;而”Hello”和””以及”World!”也都是字符串常量,当一个字符串由多个字符串常量衔接而成时,它自己必定也是字符串常量,所以d也相同在编译期就被解析为一个字符串常量,所以d也是常量池中”HelloWorld!”的一个引证。所以咱们得出a==b==d;用newString()创立的字符串不是常量,不能在编译期就确认,所以newString()创立的字符串不放入常量池中,它们有自己的地址空间。

比如2:

Stringa=”HelloWorld”;Stringb=newString(“HelloWorld”);Stringc=”Hello”+newString(“World”);

System.out.println(a==b);//falseSystem.out.println(a==c);//falseSystem.out.println(b==c);//false

比如2中a仍是常量池中”HelloWorld”的引证,b由于无法在编译期确认,所以是运行时创立的新目标”HelloWorld”的引证,c由于有后半部分newString(“World”)所以也无法在编译期确认,所以也是一个新创立目标”HelloWorld”的引证,明白了这些也就知道为何得出此结果了。**PS:**String.intern():再弥补介绍一点:存在于.class文件中的常量池,在运行期被JVM装载,并且能够扩大。String的intern()办法便是扩大常量池的一个办法;当一个String实例str调用intern()办法时,Java查找常量池中是否有相同Unicode的字符串常量,假如有,则回来其的引证,假如没有,则在常量池中添加一个Unicode等于str的字符串并回来它的引证,看例3就清楚了。

比如3:

Stringa=”Hello”;Stringb=newString(“Hello”);Stringc=newString(“Hello”);

System.out.println(a==b);//falseSystem.out.println(“**********”);

b.intern();

c=c.intern();//把常量池中”Hello”的引证赋给cSystem.out.println(a==b);//false尽管执行了b.intern()但没有赋值给bSystem.out.println(a==b.intern());//trueSystem.out.println(a==c);//true

比如4:

关于equals()和==:equals()是比较两个目标的值是否持平,这个对于String简略来说便是比较两字符串的Unicode序列是否适当,假如持平回来true;而==是比较两字符串的地址是否相同,也便是是否是同一个字符串的引证。

比如5:

String是不可变的:这一说又要说许多,大家只要知道String的实例一旦生成就不会再改变了,比如说:Stringstr=”aa”+”bb”+”“+”cc”;便是有4个字符串常量,首要”aa”和”bb”生成了”aabb”存在内存中,后”aabb”又和”“生成”aabb“存在内存中,最后又和生成了”aabbcc”,并把这个字符串的地址赋给了str,便是由于String的“不可变”产生了许多临时变量,这也便是为什么建议用StringBuffer的原因了。

三、StringBuffer和StringBuiler

咱们对String、StringBuffer、StringBuiler先有一个简略的知道。String是不可变字符串,StringBuffer和StringBuilder是长度可变的字符串,差异是前者是线程安全的,后者是线程不安全的,相同后者的功率也会更高。

StringBuffer上的主要操作是append和insert办法,可重载这些办法,以承受恣意类型的数据。每个办法都能有效地将给定的数据转化成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。append办法始终将这些字符添加到缓冲区的结尾;而insert办法则在指定的点添加字符。

例如,假如z引证一个当时内容为”start”的字符串缓冲区目标,则此办法调用z.append(“le”)会使字符串缓冲区包括”startle”,而z.insert(4,”le”)将更改字符串缓冲区,使之包括”starlet”。

一般,假如sb引证StringBuilder的一个实例,则sb.append(x)和sb.insert(sb.length(),x)具有相同的作用。

还有delete删除办法deleteCharAt(intindex)delete(intstart,intend)

© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享
评论 抢沙发

请登录后发表评论