字符串相关的类:String
String的特性
- String类:代表字符串。Java 程序中的所有字符串字面值(如"abc" )都作为此类的实例实现。
- String是一个final类,代表不可变的字符序列。
- 字符串是常量,用双引号引起来表示。它们的值在创建之后不能更改。
- String对象的字符内容是存储在一个字符数组value[]中的。
String对象的创建
String str = "hello";
//本质上this.value = new char[0];
String s1 = newString();
//this.value = original.value;
String s2 = newString(String original);
//this.value = Arrays.copyOf(value, value.length);
String s3 = newString(char[] a);
String s4 = newString(char[] a,intstartIndex,intcount);
-
字符串常量存储在字符串常量池,目的是共享
-
字符串非常量对象存储在堆中。
/**
* String的使用:
*
*/
public class StringTest {
/*
结论:
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量,结果就在堆中
3.如果拼接的结果调用intern()方法,返回值就在常量池中
*/
@Test
public void test3(){
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;
System.out.println(s3 == s4); //true
System.out.println(s3 == s5); //false
System.out.println(s3 == s6); //false
System.out.println(s5 == s6); //false
System.out.println(s6 == s7); //false
String s8 = s7.intern();//返回值得到的s8使用的常量值中已经存在的"JavaEEhadoop"
System.out.println(s8 == s4); //true
}
/*
String的实例化方式:
方式一:通过字面量定义的方式
方式二:通过new + 构造器的方式
面试题:
String str = new String("abc"); 该方式创建对象,在内存中创建了几个对象?
答:两个; 一个是堆空间中new结构,另一个是char[]对应的常量池中的数据:"abc"
*/
@Test
public void test2(){
//此时的s1和s2的数据JavaEE声明在方法区的字符串常量池中
String s1 = "JavaEE";
String s2 = "JavaEE";
//通过new + 构造器的方式:此时的s3,s4保存的地址值,是数据在堆空间中开辟空间以后对应的地址值
String s3 = new String("JavaEE");
String s4 = new String("JavaEE");
System.out.println(s1 == s3);//false
System.out.println(s3 == s4);//false
System.out.println(s1 == s2);//true
System.out.println("--------------");
Person p1 = new Person("Tom",12);
Person p2 = new Person("Tom",12);
System.out.println(p1.name.equals(p2.name)); //true
System.out.println(p1.name == p2.name); //true
}
/*
String字符串,使用一对""引起来表示
1.String声明为final的,不可被继承
2.String实现了Serializable接口:表示字符串是支持序列化的
String实现了Comparable接口:表示可以比较大小
3.String内部定义了final char value[]用于储存字符串数据
4.String代表不可变的字符序列。简称:不可变的特性
体现:1.当字符串重新赋值时,需要重新指定内存区域赋值,不能使用原有的value进行赋值
2.当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能在原有的value上进行赋值
3.当调用String的replace()方法修改指定的字符或字符串时,也需要重新指定内存区域赋值
5.通过字面量的方式(区别于new方式)给一个字符串赋值,此时的字符串值声明在字符串常量池中
6.字符串常量池中是不会储存相同内容的字符串的
*/
@Test
public void test1(){
String s1 = "abc"; //字面量的定义方式
String s2 = "abc";
String s01 = "abc";
s1 = "hello";
System.out.println(s1);
System.out.println(s2);
System.out.println(s2 == s01);//true
System.out.println("--------------");
String s3 = "abc";
s3 += "def";
System.out.println(s3);
System.out.println("--------------");
String s4 = "aabaaacaa";
String s5 = s4.replace("aa", "m");
System.out.println(s4);
System.out.println(s5);
}
}
-
常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
-
只要其中有一个是变量,结果就在堆中
-
如果拼接的结果调用intern()方法,返回值就在常量池中
String使用陷阱
- String s1 = “a”;
说明:在字符串常量池中创建了一个字面量为"a"的字符串。
- s1 = s1 + “b”;
说明:实际上原来的“a”字符串对象已经丢弃了,现在在堆空间中产生了一个字符串s1+“b”(也就是"ab")。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的性能。
- String s2 = “ab”;
说明:直接在字符串常量池中创建一个字面量为"ab"的字符串。
- String s3 = “a” + “b”;
说明:s3指向字符串常量池中已经创建的"ab"的字符串。
- String s4 = s1.intern();
说明:堆空间的s1对象在调用intern()之后,会将常量池中已经存在的"ab"字符串赋值给s4。
面试题:
public class StringTest01 {
String str= new String("good");
char[] ch= { 't', 'e', 's', 't'};
public void change(String str, char ch[]) {
str = "test ok";//str不可变性
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest01 ex= new StringTest01();
ex.change(ex.str, ex.ch);
System.out.print(ex.str+ " and "); //str == good
System.out.println(ex.ch);
}
}
run:
good and best
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 another String):与equals方法类似,忽略大小写
String concat(String str):将指定字符串连接到此字符串的结尾。等价于用“+”
int compareTo(String another String):比较两个字符串的大小
String substring(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex,int endIndex):返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
String s1 = "hello world";
System.out.println(s1.length());
//11 返回字符串的长度:return value.length
System.out.println(s1.charAt(2));
//l 返回某索引处的字符return value[index]
System.out.println(s1.isEmpty());
//false 判断是否是空字符串:return value.length==0
String s2 = s1.toUpperCase();
System.out.println(s2);
//HELLO WORLD 使用默认语言环境,将String中的所有字符转换为大写
String s3 = s2.toLowerCase();
System.out.println(s3);
//hello world 使用默认语言环境,将String中的所有字符转换为小写
String s4 = " abc ";
System.out.println(s4.trim()+'A');
//abcA 返回字符串的副本,忽略前导空白和尾部空白
System.out.println(s3.equals(s1));
//true 比较字符串的内容是否相同
System.out.println(s2.equalsIgnoreCase(s3));
//true 与equals方法类似,忽略大小写
String s5 = s1.concat(" hahaha");
System.out.println(s5);
//hello world hahaha 将指定字符串连接到此字符串的结尾。等价于用“+”
int i = s1.compareTo("dello world");
System.out.println(i);
//4 比较两个字符串的大小 (后面减前面,!!涉及到字符串排序!!)
String s6 = s5.substring(6);
System.out.println(s6);
//world hahah 返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String s7 = s5.substring(6,11);
System.out.println(s7);
//world 返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean endsWith(String suffix):
测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):
测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix,int toffset):
测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean contains(CharSequence s):
当且仅当此字符串包含指定的char 值序列时,返回true
int indexOf(String str):
返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex):
返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex):
返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索
注:indexOf和lastIndexOf方法如果未找到都是返回-1
String s1 = "helloworld";
boolean isld = s1.endsWith("ld");
boolean isa = s1.endsWith("a");
System.out.println(isld+"\t"+isa);
//true false 测试此字符串是否以指定的后缀结束
System.out.println(s1.startsWith("hell"));
//true 测试此字符串是否以指定的前缀开始
System.out.println(s1.startsWith("ll",2));
//true 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
System.out.println(s1.contains("lo"));
System.out.println(s1.contains("d "));
//true false 当且仅当此字符串包含指定的char值序列时,返回true
String s2 = "melon";
String s3 = "wor";
System.out.println(s1.indexOf(s2));
System.out.println(s1.indexOf(s3));
System.out.println(s1.indexOf("he"));
//-1 5 0 返回指定子字符串在此字符串中第一次出现处的索引
System.out.println(s1.indexOf("wor", 4));
//5 返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
System.out.println(s1.lastIndexOf("l"));
//8 返回指定子字符串在此字符串中最右边出现处的索引
System.out.println(s1.lastIndexOf("l",7));
//3 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索