黑马程序员 Java基础 ---> String类

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

String类

　　String类是java字符串类，是Java中使用最多的类，也是最为特殊的一个类。

　　

一、String类的特点：

　　String类是一个final类，不可被继承。

　　String类的底层是字符数组char[], 并且其值不可改变。

　　String类对象有个特殊的创建的方式，就是直接指定比如String x = "abc"，"abc"就表示一个字符串对象。而x是"abc"对象的地址，也叫做"abc"对象的引用。

　　String对象可以通过“+”串联。串联后会生成新的字符串。也可以通过concat()来串联，这个后面会讲述。

　　Java运行时会维护一个String Pool（String池），JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。

　　创建字符串的方式很多，归纳起来有三类：

　　　　一，使用new关键字创建字符串，比如String s1 = new String("abc");

　　　　二，直接指定。比如String s2 = "abc";

　　　　三，使用串联生成新的字符串。比如String s3 = "ab" + "c";

二、String对象的创建

String对象的创建也很讲究，关键是要明白其原理。

　　原理1：当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个X在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。

　　原理2：Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。

　　原理3：使用直接指定或者使用纯字符串串联来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象。

　　原理4：使用包含变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String对象。

　　另外，String的intern()方法是一个本地方法，定义为public native String intern(); intern()方法的价值在于让开发者能将注意力集中到String池上。当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则

返回池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。

三、不可变类

　　不可改变的字符串具有一个很大的优点：编译器可以把字符串设置为共享。不可变类String有一个重要的优点－它们不会被共享引用。JAVA为了提高效率，所以对于String类型进行了特别的处理－－－为string类型提供了串池 定义一个string类型的变量有两种方式：

　　string name= "tom ";

　　string name =new string( "tom ")

　　使用第一种方式的时候，就使用了串池，

　　使用第二中方式的时候，就是一种普通的声明对象的方式

　　如果你使用了第一种方式，那么当你在声明一个内容也是 "tom "的string时，它将使用串池里原来的那个内存，而不会重新分配内存，也就是说，string saname= "tom ",将会指向同一块内存。

另外关于string类型是不可改变的问题：

　　string类型是不可改变的，也就是说，当你想改变一个string对象的时候，比如name= "madding " ，那么虚拟机不会改变原来的对象，而是生成一个新的string对象，然后让name去指向它，如果原来的那个 "tom "没有任何对象去引用它，虚拟机的垃圾回收机制将接收它。据说这样可以提高效率！！！

String类的常用方法

返回值　　　　　　方法　　　　　　　　　　　　　　　　　　　功能

char charAt(下标) 　　　　　　　　　　　　　　 获取指定坐标的字符

int indexOf(字符串)　　　　　　　　　　　　　 获取字符串位置

int　　　　　　 　indexOf(字符串,从x下标开始)　　　　　　　 获取字符串位置

int　　　　　　 　lastIndexOf(字符) 　　　　　　　　　　　 获取字符位置(从右边开始查找)

int　　　　　　　 lastIndexOf(字符,从x下标开始) 　　　　　 获取字符位置

boolean startsWith(字符串) 　　　　　　　　　　　 判断是否以某个字符串开头

boolean startsWith(字符串,从x下标开始)　　　　　　　 判断是否以某个字符串开头

boolean endsWith(字符串)　　　　　　　　　　　　　 判断是否以某个字符串结尾

boolean isEmpty() 　　　　　　　　　　　　　 判断是否为空

boolean contains(字符串) 　　　　　　　　　　　　　 判断是否包含某个字符串

boolean equals(字符串) 　　　　　　　　　　　　　 判断字符串是否相同

boolean equalsIgnoreCase(字符串) 　　　　　　　　 判断字符串是否相同(忽略大小写)

char[] tocharArray () 　　　　　　　　　　　　 将字符串转为char数组

String replace(被替换字符串,新字符串)　　　　　　　替换字符串

String[] 　　　　 split(字符串) 　　　　　　　　　　　　　　　 切割字符串

String 　　　　 toUpperCase()　　　　　　　　　　　　　　 将小写字符转为大写

String 　　　　 toLowerCase() 　　　　　　　　　　　　 将大写字符转为小写

String 　　　　 substring(开始坐标) 　　　　　　　　　　　 获取子字符串

String 　　　　 substring(开始坐标,结束坐标)　　　　　　　　 获取子字符串

String 　　　　 trim() 　　　　　　　　　　　　　　　　　　去除两端空格

注：上面所说的 x是int类型的数值，例如 “从x下标开始”，indexOf("m",5)。

