String
什么是String
String:字符串,使用" "来表示。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
- String是声明为final的,不可被继承。
- String实现了Serializable接口:表示String是支持序列化的;
实现了Comparable接口:表示String可以比较大小。 - String内部定义了final char[] value用于存储字符串数据。
- 通过字面量的方式(区别于new方式)给一个字符串赋值,此时的字符串值声明在字符串常量池中。
- 字符串常量池中是不会存储相同内容(使用String类的equals()比较,返回true)的字符串的。
String的不可变性
String:代表不可变的字符序列,即String的不可变性。
- 当对字符串重新赋值时,需要重新指定内存区域赋值(新的内存地址),不能使用原有的value进行赋值。(test1)
- 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。(test2)
- 当调用String的replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。(test3)
public class String01 {
@Test
public void test1() {
//test1
String s1 = "abc"; //字面量的定义方式
String s2 = "abc";
s1 = "hello";
System.out.println(s1 == s2); //比较s1和s2的地址值,s1,s2都为"abc"时结果为true
System.out.println(s1); //hello
System.out.println(s2); //abc
System.out.println("=================");
//test2
String s3 = "abc";
s3 += "def";
System.out.println(s3); //abcdef
System.out.println(s2); //abc
System.out.println("=================");
//test3
String s4 = "abc";
String s5 = s4.replace('a', 'm'); //将字符串中旧的字符'a'替换为新的字符'm'
System.out.println(s4); //abc
System.out.println(s5); //mbc
}
}
String的两种实例化方式
方式一:通过字面量定义
方式二:通过new + 构造器
public class String02 {
@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 == s2); //true
System.out.println(s1 == s3); //false
System.out.println(s1 == s4); //false
System.out.println(s3 == s4); //false
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
p1.name = "Jerry";
System.out.println(p2.name); //Tom
String s5 = new String(new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g'}, 2, 4);
System.out.println(s5); //cdef 即从坐标为2的字符开始取4个字符
}
}
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
}
面试题:String s = new String(“abc”); 用这种方式创建对象的话在内存中创建了几个对象?
答:两个。一个是堆空间中的new结构,另一个是char[]对应的常量池中的数据"abc"。
String不同拼接操作的对比
public class String03 {
@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(s3 == s7); //false
System.out.println(s5 == s6); //false
System.out.println(s5 == s7); //false
System.out.println(s6 == s7); //false
String s8 = s5.intern(); //s8的返回值是使用的常量池中已经存在的"javaEEhadoop"
System.out.println(s3 == s8); //true
}
@Test
public void test4() {
String s1 = "javaEEhadoop";
String s2 = "javaEE"; //s2:变量
String s3 = s2 + "hadoop"; //变量+常量
System.out.println(s1 == s3); //false
final String s4 = "javaEE"; //s4:常量
String s5 = s4 + "hadoop"; //常量+常量
System.out.println(s1 == s5); //true
}
}
结论:
1.常量与常量的拼接结果在常量池中,且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量,结果就在堆中。
3.如果拼接的结果调用intern()方法,返回值就在常量池中。
JVM中字符串常量池存放位置说明
jdk1.6:字符串常量池存储在方法区(永久区)
jdk1.7:字符串常量池存储在堆空间
jdk1.8:字符串常量池存储在方法区(元空间)
一道面试题
//基础数据类型传递的是存储的数据,引用数据类型传递的是地址值。
//String的不可变性
public class StringTest1 {
String str = new String("good");
char[] ch = {'t', 'e', 's', 't'};
public void change(String str, char ch[]) {
str = "test ok";
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest1 ex = new StringTest1();
ex.change(ex.str, ex.ch);
System.out.println(ex.str); //good
System.out.println(ex.ch); //best
}
}
String的常用方法1
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方法类似,忽略大小写
String concat(String str):将指定字符串连接到此字符串的结尾,等价于使用"+"
int compareTo(String anotherString):比较两个字符串的大小
String substring(int beginIndex):返回一个新字符串,它是此字符串从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex):返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
public class StringMethod {
@Test
public void test1() {
String s1 = "HelloWorld";
System.out.println(s1.length()); //10
System.out.println(s1.charAt(0)); //H
System.out.println(s1.charAt(9)); //d
//System.out.println(s1.charAt(10)); StringIndexOutOfBoundsException 超出字符串长度
System.out.println(s1.isEmpty()); //false
String s2 = s1.toLowerCase();
String s3 = s1.toUpperCase();
System.out.println(s1); //HelloWorld s1的不可变性,仍然为原来的字符串
System.out.println(s2); //helloworld
System.out.println(s3); //HELLOWORLD
String s4 = " he llo world ";
String s5 = s4.trim();
System.out.println("-----" + s4 + "-----"); //----- he llo world -----
System.out.println("-----" + s5 + "-----"); //-----he llo world----- 去除首尾空格
String s6 = "HelloWorld";
String s7 = "helloworld";
System.out.println(s6.equals(s7)); //false
System.out.println(s6.equalsIgnoreCase(s7)); //true
String s8 = s6.concat("!");
System.out.println(s8); //HelloWorld!
String s9 = "abc";
String s10 = new String("abe");
System.out.println(s9.compareTo(s10)); //-2 从第一个字符开始逐个比较,直到找出第一个不同的字符
//将两个字符相减,即c的ASCII码为99,e为101,99-101=-2,则输出-2
//即结果为正,当前字符串大;结果为负,当前字符串小;结果为0,两个字符串相等。可用于字符串排序。
String s11 = "北京欢迎你";
String s12 = s11.substring(2);
String s13 = s11.substring(2, 4);
System.out.println(s11); //北京欢迎你
System.out.println(s12); //欢迎你
System.out.println(s13); //欢迎
}
}
String的常用方法2
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
public class StringMethod02 {
@Test
public void test2() {
String str1 = "helloworld";
boolean b1 = str1.endsWith("rld");
boolean b2 = str1.startsWith("He");
boolean b3 = str1.startsWith("wo", 5);
System.out.println(b1); //true
System.out.println(b2); //false 区分大小写
System.out.println(b3); //true
String str2 = "wor";
System.out.println(str1.contains(str2)); //true
System.out.println(str1.indexOf("ll")); //2
System.out.println(str1.indexOf("lo", 5)); //-1
String str3 = "hellorworld";
System.out.println(str3.lastIndexOf("or")); //7
System.out.println(str3.lastIndexOf("or", 6)); //4
}
}
String的常用方法3
替换:
String replace(char oldChar, char newChar):返回一个新的字符串,它是通过用newChar替换此字符串中出现的所有oldChar得到的。
String replace(CharSequence target, CharSequence replacement):使用指定字符串替换此字符串中所有匹配指定字符串的子字符串。
String replaceAll(String regex, String replacement):替换此字符串中所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement);替换此字符串中第一个匹配给定的正则表达式的子字符串。
匹配:
boolean matches(String regex):判断此字符串是否匹配给定的正则表达式。
切片:
String[] split(String regex):根据匹配给定的正则表达式拆分此字符串。
String[] split(String regex, int limit):根据匹配给定的正则表达式拆分此字符串,最多不超过limit个;如果超过了,剩下的全部都放到最后一个元素中。
public class StringMethod03 {
@Test
public void test3() {
String str1 = "北京欢迎你, 北京";
String str2 = str1.replace('北', '南');
String str3 = str1.replace("北京", "上海");
System.out.println(str2); //南京欢迎你, 南京
System.out.println(str3); //上海欢迎你, 上海
String str4 = "12hello34world5java7891mysql456";
//将出现一个或多个数字(正则表达式)的位置替换为逗号
String str5 = str4.replaceAll("\\d+", ",");
System.out.println(str5); //,hello,world,java,mysql,
//如果开头有逗号或者结尾有逗号(正则表达式),就把逗号替换为空
String str6 = str5.replaceAll("^,|,$", "");
System.out.println(str6); //hello,world,java,mysql
String str7 = "hello12world99!";
String str8 = str7.replaceFirst("\\d+", ",");
System.out.println(str8); //hello,world99!
String str9 = "12345";
//判断字符串中是否全部由数字组成,即是否由一个或多个数字组成
boolean matches = str9.matches("\\d+");
System.out.println(matches); //true
String tel = "0571-4534289";
//判断是否是杭州的固定电话号码,即判断是否由0571-加上7或8个数字组成
boolean result = tel.matches("0571-\\d{7,8}");
System.out.println(result); //true
String str10 = "hello|world|java";
String[] str11 = str10.split("\\|");
System.out.println(Arrays.toString(str11)); //[hello, world, java]
//即将原字符串拆分为hello、world和java三个字符串,并存放到一个数组中。
String str12 = "hello|world|java|mysql|hadoop";
String[] str13 = str12.split("\\|", 3);
System.out.println(Arrays.toString(str13)); //[hello, world, java|mysql|hadoop]
}
}
String与基本数据类型、包装类之间的转换
String --> 基本数据类型、包装类:调用包装类的静态方法 parseXxx(str)
基本数据类型、包装类 --> String:调用String重载的valueOf()方法
public class StringChange {
@Test
public void test1() {
String str1 = "123";
int num = Integer.parseInt((str1));
System.out.println(num); //123 int类型
String str2 = String.valueOf(num);
System.out.println(str2); //123 String类型
String str3 = num + "";
System.out.println(str3); //123 String类型
}
}
String与char[]之间的转换
String --> char[]:调用String的toCharArray()方法
char[] --> String:调用String的构造器
public class StringChangeChar {
@Test
public void test2() {
String str1 = "abc123";
char[] charArray = str1.toCharArray();
System.out.println(Arrays.toString(charArray)); //[a, b, c, 1, 2, 3]
char[] arr = new char[] {'h', 'e', 'l', 'l', 'o'};
String str2 = new String(arr);
System.out.println(str2); //hello
}
}
练习:将"abc123"转换为"a21cb3"
public static void main(String[] args) {
String str = "abc123";
char[] arr = str.toCharArray();
char a;
for (int i= arr.length-2, j = 1; i>(arr.length/2)-1; i--, j++) {
a = arr[j];
arr[j] = arr[i];
arr[i] = a;
}
String str1 = new String(arr);
System.out.println(str1); //a21cb3
}
String与byte[]之间的转换
(编码)String --> byte[]:调用String的getBytes()方法
(解码)byte[] --> String:调用String的构造器
编码:字符串 --> 字节 (看得懂的 --> 看不懂的二进制数据)
解码:字节 --> 字符串 编码的逆过程 (看不懂的二进制数据 --> 看得懂的)
说明:在解码时,要求解码使用的字符集必须与编码时使用的字符集一致,否则会出现乱码
public class StringChangeByte {
@Test
public void test3() throws UnsupportedEncodingException {
String str1 = "abc123中国";
byte[] bytes = str1.getBytes(); //使用默认的字符集进行转换,当前设定为utf-8
System.out.println(Arrays.toString(bytes)); //[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]
//utf-8中一个汉字占3个字节
byte[] gbks = str1.getBytes("gbk"); //使用指定的字符集进行编码 gbk
System.out.println(Arrays.toString(gbks)); //[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]
//gbk中一个汉字占2个字节
String str2 = new String(bytes); //使用默认的字符集进行解码,当前设定为utf-8
System.out.println(str2); //abc123中国
String str3 = new String(gbks);
System.out.println(str3); //abc123�й�
//出现乱码的原因:编码集和解码集不一致!
String str4 = new String(gbks, "gbk"); //使用gbk字符集进行解码
System.out.println(str4); //abc123中国 编码集和解码集一致,成功解码
}
}