常用类之String类
1.关于JDK内置的一个类：String
- String表示字符串类型，属于引用数据类型，不属于基本数据类型
- 在java中随便使用双引号括起来的都是String对象
- java中规定，双引号括起来的字符串是不可变的
- 在JDK当中双引号括起来的字符串都是直接存储在方法区的字符串常量池当中的
由于字符串在实际开发中使用太频繁，为了执行效率，所以把字符串放到了方法区的字符串常量池当中。
2.String字符串的存储原理
package se2.String;
public class StringTest01 {
public static void main(String[] args) {
//这两行代码表示底层创建了3个字符串对象，都在字符串常量池当中
//直接指向字符串常量池
String s1 = "abcdef";
String s2 = "abcdef" + "xy";
//分析：这是使用new方式创建的字符串对象，这个代码中的“xy”是从哪来的？
//凡是双引号括起来的都在字符串常量池中有一份
//new对象的时候一定是在堆内存当中开辟空间
//在堆内存中多了个对象再指向字符串常量池
String s3 = new String("xy");
//注意
//i变量保存的是100这个值
int i = 100;
//s变量保存的不是“abc”，是字符串对象的内存地址
String s = "abc";
}
}
package se2.String;
public class StringTest02 {
public static void main(String[] args) {
//“阿波”是存储在方法区的字符串常量池当中
//所以这个“阿波”不会新建（因为这个对象已经存在了！）
String s1 = "阿波";
String s2 = "阿波";
//分析结果是true还是false
//==比较的是变量中保存的内存地址
System.out.println(s1 == s2);//true
String x = new String("xyz");
String y = new String("xyz");
//分析结果是true还是false
//注意：垃圾回收器是不会释放常量的
System.out.println(x == y);//false
//通过这个案例，我们知道，字符串对象之间的比较不能使用“==”
//不保险，应该调用String类的equals方法
//String类已经重写了equals方法,以下的equals方法调用的是String重写之后的equals方法
System.out.println(x.equals(y));//true
String k = new String("testString");
//为什么“testString”这个字符串可以后面加"."？
//因为“testString”是一个String字符串对象，只要是对象都能调用方法
System.out.println("testString".equals(k));//建议使用这种方式，可以避免空指针异常
System.out.println(k.equals("testString"));//若k为null，会空指针异常，不建议这样写
}
}
package se2.String;
//面试题
//分析以下程序一共创建了几个对象
public class StringTest03 {
public static void main(String[] args) {
/*
一共3个对象：
方法区字符串常量池中有1个：“hello”
堆内存当中有两个String对象
*/
String s1 = new String("hello");
String s2 = new String("hello");
}
}
3.String类的常用构造方法
package se2.String;
/**
* 关于String类中的构造方法
* 第一个：String s = new String("");
* 第二个:String s = "";(最常用)
* 第三个:String s = new String(char数组);
* 第四个:String s = new String(char数组，起始下标，长度);
* 第五个:String s = new String(byte数组);
* 第六个:String s = new String(byte数组，起始下标，长度);
*/
public class StringTest04 {
public static void main(String[] args) {
//创建字符串对象最常用的一种方式
String s1 = "hello world!";
System.out.println(s1);//hello world!
System.out.println(s1.toString());//hello world!
//这里只掌握常用的构造方法
byte[] bytes = {97,98,99};//97是a，98是b，99是c
String s2 = new String(bytes);
//输出一个引用的时候，会自动调用toString方法，默认Object的话，会自动输出对象的内存地址
System.out.println(s2);//abc
System.out.println(s2.toString());//abc
//通过输出结果我们得出一个结论：String类已经重写了toString方法
//输出字符串对象的话，输出的不是对象的内存地址，而是字符串本身
//String（字节数组，数组元素下标的起始位置，长度）
//将byte数组中的一部分转换成字符串
String s3 = new String(bytes,1,2);
System.out.println(s3);//bc
//将char数组全部转换成字符串
char[] chars = {'最','爱','琴','女','E'};
String s4 = new String(chars);
System.out.println(s4);//最爱琴女E
//将char数组的一部分转换成字符串
String s5 = new String(chars,2,2);
System.out.println(s5);//琴女
String s6 = new String("哈哈");
System.out.println(s6);//哈哈
}
}
4.String类常用的21个方法
package se2.String;
public class StringTest05 {
public static void main(String[] args) {
//String类当中常用的方法
//1（掌握）.char charAt(int index)
char c = "琴瑟仙女娑娜".charAt(0);//""是一个字符串对象，只要是对象就能"点"
System.out.println(c);//琴
//2（了解）.compareTo(String anotherString)（比较字符串大小关系）
//字符串之间比较大小不能直接使用> < ，需要使用compareTo方法
int result = "abc".compareTo("abc");
System.out.println(result);//0（等于0） 前后一致 10-10 = 0
int result2 = "abcd".compareTo("abce");
System.out.println(result2);//-1（小于0） 前小后大 8-9 = -1
int result3 = "abce".compareTo("abcd");
System.out.println(result3);//1（大于0） 前大后小 9-8 = 1
//拿着字符串第一个字母和后面字符串的第一个字母比较，能分胜负就不再比较了
System.out.println("xyz".compareTo("yxz"));//-1
//3（掌握）.boolean contains(CharSequence s)
//判断前面的字符串当中是否包含后面的子字符串
System.out.println("琴瑟仙女".contains("琴"));//true
System.out.println("琴瑟仙女".contains("星籁歌姬"));//false
//4（掌握）.boolean endsWith(String suffix)
//判断当前字符串是否以某个字符串结尾
System.out.println("test.txt".endsWith(".java"));//false
System.out.println("test.txt".endsWith(".txt"));//true
System.out.println("卧槽尼玛的".endsWith("尼玛的"));//true
//5（掌握）.boolean equals(Object anObject)
//比较两个字符串必须使用equals方法，不能使用“==”
//equals只能看出是否相等
//compareTo可以看出是否相等，并且同时还可以看出谁大谁小
System.out.println("abc".equals("abc"));//true
//6（掌握）.boolean equalsIgnoreCase(String anotherString)
//判断两个字符串是否相等，并且同时忽略大小写
System.out.println("ABc".equalsIgnoreCase("abC"));//true
//7（掌握）.byte[] getBytes()
//将字符串对象转换成字节数组
byte[] bytes = "abcdef".getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
System.out.println();
//输出结果：97 98 99 100 101 102
//8（掌握）.int indexOf(String str)
//判断某个子字符串在当前字符串中第一次出现处的索引（下标）
System.out.println("cc++javapythonc#".indexOf("java"));//4
//9（掌握）.boolean isEmpty()
//判断某个字符串是否为空字符串
String s = "";
System.out.println(s.isEmpty());//true
String s2 = "a";
System.out.println(s2.isEmpty());//false
//注意：变量为null时，会出现空指针异常
//10（掌握）.int length()
System.out.println("qwe".length());//3
//面试题：判断数组长度和判断字符串长度不一样
//判断数组长度是length属性，判断字符串长度是length()方法
//11（掌握）.int lastIndexOf(String str)
//判断某个字符串在当前字符串中最后一次出现的索引（下标）
System.out.println("abcdefggfedcba".lastIndexOf("c"));//11
//12（掌握）.String replace(CharSequence target,CharSequence replacement)
//String的父类接口就是：CharSequence
//替换
String newString = "琴女26D".replace("2","3");
System.out.println(newString);//琴女36D
String newString2 = "阿波&密码=123&年龄=20".replace("=",":");
System.out.println(newString2);//将“=”替换成“：”
//13（掌握）.String[] split(String regex)
//拆分字符串
String[] ymd = "1999-2-25".split("-");//"1999-2-25"以“-”分隔符进行拆分
for (int i = 0; i < ymd.length; i++) {
System.out.println(ymd[i]);
}
/* 运行结果：
1999
2
25
*/
String param = "name=阿波&password=123&age=20";
String[] params = param.split("&");
for (int i = 0; i < params.length; i++) {
System.out.println(params[i]);
}
/* 运行结果：
name=阿波
password=123
age=20
*/
//14（掌握）.boolean stacksWith(String prefix)
//判断某个字符串是否以某个字符串开始
System.out.println("艾欧尼亚，昂扬不灭！".startsWith("艾"));//true
System.out.println("艾欧尼亚，昂扬不灭！".startsWith("爱"));//false
//15（掌握）.String substring(int beginIndex)
//截取字符串
System.out.println("http://www.baidu.com".substring(7));//www.baidu.com
//16（掌握）.String substring(int beginIndex,int endIndex)
//beginIndex起始位置（包括）
//endIndex结束位置（不包括）
System.out.println("http://www.baidu.com".substring(7,10));//www
//左闭右开，包含7但不包含10
//17（掌握）.char[] toCharArray()
//将字符串转换成char数组
char[] chars = "我是中国人".toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
/*运行结果：
我
是
中
国
人
*/
//18（掌握）.String toLowerCase()
//转换为小写
System.out.println("ABCDefg".toLowerCase());//abcdefg
//19（掌握）.String toUpperCase()
//转换为大写
System.out.println("ABCDefg".toUpperCase());//ABCDEFG
//20（掌握）.String trim();
//去除字符串前后空白
System.out.println(" 琴女 36D ".trim());//琴女 36D
//注意：只能去除前后，中间不行
//21（掌握）.String中只有一个方法是静态的，不需要new对象
//valueOf
//作用：将非字符串转换成字符串
String str1 = String.valueOf(100);
System.out.println(str1);//100
String str2 = String.valueOf(true);
System.out.println(str2);//true
String str3 = String.valueOf(3.14);
System.out.println(str3);//3.14
//这个静态的valueOf方法，参数是一个对象的时候，会自动调用该对象的toString()方法吗？
String str4 = String.valueOf(new Customer());
System.out.println(str4);
//Customer没有重写toString方法输出：se2.String.Customer@154617c
//Customer重写toString方法输出：最爱琴女E！！！
//关于System.out.println();
//System.out.println();通过看源代码得知这个方法底层调用了valueOf方法
//本质上System.out.println();这个方法在输出任何数据的时候会先转换成字符串，再输出
}
}
class Customer{
//重写toString方法
@Override
public String toString() {
return "最爱琴女E！！！";
}
}