带你轻松掌握String类(文章可能比较长)

字符串是Java中经常处理的对象,如果字符串用的不好,将影响到程序运行的效率.
因此Java语言专门提供了String类,将字符串作为String类的实例来处理.以对象的方式来处理字符串,可以使字符串更加灵活方便.

一:String常用方法

1.1 声明字符串

在Java中字符串必须包含在一对双引号(" ")之内,例如:

以下这些都是字符串常量:
"3.14","abcde","你好啊!"

注意:在Java中由双引号 (" ") 包围的都是字符串,不能作为其他数据类型来使用,比如 “1+2"就不可能输出3.
声明字符串变量必须经过初始化才能使用,不然编译器会报出"变量未被初始化错误”

1.2 字符串的构造

1.在Java语言中将字符串作为对象来管理,因此可以像创建其他类对象一样来创建字符串对象.String常用的构造方法如下:

a.使用常量串构造

String s="hello world";
System.out.println(s);

b.直接newString对象

String s=new String("hello world");
System.out.println(s);

c.用一个字符数组a创建String对象.

char[] c={'h','e','l','l','o'};
String s=new String(c);
等价于:
String s =new String("hello");

1.2.1 String是引用类型.

String是引用类型.内部并不存储字符串本身，字符串具体的内容存储在对象中，而字符串引用类型变量存储的是对象的地址。

//s1和s2不是相同对象,s1和s3是相同对象
String s1=new String("hello");
String s2-new String("hello");
String s3=s1;

1.2.2 " " 引号

在Java中用" "引起来的也是String类型对象.可以用 “xxxxxx”.length()获得引号中内容的长度.

//打印字符串"hello"(String对象)长度
System.out.println("hello".length());		//5

1.3 String对象的比较

字符串的比较是常见的操作之一.通过以下几个部分进行讲解.

1.3.1 "=="比较

返回值是一个boolean类型的(true或者false).
a.对于基本类型变量,==比较的是两个变量中存储的值是否相同

public static void main(String[] args){
	int a=1;
	int b=2;
	int c=1;
	Ststem.out.println(a==b);		//false
	Ststem.out.println(a==c);		//true
}

b.对于引用类型变量,==比较的是两个引用类型引用的变量是否为同一个对象.

	String s1 = new String("hello");
 	String s2 = new String("hello");
 	String s3 = new String("world");
 	String s4 = s1;
 	System.out.println(s1 == s2); 		// false
 	System.out.println(s2 == s3); 		// false
 	System.out.println(s1 == s4); 		// true

1.3.2 equals()和equalsIgnoreCase()

两个方法比较内容是否相等,返回结果为boolean类型的(true或者false).
a.equals()方法
如果两个字符串具有相同的字符和长度,则使用equals()方法进行比较,是区分大小写的,返回值为true
语法如下:

s1.equals(s2);
s1,s2是两个需要比较的对象

b.equalsIgnoreCase()方法
是在忽略了大小写的情况下对比较两个字符串是否相等,返回结果仍然是boolean类型的.语法如下:

s1.equalsIgnoreCase(s2);
s1,s2是两个需要比较的对象

举个简单的代码例子:

public static void main(String[] args){
	String s1=new String("ABC");
	String s2=new String("abc");
	String s3=new String("ABC");
	System.out.println(s1.equals(s2));			//false
	System.out.println(s1.equalsIgnoreCase(s2));//true
	System.out.println(s1.equals(s3));			//true
}

1.3.3 compareTo()和 compareToIgnoreCase()

字典序：字符大小的顺序(对照ASCII表来看)
1.3.1和1.3.2返回的值是boolean类型,此处两个方法返回的值是int类型的.
具体比较方式为:
(1). 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
(2). 如果前k个字符相等(k为两个字符长度最小值)，返回两个字符串长度差值
a. compareTo()方法
语法:

s1.compareTo(s2);
//计算的时候是s1-s2.

