String类的概述

String类是一个由final关键字修饰的类,这个类不可以被继承
字符串是常量,用双引号引起来表示,它们的值在内存中创建之后就不可以修改
- 如何更好的理解上面的这一句话?什么叫做字符串的值在内存中创建以后就不能修改了?
  - 其实就是说我们只要在内存中为某一个字符串常量在内存中开辟了空间,并且将这个字符串常量存了进去,那么这个内存中就一直存的是这个字符串常量,一直不可以改变,直到这一片内存被回收为止
字符串类实现了Serializable接口
- 实现这个接口表示字符串是可以序列化的,何为序列化(这个我们会在后续笔记的IO流中讲到)
  - 这里做一简单说明:其实序列化就是可以将其转换成字节流来传输
字符串类实现了Comparable接口
- 实现了Comparable接口表示字符串是可以比较大小的
String类内部定义了 final char[] value ;数组用于存储字符串数据
- 这里的value数组是通过final关键字修饰的,也就说们字符串其实是一个常量,一旦在内存中申请出一个空间并且为其赋值之后这个空间中的字符串值就不可以修改了,将这个性质我们称之为不可变性
在java中多个字符组成的一串数据都会被归为(视为)String类的一个实例对象
String对象的值一旦确定,值就不可以再次修改了,也就是值就不可变了,如果改变值就会创建一个新的对象(在底层也就是创建了一个新的数组)

上面的字符串的不可变性需要重点理解,我们的另一篇笔记:字符串的不可变性中会对这个性质进行细讲
字符串(String)就是由多个字符组成的一段数据,一旦创建之后就不能再修改
- 为什么字符串一旦创建之后就不可以修改了?
  - 这和字符串在计算机的底层的存储有关
    - 在计算机底层,字符串是以字符数组的方式一个一个字符进行存储的(jdk9.0之前),并且这个数组还是被final关键字修饰的,也就表示这是一个常量,一旦确定就不能改变
    - 在jdk9.0之后就换成了以byte数组的方式来存储了
      - 因为在计算机底层本来字符就是以十进制数表示的

String类的对象的创建方式

String类的对象的创建方式一共有两种

第一种: 简化方式(这种方式我们一般也称之为字面量定义的方式):

eg:

String s1="123";
String s2="123";
System.out.println(s1==s2);  //这个时候这两个对象指向了字符串常量池中的同一个对象,所以这里输出true

上面就是通过简化方式创建的字符串对象,这种方式创建并没有调用String类的构造方法来创建
那么简化方式在是如果创建字符串对象的呐?
- 简化方式创建对象时先去字符串常量池中去找有没有这个一个字符串对象的值和我们现在要创建的对象的值相同,如过没有一个字符串对象的值和我们现在要创建的对象的值相同时,那么这个时候就会在这个字符串常量池中创建一个对象这个值的对象,如果字符串常量池中已经有一个和这个我们想要创建的对象的值相同时,我们就直接会让我们要创建的对象的引用直接指向字符串常量池中已经有的这个对象,
也就是说:如果我们通过简化方式创建了两个值一样的字符串对象时,这两个字符串对象其实是同一个对象,它们指向了字符串常量池中的同一个对象
- 那么如果这种情况我们如果使用==进行判断这两个对象,那么返回值肯定为true

第二种:new+构造方法的方式

eg:

String s1=new String("123");
String s2=new String("123");
System.out.println("s1==s2"); //只要是new出来的就是独一无二的对象,所以这里的两个对象的地址也就不同,                                 //所以这里会输出false

深入理解字符串的不可变性

字符串的不可变性:

String类内部定义了 final char[] value ;数组用于存储字符串数据
- 这里的value数组是通过final关键字修饰的,也就说们字符串其实是一个常量,一旦在内存中申请出一个空间并且为其赋值之后这个空间中的字符串值就不可以修改了,将这个性质我们称之为不可变性

