目录
一:常用方法
1.1字符串构造
1.2String对象的比较
1. ==比较是否引用同一个对象
2. boolean equals(Object anObject) 方法:按照字典序比较
3.int compareTo(String s) 方法: 按照字典序进行比较。
4.int compareToIgnoreCase(String str) 方法
1.3字符串查找
1.4转化
1. 数值和字符串转化
2.大小写转换
3.字符串转数组
4.格式化
1.5字符串替换
1.6字符串拆分
1.7字符串截取
二:字符串常量池
2.1什么是字符串常量池?
2.2画图解释
2.2.1直接被双引号括起来的字符串
2.2.2new创建的字符串
2.3intern方法
三:StringBuilder和StringBuffer
一:常用方法
1.1字符串构造
我仅介绍最常用的三种构造方法。
public class TestDemo {
public static void main(String[] args) {
// 1.使用常量串构造
String s1 = "helloworld";
System.out.println(s1);
// 2.直接newString对象
String s2 = new String("helloworld");
System.out.println(s2);
// 3.使用字符数组进行构造
char[] array = {'h','e','l','l','o','w','o','r','l','d'};
String s3 = new String(array);
System.out.println(s3);
}
}
运行结果如下:
1.2String对象的比较
1. ==比较是否引用同一个对象
注意:对于内置类型,==比较的是变量中的值;对于引用类型==比较的是引用中的地址。
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量,==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量,==比较两个引用变量引用的是否为同一个对象
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
}
}
运行结果如下:
2. boolean equals(Object anObject) 方法:按照字典序比较
字典序(dictionary order),又称字母序(alphabetical order),原意是表示英文单词在字典中的先后顺序,在计算机领域中扩展成两个任意字符串的大小关系。
字典序:字符大小的顺序。String类重写了父类Object中equals方法。
public class TestDemo {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
// s1、s2、s3引用的是三个不同对象,因此==比较结果全部为false
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false
// equals比较:String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象,但是两个对象中放置的内容相同,因此输出true
// s1与s3引用的不是同一个对象,而且两个对象中内容也不同,因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}
}
运行结果如下:
内容是否相同,返回值为boolean类型。
3.int compareTo(String s) 方法: 按照字典序进行比较。
public class TestDemo {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdefg");
System.out.println(s1.compareTo(s2)); // 第1个字符完全相同,输出长度差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前4个字符完全相同,输出长度差值-4
}
}
运行结果如下:
总结:S1.compareTo(S2),就是比较字符串S1与S2的内容是否相同,返回值为int类型,返回值等于0,说明S1和S2内容相同;输出负数,说明S1字典序小于S2;输出正数,说明S1字典序大于S2。
4.int compareToIgnoreCase(String str) 方法
与compareTo方式相同,但是忽略大小写比较。
public class TestDemo {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同,输出长度差值 -3
}
}
运行结果如下:
1.3字符串查找
String提供的常用查找方法有:
public class TestDemo {
public static void main(String[] args) {
String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3));
}
}
运行结果如下:
1.4转化
1. 数值和字符串转化
public class TestDemo {
public static void main(String[] args) {
// 数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
System.out.println(s1+1);
System.out.println(s2+1);
System.out.println(s3+1);
System.out.println("=================================");
// 字符串转数字
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1+1);
System.out.println(data2+1);
}
}
运行结果如下:
2.大小写转换
public class TestDemo {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
// 小写转大写
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());
}
}
运行结果如下:
3.字符串转数组
public class TestDemo {
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。字符串转数组——char[ ] ch = s.toCharArray();
2. 数组转字符串 String s2 = new String(ch);
4.格式化
public class TestDemo {
public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);
}
}
运行结果如下:
1.5字符串替换
public class TestDemo {
public static void main(String[] args) {
String str = "helloworld";
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));
}
}
运行结果如下:
1.6字符串拆分
public class TestDemo {
public static void main(String[] args) {
String str = "hello world hello bai" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
System.out.println(s);
}
System.out.println("====================");
String str1 = "hello world hello bai" ;
String[] result1 = str.split(" ",2) ;//只拆成2部分
for(String s: result1) {
System.out.println(s);
}
}
}
运行结果如下:
特殊情况:拆分时含有特殊字符,需要进行转义,其规则如下:
1. 字符"|","*","+"都得加上转义字符,前面加上"\\" .
2. 而如果是"\" ,那么就得写成"\\\\" .
3. 如果一个字符串中有多个分隔符,可以用"|"作为连字符.
public class TestDemo {
public static void main(String[] args) {
String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}
}
}
运行结果如下:
多次拆分:很简单,对拆分的结果进行再拆分即可。
public class TestDemo {
public static void main(String[] args) {
String str = "name=zhangsan&age=18";
String[] result = str.split("&");
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}
System.out.println("===============");
for (int i = 0; i < result.length; i++) {
String[] temp = result[i].split("=");
System.out.println(temp[0] + " ## " + temp[1]);
}
}
}
运行结果如下:
1.7字符串截取
public class TestDemo {
public static void main(String[] args) {
String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));
}
}
运行结果如下:
注意:
1. 索引从0开始;
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标。
二:字符串常量池
2.1什么是字符串常量池?
在Java程序中,类似于:1, 2, 3,3.14,“hello”等字面类型的常量经常频繁使用,为了使程序的运行速度更快、更节省内存,Java为8种基本数据类型和String类都提供了常量池。
为了节省存储空间以及程序的运行效率,Java中引入了:
1. class文件常量池:每个.java源文件编译后生成的.class文件中会保存当前类中的字面常量以及符号信息;
2. 运行时常量池:在.class文件被加载时,.class文件中的常量池被加载到内存中称为运行时常量池,运行时常量池每个类都有一份;
3. 字符串常量池。注意:
1. 在JVM中字符串常量池只有一份,是全局共享的;
2. 刚开始字符串常量池是空的,随着程序不断运行,字符串常量池中元素会越来越多;
3. 当类加载时,字节码文件中的常量池也被加载到JVM中,称为运行时常量池,同时会将其中的字符串常量保存在字符串常量池中;
4. 字符串常量池中的内容:一部分来自运行时常量池,一部分来自程序动态添加。
2.2画图解释
2.2.1直接被双引号括起来的字符串
2.2.2new创建的字符串
总结:只要是new的对象,都是唯一的。
2.3intern方法
intern是一个native方法(Native方法指:底层使用C++实现的,看不到其实现的源代码),该方法的作用是手动将创建的String对象添加到常量池中。
public class TestDemo {
public static void main(String[] args) {
char[] ch = new char[]{'a', 'b', 'c'};
String s1 = new String(ch);
s1.intern();// s1对象被添加到常量池中
String s2 = "abc"; // "abc" 在常量池中存在了,s2创建时直接用常量池中"abc"的引用
System.out.println(s1 == s2);
}
}
运行结果如下:
总结:
1.S.intern()方法,将创建的String对象S添加到常量池中。
2.只有常量池中没有时,才会入池。
注意:因为String内部的value被final修饰,所以字符串不能被修改.所有对字符串的操作,本质上都是创建了新的字符串。
三:StringBuilder和StringBuffer
在对String类进行修改时,效率是非常慢的,因此:尽量避免对String的直接需要,如果要修改建议尽量使用StringBuffer或者StringBuilder。
说明:所有对String适用的方法,也适用于StringBuilder和StringBuffer。
具体实例如下:
public class TestDemo1 {
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder("hello");
StringBuffer sb2 = new StringBuffer("hello");
sb1.append("world");
sb2.append("world");
System.out.println(sb1);
System.out.println(sb2);
sb1.reverse();
sb2.reverse();
System.out.println(sb1);
System.out.println(sb2);
}
}
运行结果如下:
区别:
1.在执行速度方面的比较:StringBuilder> StringBuffer;
2.StringBuffer与StringBuilder,他们是字符串变量,是可改变的对象,每当我们用它们对字符串做操作时,实际上是在一个对象上操作的,不像String一样创建一些对象进行操作,所以速度就快了;
3.StringBuilder:线程非安全的 StringBuffer:线程安全的建议:
1.如果要操作少量的数据用 String;
2.单线程操作字符串缓冲区下操作大量数据 StringBuilder;
3.多线程操作字符串缓冲区下操作大量数据 StringBuffer。
本课内容完!