public static void main(String[] args){
	String s1=new String("ABC");
	String s2=new String("abc");
	String s3=new String("abcdef");
	System.out.println(s1.compareTo(s2));		//-32  
 	System.out.println(s1.compareTo(s3));		//-32
 	System.out.println(s2.compareTo(s3));		//-3

b.compareToIgnoreCase方法,与compareTo方法相同,只是忽略大小写.

	String s1=new String("ABC");
	String s2=new String("abc");
	String s3=new String("abcdef");
	System.out.println(s1.compareToIgnoreCase(s2));	//0
 	System.out.println(s1.compareToIgnoreCase(s3));	//-3
 	System.out.println(s2.compareToIgnoreCase(s3));	//-3

1.4 字符串查找

字符串查找也是字符串中非常常见的操作，String类提供的查找的方法有很多,我就简单的介绍几个,想要深入研究的好兄弟可以去文档里查看.
我先简单列几个方法:

方法	含义
charAt(int index)	返回index位置上字符，如果index为负数或者越界,抛出IndexOutOfBoundsException异常
indexOf(int ch)	返回ch第一次出现的位置,没有的话返回-1.
indexOf(int ch,int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex)	从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int indexOf(String str)	返回str第一次出现的位置，没有返回-1
indexOf(String str,int fromIndex)	从fromIndex位置开始查找str第一次出现的位置,没有返回-1.
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

1.4.1 indexOf(String s)和lastIndexOf(String s)方法

a.indexOf(String s)方法
用于返回参数字符串s在指定字符串中首次出现的索引位置.当调用indexOf()方法时,会从当前字符串的开始位置搜索s的位置;如果没有检索到字符串s,该方法的返回值是-1.
语法如下:

str.indexOf(substr);
str是任意字符对象
substr是需要搜索的字符串.

String str="We are brothers";
int size=Str.indexOf("a");		//size=3

b.lastIndexOf(String s)方法
该方法用于返回字符串最后一次出现的索引位置.当调用lastIndexOf()方法时,会从字符串的结尾处,从右向左反向查找指定的字符串,如果找到该字符串,则返回该字符串中第一个字符的索引;如果没有查到字符串,该方法返回-1.
语法:

str.lastIndexOf(substr);
str是任意字符对象
substr是需要搜索的字符串.

String str="We are brothers";
int size=Str.lastIndexOf("s");		//size=14
int size2=str.lastIndexOf("c");		//size2=-1

1.4.2 charAt(int index)方法.

返回index位置上的字符,如果index是负数或者数组下标越界,会抛出IndexOutOfBoundsException异常

String s = "we are brothers";
char c=s.charAt(8);				//r

1.4.3 substring()方法

substring()方法可以对字符串进行截取,这些方法的共同点就是都利用字符串的下标进行截取,且对应的字符串下标都是从0开始的.
a.substring(int beginIndex)
语法如下:

str.substring(int beginIndex)
beginIndex指的是从这个索引处开始截取字符串.

String str="Hello World";
String s1=str.sunstring(3);		//lo World

b.substring(int beginIndex,int endIndex)
语法如下:

str.substring(int beginIndex,int endIndex)
beginIndex指的是从这个索引处开始截取字符串.
endIndex指的是字符串在整个字符中的结束位置.
范围是[beginIndex,endIndex),endIndex处的元素取不到.

String s2=str.substring(0,3);		//Hel

1.6 字符串转化

1.6.1 数值和字符串转化

valueOf():数字转换为字符串.
包装类型.parseInt():把字符串转化为自己想要类型的数字.

public static void main(String[] args) {
 // a.数字转字符串
 String s1 = String.valueOf(1234);
 String s2 = String.valueOf(12.34);
 String s3 = String.valueOf(true);
 System.out.println(s1);
 System.out.println(s2);
 System.out.println(s3);
 System.out.println("=================================");
 // b.字符串转数字
 // 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
 int data1 = Integer.parseInt("1234");
 double data2 = Double.parseDouble("12.34");
 System.out.println(data1);
 System.out.println(data2);
}

1.6.2 大小写转化

toUpperCase():小写全部转化为大写,
toLowerCase():大写全部转化为小写.

public static void main(String[] args) {
 String s1 = "hello";
 String s2 = "HELLO";
 // 小写转大写
 System.out.println(s1.toUpperCase());
 // 大写转小写
 System.out.println(s2.toLowerCase());
}

1.6.3 字符串转数组

toCharArray():将字符串转换为数组.

public static void main(String[] args) {
 String s = "hello";
 // 字符串转数组
 char[] ch = s.toCharArray();
 for (int i = 0; i < ch.length; i++) {
 System.out.print(ch[i]);
 }
 System.out.println();
 // 数组转字符串
 String s2 = new String(ch);
 System.out.println(s2);
}

1.7 去掉空格 (trim()方法).

trim()方法用来返回字符串的副本,忽略前导空格和尾部空格.

String s=" Java NB ";
System.out.println("字符串原来的长度: "+s.length());		//9
int ret=s.trim().length();
System.out.println("去掉空格后的长度: "+ ret);				//7

1.8 字符串分割 (split()方法)

使用split()方法可以使字符串按指定的分割字符或字符串对内容进行分割,并将分割后的结果存放在字符数组中.
a.split(String sign):
该方法可根据给定的分割符对字符串进行拆分.
sign: 分割字符串的分隔符.也可以使用正则表达式.

String s="jue.dui.ling.du";
   //按照.来进行拆分,使用转义字符\\
String[] arr1=s.split("\\.");
for (int i = 0; i < arr1.length; i++) {
    System.out.print("["+arr1[i]+"]");
}
//结果为:[jue][dui][ling][du]
System.out.println();

b.split(String sign,int limit):
该方法可根据给定的分割符对字符串进行拆分,并限定拆分的次数.
sign: 分割字符串的分隔符.也可以使用正则表达式.
limit: 模式匹配次数,如果次数是n,那么根据正则表达式匹配 n-1 次,得到的结果数组的长度不会大于n,数组最后一项是最后匹配的分割符以后的全部内容.

String[] arr2=s.split("\\.",2);
for (int i = 0; i < arr2.length; i++) {
     System.out.print("["+arr2[i]+"]");
}

二.字符串常量池

2.1直接赋值和new构造String

 String s1 = "hello";
 String s2 = "hello";
 String s3 = new String("hello");
 String s4 = new String("hello");
 System.out.println(s1 == s2); 			// true
 System.out.println(s1 == s3); 			// false
 System.out.println(s3 == s4); 			// false
}