public class StringDemo {
public static void main(String[] args) {
//		1,因为直接定义是字符串常量,所以先去常量池去看,如果没有就创建,有就不创建了
String str = "abc";
String str1 = "abc";
//		System.out.println(str == str1);//true
//		2,这句话创建了两个对象,先去常量池中看有没有abc这些字符,如果有,就把他拷贝
//		一份给堆内存,如果没有就创建一个
String str2 = new String("abc");
String str3 = new String("abc");
//		System.out.println(str2 == str3);//false
//		3,字符串相连接在也是两个常量相连接所以也会先在常量池去看,如果有就不创建了
String str4 = "a" +"bc";
//		System.out.println(str == str4);
//		System.out.println(str.equals(str2));
//		System.out.println(str2.equals(str3));
//		4,String类的构造方法,将字节数组转成字符串
byte[] arr = {65,66,67,68,69,70};
String s2 = new String(arr);
//		System.out.println(s2);
//		5,String类的构造方法2,将字节数组的一部分转换成字符串
String s3 = new String(arr,1,4);
System.out.println(s3);
}
}

public class StringDemo1 {
public static void main(String[] args) {
/*
* 1，判断。
1.1 判断两个字符串内容是否相同。
boolean equals(Object)：覆盖了Object类中的方法。
1.2 判断两个字符串内容是否相同，忽略大小写。
boolean equalsIgnoreCase(string)应用:注册用户名,搜索
1.3 判断一个字符串中是否包含另一个字符串。
boolean contains(string):jdk1.5出现的功能。文件搜索功能
1.4 判断一个字符串是否以一个字符串开头。
boolean startsWith(string):
1.5 判断一个字符串是否以一个字符串结尾。判断文件后缀名
boolean endsWith(string);
1.6 判断字符串是否有具体的字符数据。或者成为判断字符串是否有内容。
boolean isEmpty():原理就是判断字符串的长度是否为0.该方法是jdk1.6版本。
public boolean isEmpty(){
return this.length()==0;}

*/
//1,忽略大小写比较两个字符串
String str1 = "abc";
String str2 = "ABC";
//System.out.println(str1.equals(str2));
//System.out.println(str1.equalsIgnoreCase(str2));
//2,判断是否包含
String str3 = "abcdefgh";
//		System.out.println(str3.contains(str1));
//		System.out.println(str3.contains(str2));
//3,一个字符串是否以另一个字符串开头
String str4 = "a";
String str5 = "c1";
//		System.out.println(str3.startsWith(str4));
//		System.out.println(str3.startsWith(str5));
//4,一个字符串是否以另一个字符结尾
String str6 = "gh";
//		System.out.println(str3.endsWith(str6));
System.out.println(str3.endsWith(str4));
}
}

public class StringDemo2 {
public static void main(String[] args) {
/*
* 2.1 获取字符串的长度。
int length();
2.2 根据指定的位置获取该位置对应的字符。
char charAt(index);
2.3 根据字符获取该字符第一次出现的位置
int indexOf(int ch);
int idnexOf(int ch,fromIndex):从fromIndex位置开始获取ch第一次
出现的位置对应的角标,角标不会从fromIndex开始,而是从0开始。找到了
就返回第一次出现角标位，没找到，就返回-1.所以，可以通过-1这种方式
判断一个字符是否在字符串存在。
2.4 根据字符串获取该字符串第一次出现的位置
int indexOf(string str);
int idnexOf(string str,fromIndex):从fromIndex位置开始
获取string第一次出现的位置。
2.5 同样是获取一个字符或者字符串第一次出现的位置，但是是通过反向索引完成。角标还是从前往后,0开始
功能和indexOf一致。
int lastIndexOf(ch);
int lastIdnexOf(ch,fromIndex):
int lastIndexOf(string);
int lastIdnexOf(string,fromIndex):
2.6 获取字符串中的一部分字符串。
String substring(start):从start开始到结尾。
String substring(start,end);获取到的字符串包含start位，不包含end位。

*/
//1,获取字符串的长度
String str = "abcfcccdefcccghf";
String str5 = "abcfcccdefcccghf";
//boolean b1 = str.equals(str5);
//System.out.println(b1);
int x = str.length();
//		System.out.println(x);
//2,根据指定的角标获取对应的字符
char ch = str.charAt(1);
//System.out.println(ch);
//3,根据字符获取对应的角标
int y = str.indexOf(98);
//System.out.println(y);
//4,根据我们的角标,找到对应字符第一次出现的位置
int z = str.indexOf(99,6);
//System.out.println(z);
//5,根据字符串找字符串所对应的位置
String str1 = "ccc";
int i = str.indexOf(str1);
//System.out.println(i);
//6,反向索引
int j = str.lastIndexOf('f');
//System.out.println(j);
int a = str.lastIndexOf('f',9);
//System.out.println(a);
//7,通过传入的字符串反向索引
int b = str.lastIndexOf(str1);
//System.out.println(b);
//8,通过传入的字符串反向索引,在指定的位置开始
int c = str.lastIndexOf(str1, 9);
//System.out.println(c);
//9,获取字符串的一部分
String str2 = str.substring(5);
System.out.println(str2);
//10,获取字符串的一部分,有开始,有结束,包含头,不包含尾
String str3 = str.substring(5, 7);
System.out.println(str3);
//11,想让子串正好等于原来的串
String str4 = str.substring(0, str.length());
System.out.println(str4);
}
}

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------