深入理解:

不可变性的体现一:

当对字符串重新赋值时我们需要重新制定一个内存区域,然后才能赋值,不能对原有的value进行赋值(也就是我们不能改变原有的value)

这里其实就是我们每当有一个对象就有一次给value赋值的机会,这次机会用了之后,也就是赋值之后,就不可以再改变了
- 所以我们在这里说,字符串的值一旦给定就不可以再修改,一旦尝试修改,就会创建一个新的字符串对象,让这个新的字符串去接收你想要成为的值

这里我们可以举一个例子来说明

public class Demo{public static void main(String[] args){String s1="123";  //这里的赋值方式其实就是字符串的第一种创建方式,也就是通过字面量定义的方式s1="hello";   //这里我们尝试对s1的值进行修改,那么这里会发生什么呐?System.out.println(s1);}
}

在上面,我们对定义好的字符串尝试进行改变,那么有没有能成功改变s1的值呐?

这里我们其实我们在运行之后发现,输出的结果真的变成了hello
那么我们之前不是说字符串一旦赋值后就不可以改变了,这里怎么会改变呐?
- 其实这里的原来的字符串的值并没有改变,那这里的s1的值为什么改变了呐?其实这里是原来的字符串的值没有变,但是s1这个字符串变量的指向发生了变化,其实我们在做这一步尝试改变的操作的时候,我们计算机的内部会再产生一个字符串对象,给这个对象赋值为"hello",然后又然字符串变量s1指向这里的新产生的对象
- 所以这里我们说呐,就是"我本将心照明月,奈何明月照沟渠呀!",我本身没有变,但是你却指向了别人

不可变性的体现二:

当我们要对现有的字符串进行连接操作时,也需要重新指定内存区域并赋值,不能是修改原有的内存(对象)的value数组(这里的value数组就是字符串在底层存储的数组)

比如说这里我们也可以举一个例子:

public class Demo2{public static void main(String[] args){String s1="123";s1+="456";  /*这里其实就是对字符串进行了一个拼接,那么这里的拼接是对原来的s1所表示的对象进行了                     修改吗?                */ System.out.println(s1);}
}

这里的输出结果在我们运行之后我们可以发现这里的运行的结果为123456,那么这里的拼接操作到底是不是对原来的s1所指的字符串对象进行了修改呐?

其实也不是的,这就和我们上面说的一样,这里其实我们在进行字符串的拼接操作的时候我们其实也不是对原来的s1指向的对象进行了修改,而是重新在内存中创建了一个字符串对象,并给这个新创建的字符串对象赋值为123546,然后又让s1指向了这个新创建的对象
这里显然原来的字符串对象又被s1这个字符串变量(引用)给抛弃了,这个字符串变量s1又指向了新的对象了
还是那句话"我本将心照明月,奈何明月照沟渠啊!"这个引用它又去指向别人了

字符串不可变性的体现三:

当我们调用String类的replace()方法来修改制定字符或者制定字符串时,也需要重新创建内存区域(对象,这里的内存区域其实就指的是对象)并且给这个新对象赋值,不能对原有的对象的value进行赋值

这里我们也可以再举一个例子:

public class Demo3{public static void main(String [] args){String s1="1213";s1=s1.replace("1","6"); //这里的replace()方法的返回值为String类型System.out.println(s1);  //想一下,这里的输出结果应该是什么?}
}

上面的输出结果应该是 6263,为什么是6263呐?因为我们使用s1对象调用replace()方法将s1对象中的字符1全部更换为了字符6,那么这个时候我们的s1的原有对象是不是还保持不变呐?

答案是’是的’,s1指向的原来的对象还是没有改变,只是我们再调用这个replace()方法时,系统又为我们在内存中开辟了一个空间,并且将这个新的值赋给了这个新的字符串对象,然后我们后面又将这个返回值赋给了s1,也就是又让这个s1引用指向了这个新的对象,这个时候,我们的s1又抛弃了我们的原来的对象了
又是那句话.脱口而出"我本将心照明月,奈何明月照沟渠啊!"
别急 ,最后这里还有一道经典的关于字符串的面试题

只要你把这道题做对了,也就说明你对字符串的底层存储有一定的了解

public class Demo {public static void change(String s1){s1="1234";}public static void main(String[] args) {String s1="123";Demo.change(s1);System.out.println(s1);  //那么这里输出的结果应该是多少?}
}

首先:上面的输出结果是:123
为什么不是1234呐,很多人都会犯这个错误,都会认为这里返回的结果会是1234,因为很多人都认为这里通过这个change()函数传递的是主函数中变量s1的地址,所以这里我们在change()方法中改变了s1的值,然后这里就会影响到实参的值,也就是会影响到主函数中s1的值,那么真的是这样吗?
- 显然不是这样的,那到底是为什么呐?
  - 这里我们一步一步过一遍思路.首先,我们进入到主方法中,在主方法中我们声明了一个局部变量s1,然后我们就调用了Demo类中的静态成员方法change(),我们在这方法中传递的是我们主方法中的局部变量s1,由于这里的s1是字符串,是引用类型,所以这里传递的是一个地址,我们现在假设这个地址为100,然后我们就进入到了这个成员方法中,进入这个成员方法,我们又创建了一个change()方法的局部变量s1,这个s1现在的地址也是s1,我们下一步在将这个s1对应的字符串尝试修改,这里一旦修改就出问题了,这里我们尝试修改这个字符串通过前面的知识点我们知道了,这里其实是在内存中重新创建了一个字符串对象,我们假设这个字符串对象的地址为102,那么这里我们就会让s1的对象指向这个新的对象,也就是现在的change()方法中的局部变量的s1指向的地址为102,那么我们就又回到了主方法中,回到了主方法中之后我们输出这个主方法中的s1也就是输出的地址为100的对象的值,自然输出的也就还是123
  - 所以呐,这里我们进入到这个change()方法之后其实没有对这个原有地址进行操作,所以实参,也就是主函数中的s1变量自然也就没有受到影响

总结:

String类型的对象的值一旦给定后,就不可以再改变了,如果改变了,就是创建了一个新的对象,并且将新的值赋给这个新的对象

String对象的创建方式(两种)

方式一:

通过字面量定义的方式(也称之为简化方式)

String str = "123";

方式二:

通过new+构造器的方式

String s1 = new String();//这里就是创建了一个空字符串String str =new String("");//这里也是创建了一个空字符串

上面的s1的创建方式的本质是: this.value =new char[0];

String s2 = new String(String original);

本质: this.value=original.value;

String s3 = new String(char[] a);

本质: this.value=Arrays.copyOf(value , value.length);

String s4 =new String(char[] a, int startIndex, int count);

这种方式就是上面s3方式创建的进阶版,就是可以指定数组开始复制的地方,并且可以指定赋值多少个数到字符串

String对象两种实例化方式的对比

通过字面值直接赋值创建的方式:

这个时候如果有多个字符串变量以字面值创建方式创建,那么这些字符串变量其实是指向了同一个对象,指向了同一个地址(这个地址是字符串常量池中的一个地址)

通过字面值创建的方式我们在创建时先要看在字符串常量池中有没有值和我们要创建的字符串对象的值一样的,如果没有,就在字符串常量池中创建出一个对象,如果已经有了的话,那么我们只需要将这个字符串引用指向字符串常量池中的这个对象的地址就可以了
注意:字符串常量池中不允许有多个相同值的对象,每个值的对象在字符串常量池中最多有一个,第二次创建时只需要将引用指向已有的对象就可以了

这里我们可以来看一个例题:

public class Demo{public static void main(String [] args){String s1="123";String s2="123";System.out.println(s1==s2);//这里输出的结果是什么?}
}

这里输出的结果也是true

由于我们这里通过字面量直接赋值的方式创建了两个相同值的对象,所以这里创建的两个字符串变量是指向了同一个对象的首地址,也就是指向了同一个内存区域,

通过new+构造器的方式创建的方式:

通过这种方式创建的多个相同值的字符串对象的地址不同,这种方式创建就是在堆区中创建字符串对象,在堆区中创建出来的对象每一个对象都是独一无二的

这里有一个例题:

public class Demo2{public static void main(Stirng[] args){String s1=new String("123");String s2=new String("123");System.out.println(s1==s2); //这里的输出结果是true还是false呐?}
}

上面的输出结果是false

原因:这里我们通过new + 构造器的方式创建字符串对象是在堆区中创建的,每个对象都是独一无二的,这时候的输出结果也就为false

最后:这里由一道面试题

问题:在String s =new String("abc");这条语句执行时创建了几个对象?

答案是创建了两个对象
因为这里我们在实质上是执行了 String str =new String(String original);
而这条语句的本质是:this.value=original.value;
也就是这里我们穿参的时候可以说是执行了 string original =“abc”; (在这里我们在字符串长两处中创建了第一个对象)
接下来我们又通过new关键字创建了第二个对象(s),这个对象是在堆空间中创建的

String不同拼接操作的对比

常量与常量的拼接结果是在常量池中,且常量池不会存在相同内容的常量
只要其中有一个是变量,结果就在堆中(也就是会通过new产生,那么也就说明只要其中有一个是变量,那么就会在堆内存中去创建一个独一无二的对象,这个对象的地址自然也就是独一无二的)
如果拼接的结果调用了intern()方法,返回值就在一定在常量池中
- 如果一个堆中的字符串对象调用这个intern()方法,那么返回的结果就会是字符串常量池中和这个堆中对象的value值一样的对象(也就是返回了一个字符串常量池中的字符串对象)

如何判断自己是不是懂了:

这里有一道题:做对了就懂了:

public class Demo{public static void main(){String s1="javaEE";String s2="hadoop";String s3="javaEEHadoop";String s4="javaEE"+"hadoop";String s5=s1+"hadoop";String s6="javaEE"+s2;String s7=s1+s2;String s8=s7.intern();System.out.println(s3==s4);  /*这里的输出结果为true,原因是:s4是的字符串运算时两边都是字符串常量,那么这个新对象是从字符串常量池中产生的,而s3是字面量赋值直接创建的对象,s3对象也是从字符串常量池中产生的,并且这两个值相等,所以这个时候输出的结果为true*/System.out.println(s3==s5);/*这里输出的结果为false,因为这里s5是有一边是变量连接的,所以就会从堆空间区产生这个新的对象,这个时候我们的这个值也就独一无二的,所以比较的结果肯定就是false*/System.out.println(s3==s7);  /*这里的输出结果也为false*/System.out.println(s5==s6);  /*这里的输出结果也为false*/System.out.println(s8==s3);/*这里输出的结果为true,因为这里我们的s8对象产生是s7对象调用了intern()方法之后产生的,那么这个时候的s8对象其实就是从字符串常量池中产生的了,那么这个时候由于s3也是从字符串常量池中产生的,所以这个时候的结果就应该为true*/System.out.println(s8==s7);/*这里输出的结果为false,因为这里的s7还是通过了变量连接的,那么这个时候的s7是独一无二的,那么也就说明这个时候的结果就应该为true*///判断一下上面的输出结果都是什么}
}

jvm中涉及字符串的内存结构

随着时代变化jdk在变化,在进步,jvm也会有所变化
三种常用的jvm
1. sun公司的HotSpot //这个是使用最多的java虚拟机
2. BEA公司的JRockit
  - 上面的1和2是使用的最多的java虚拟机
3. IBM公司的J9vm
咱们通常指的jvm就是sun公司的HotSpot
jdk1.6之前jvm将字符串常量池设置到了方法区中(这里也称之为永久代)
jdk1.7中jvm将字符串常量池设置到了堆空间中
jdk1.8开始jvm又将字符串常量池设置到了方法区(元空间)中
- 这里是到jdk1.8将方法区不叫永久代了,而改名为元空间了

String类中的常用方法一:

字符串(String)的底层其实就是一个数组,只不过字符串中将这个数组封装起来了

int length();
- 返回字符串的长度
- return value.length;
char charAt(int index);
- 返回某索引处的字符
- return value[index];
boolean isEmpty();
- 判断字符串是不是空串
- return value.length==0;
String toLowercase();
- 使用默认语言环境,将String中所有的字符转为小写
String toUppercase();
- 使用默认语言环境,将String中所有的字符转为大写
String trim();
- 返回字符串的副本,忽略前导空白和后导空白
- 只去出字符串前面和后面的空格,而不删除字符串中间的空格
  - 可用于输入用户名查找时,如果客户在输入的名字前多输了空格或者在名字后面多输了空格,这个时候我们就需要通过这个方法来删除用户名前面和用户名后面的空格,就能保证用户搜索的正确性
boolean equals(Object obj)
- 比较字符串的内容是否相同
boolean equalsIgnorecase(String anotherString);
- 这个方法与上面equals()方法类似不同的地方在于这个equalsIgnorecase()方法比较时忽略大小写
String concat(String str);
- 将制定的字符串连接到此字符串的结尾
- 等价于使用’+’,所以我们一般不常使用
int compareTo(String anotherString);
- 比较两个字符串的大小
- 结果为负数时:当前对象小,参数对象大
- 结果为正数时:当前对象大,参数对象小
- 结果为0,两个字符串对象大小相同
- 这里就涉及到了字符串排序
String substring(int beginIndex);
- 返回一个截取的字符串
- 它是从此字符串中从beginIndex索引开始一直到最后截取的一个子串
String substring(int beginIndex,int endIndex);
- 返回一个截取的字符串
- 为左闭右开区间截取

String类中的常用方法二

boolean endsWith(String suffix);
- 测试此字符串是否是以指定的后缀结束
  - 这里的后缀可以是一个空字符串也可以是由多个字符构成的字符串
boolean startsWith(String prefix);
- 测试此字符串是否是以制定的字符串开始
  - 同样的这里的字符串可以是空字符串,也可以是由多个字符构成的字符串
boolean startsWith(String prefix,int toffset);
- 此时此字符串从制定索引开始的子字符串是否以制定的前缀开始
boolean contains(charSequence s); [常用]
- 当且仅当此字符串中包含指定的char值序列时,返回true,否则返回false
  - 也就是判断这个字符串中有没有包含参数字符串,如果包含返回true,如果没有包含返回false
- 这里的charSequence是一个接口,表示一个char值序列
- String类中实现了这个charSequence接口,所以在这个方法中一般是传递一个String类型,这个时候就是charSequence接口类型的引用指向这个接口的实现类的对象

java中严格区分大小写,除非在某些特定的方法中才不区分大小写
- eg:equalsIgnorecase(String s),
- 还有就是布尔型包装类的构造方法中以String类型作为形参来构造包装类时不区分大小写(这个其实也是java官方的一个优化)
  - Boolean b1=new Boolean(“TRue”);//这里虽然我们是大小写混合的,但是其实这个不区分大小写.
    - 所以这个b1的值为true
5.int indexOf(String str);
- 返回指定子字符串在此字符串中第一次出现的索引
  - 如果这个时候可以找到这个指定字符串,那么就输出这个指定字符串在此字符串中第一次出现的首字母的索引
  - 如果找不到这个指定的字符串,那么这个时候就会返回-1,
    - 这里返回-1是有原因的,因为字符串的索引可能是从0开始的正整数,但是永远不可能是负数,所以我们就是用-1来表示找不到这个字符串

int indexOf(String str int fromIndex);
- 从指定的索引开始找此字符串中有没有出现这个特定的字符串
  - 如果找不到的话也是返回-1;
  - 这个方法我们可以用于去寻找这个一个字符串中出现了多少次另一个字符串
    - 第一次找------->返回索引------->第二次找的时候从前一次返回的缩影加这个寻找的字符串的长度之后的值作为第二次的开始继续寻找(然后重复多次操作)
int lastIndexOf(String Str);
- 返回这个指定字符串在此字符串中最后一次出现的位置的索引
int lastIndexOf(String str,int fromIndex);
- 从这个字符串中的最开始到指定索引处的子串中找最后一次出现特定的字符串的索引
- 也就是从指定索引处开始从左向右进行搜索这个指定字符串
- 也就是这里的索引,也就是这个fromIndex如果我们输入的时6,那么这个时候我们是在0-----6之间查找这个特定字符串最后一次出现的位置

注意 indexOf()方法和lastIndexOf()方法找不到这个特定的字符串序列时都是返回一个-1

String类中的常用方法三

替换

String replace(char oldChar,char newChar);
- 这个方法返回一个新的字符串,它是通过newChar字符替换了原来字符串中的oldChar字符
String replace(charsequence target, charsequence replacement);
- 是用指定的字面值替换序列替换此字符串中所有和目标序列相同的子字符串
String replaceAll(String regex,String replacement);
- 使用给定的replacement字符串替换此字符串中所有匹配给定正则表达式的子字符串
- 这里的regex是正则的意思(这个具体我们会在数据库中讲到)
String replaceFirst(String regex,String replacement);
- 使用给定的replacement字符串替换此字符串中第一个匹配给定正则表达式的子字符串

匹配

boolean matchs(String regex);
- 判断此字符串是否匹配给定的正则表达式(也就是判断这个字符串是不是规定的正则表达式所表示的格式)

切片

String[] split(String regex);
- 根据给定的正则表达式将此字符串拆分成一个字符串数组
- 注意:这里的返回值为String [] (字符串数组 )
String[] split(String regex,int limit);
- 将拆分范围内的符合给定的正则表达式的字符串拆成一个字符串数组
- 这里的返回值也为字符串数组的形式

String与char[]之间的转换

虽然String的底层就是通过char[]来存储的,但是有的时候我们还是要将字符串转换成char[]来操作(比如我们要给字符串中的元素排序的话,这个时候我们直接对这个字符串进行排序显然是有些困难的,这个时候我们就可以将这个字符串转换成一个char[],这个时候我们再对这个char[]进行操作,我们直接可以调用数组的排序方法直接对这个char[]进行排序,排完序之后我们再将这个char[]转换成字符串,这样我们就很轻易的解决了这个问题)

String ----> char[]

调用String中的toCharArray();

char[]----->String

调用String的构造方法(new String(char[] chars))

或者是调用String的valueOf(char[] chars)方法(这个方法是一个静态方法,直接通过String.来调用)

这里我们学习了String和char[]之间的转换之后可以干什么?

比如有一个题

我们要将字符串"abc123" 转变成 “a21cb3”

这个时候我们就可以是通过先将字符串"abc123"转变成一个char[],然后再在这个char[]中改变字符的顺序,然后改变顺序之后再将其转变为为字符串

String与byte[]之间的转换

String----->byte[] (我们将这一过程也称之为编码)

调用String的getBytes()方法

这个getBytes()方法中可以传输一个字符串实参,表示你想通过哪种编码集进行编码,但是这里会抛出一个编译时异常,这个异常就是担心用户可能会输入了一个没有的字符集,所以我们在这里就要将这个异常处理掉,要么就是使用try-------catch----------finally方式直接当场解决.要么就是用throws+异常类型将这个异常抛出

byte[]------>String(我们将这一过程称也之为解码)

调用String的构造器(String类中提供了很多的构造器,我们可以使用形参为byte[]的构造器来将byte[]转化为一个String类型的对象)

这里的String的构造器中提供了很多种重载的方式,这里除了有形参为byte[]的构造器,还有有两个参数的构造器,这个构造器中除了要输入这个byte[]之外我们还要输入一个String类型的参数,这个String类型的参数就是指定的编码集,我们就可以以某种特殊的编码集进行解码

编码: 字符串-------->字节码(我们看的懂得变成我们看不懂的)

解码: 字节码-------->字符串)(将看不懂的转换成我们都可以看的懂得)

在计算机的底层肯定是要将这些字节码继续转换称为计算机能认识的二进制数据

我们常用的编码就是UTF-8编码和GBK编码,

UTF-8编码表中汉字是三个字节存储的

GBK编码表中汉字是两个字节存储的

在我们编码和解码的过程中我们一般是要使用相同类型的编码表进行操作,否则就可能会出现乱码,但是也有可能不会出现乱码

什么时候不会出现乱码?
就是你的字符串内容都是ASCII字符集中的符号时就一般不会出现乱码
- 为什么? 因为美国人开始编程早,所以我们大多是的字符集的最开头都是ASCII字符集的一个复制.所以我们适用绝大多数的编码表进行编码时它们开头的前128为都是ASCII编码字符(也就是美国通用的一种编码表,其中包含了所有的英文字符),所以也不会产生乱码,因为它们在每个字符集中的编码都一样

String类的全面总结[java]相关推荐

Java——String类中的compareTo方法总结
String类的定义: java.lang 类 String java.lang.Object java.lang.String 所有已实现的接口: Serializable, ...
Java里的字符串, String类简单介绍.
String类在java面试中也是1个常见的问题点. 所以也是写在这里方便以后查阅了. 大家都知道c语言里是没有String 字符串这个数据类型的. 只能用字符数组的1个特殊形式来表示一个字符串, 就 ...
第三次学JAVA再学不好就吃翔(part47)--String类的构造方法
学习笔记,仅供参考文章目录 String类 String类概述 String类的构造方法 String类 String类概述 String是java.lang包下的一个类,使用String类时不需要 ...
java字符串常量池长度_Java String类相关知识梳理（含字符串常量池（String Pool）知识）...
目录 1. String类是什么 1.1 定义 1.2 类结构 1.3 所在的包 2. String类的底层数据结构 3. 关于 intern() 方法(重点) 3.1 作用 3.2 字符串常量池(S ...
Java中字符串的学习（一）String类的概述及常见方法使用
转载请注明出处http://www.cnblogs.com/devtrees/p/4347079.html (拓展:Api:编程语言对外给我们提供的应用程序接口.) 一．概述: 我们平时上网发帖,帖子 ...
java中String类是什么_Java中字符串的学习（一）String类的概述及常见方法使用
转载请注明出处http://www.cnblogs.com/devtrees/p/4347079.html (拓展:Api:编程语言对外给我们提供的应用程序接口.) 一．概述: 我们平时上网发帖,帖子 ...
java random api_API中的Scanner、Random、ArrayList、String类
API概述 API(Application Programmming Interface)应用程序编程接口,javaAPI对于程序员来说就是一本可以检索查找的[字典],是JDK官方提供给程序开发者使用 ...
java基础知识--(常用类）String类
8.01 String简介 String(字符串常量)概述 String 类代表字符串.Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现. 字符串是常量: ...
java常用类：1。包装类（以Integer类为例）2.String类 3.StringBuffer
包装类把八大基本数据类型封装到一个类中,并提供属性和方法,更方便的操作基本数据类型. 包装类的出现并不是用于取代基本数据类型,也取代不了. 包装类位于java.lang包中. Number 类 Nu ...

String类的全面总结[java]