上述创建方式,s1和s2引用的是同一个对象,而s3和s4对象不同.
在Java中, 1 , 2 , 3.14 ,"hello"等字面值常量经常频繁使用,为了使程序运行更快,更节省内存,Java为8种基本类型和String类都提供了常量池.
除了字符串常量池外，Java中还有：
a. Class常量池：每个.Java源文件编译后生成.Class文件，.Class文件中会保存当前类中的字面常量以及符号信息.
b. 运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类只保存一份.

2.2字符串常量池(StringTable)

字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构,后序给大家详细介绍)，不同JDK版本下字符串常量池的位置以及默认大小是不同的：

注意:
a.字符串常量池在JVM中字符串常量池只有一份,是全局共享的
b.刚开始字符串常量池是空的,随着程序不断运行,字符串常量池中元素会越来越多
c.字符串常量池中的内容:一部分来自运行时常量池,一部分来自程序动态添加.

2.3 String对象创建

2.3.1直接使用字符串常量进行赋值

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true

2.3.2 通过new创建String对象

图过明天进行完善.

三:字符串的不可变性

字符串是一种不可变对象. 它的内容不可改变。

String str = "hello" ; 
str += " world" ; 
System.out.println(str); 
// 执行结果
hello world

形如 += 这样的操作, 表面上好像是修改了字符串, 其实不是. += 之后 str 打印的结果却是变了, 但不是 String 对象本身发生改变, 而是 str 引用到了其他的对象.
内存变化如下:

字符串不可能被修改是因为:
a. String类在设计时就是不可改变的，String类实现描述中已经说明了.
(1)String类被final修饰，表明该类不能被继承
(2) value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。
b. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

四:StringBuffer和StringBuilder

明天进行完善.