从零学Java - String类
Java String类
文章目录
- Java String类
-
- 1 String
-
- 1.1 常用两种创建方式
- 1.2 比较两种创建方式
- 1.3 字符串不可变性
- 1.4 面试题
- 2 常用方法
-
- 2.1 练习
- 3 可变字符串
-
- 3.1 常用方法
- 3.2 验证StringBuilder的高效性
- 3.3 练习
- 3.4 面试题:
- 4 正则表达式
-
- 4.1 元字符
- 4.2 其他字符
-
- 4.2.1 预定义字符
- 4.2.2 边界匹配
- 4.2.3 数量
- 4.3 正则表达式的应用
-
- 4.3.1 匹配
- 4.3.2 拆分
- 4.3.3 获取
- 4.3.4 替换
1 String
Java程序中的所有字符串文本（例如“abc”）都是此类的实例。
字符串字面值是常量，具有不可变性，创建之后不可改变。
1.1 常用两种创建方式
//1 直接使用字符串字面值(双引号包裹)赋值
//数据存储在常量池中
String s1 = "hello";
//2 使用构造方法赋值
//数据存储在堆中
String s2 = new String("hello");
1.2 比较两种创建方式
//常量池中数据不会重复。
String s3 = "hello";
System.out.println(s1 == s2); //比较地址
System.out.printlin(s1.equals(s2)); //比较内容
System.out.println(s1 == s3); //比较地址
res:
false
true
true
字符串字面值保存在常量池中，JDK1.7之前常量池存在方法区中，JDK1.7（包括1.7）之后移入堆中；常量池中数据不会重复。
1.3 字符串不可变性
//在常量池种重新开辟空间
//字符串具有不可变性:重新赋值时,不会改变原来的数据,而是重新开辟空间
s3 = "zhangsan"
System.out.println(s3);
System.out.println(s1);
res:
zhangsan
hello
内存存储方式:
1.4 面试题
eg:
String name = new String(“lisi”) // 该语句在内存中创建了几个对象
res:
两个, 常量池一个, 堆中一个
2 常用方法
eg:
String s1 = "Java是世界上最好的语言,Java第一,Java真牛";
-
public char charAt(int index)：根据下标获取字符。
//1 charAt(); 返回指定位置上的字符 char first = s1.charAt(0); char last = s1.charAt(s1.length() - 1); System.out.println(first); System.out.println(last); -
public boolean contains(String str)：判断当前字符串中是否包含str。
//2 contains(String str)：判断当前字符串中是否包含str。 boolean b = s1.contains("java"); System.out.println(b); -
public char[] toCharArray()：将字符串转换成字符数组。
//3 toCharArray(); 返回字符串的字符数组 char[] charArray = s1.toCharArray(); System.out.println(charArray.length); -
public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。
//4 indexOf(); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。 int i = s1.indexOf("Java"); int i1 = s1.indexOf("Java",4); System.out.println(i); System.out.println(i1);//需求：输出字符串中出现Java的位置 int p = 0; while ((p=s1.indexOf("Java",p))!=-1) { System.out.println("位置："+p); p+=4; } -
public int length()：返回字符串的长度。
//5 length(); 返回字符串的长度 System.out.println(s1.length()); -
public String trim()：去掉字符串前后的空格。
//6 trim()：去掉字符串前后的空格。 String s1 = " Java是世界上最好的语言, Java第一, Java真牛 "; System.out.println(s1.trim()); -
public String toUpperCase()：将小写转成大写。
//7 toUpperCase()：将小写转成大写。toLowerCase()：将大写转成小写。 String s2 = "Hello"; System.out.println(s2.toUpperCase()); System.out.println(s2.toLowerCase()); -
public boolean endsWith(String str)：判断字符串是否以str结尾。
/* 8 endsWith(String str)：判断字符串是否以str结尾 startsWith(String str)：判断字符串是否以str开头 */ String s3 = "hello.java"; System.out.println(s3.endsWith("java")); System.out.println(s3.startsWith("hello")); -
public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
//9 replace(char oldChar,char newChar)：将旧字符串替换成新字符串 System.out.println(s1.replace("Java", "java")); -
public String[] split(String str)：根据str做拆分。
//10 split(String str)：根据str做拆分 //以逗号或空格拆分, + 表示前面的逗号或空格可以出行1次或多次 String[] strings = s1.split("[, ]+"); System.out.println(strings.length); for (String s : strings) { System.out.println(s); } -
public String substring(int beginIndex,int endIndex)：在字符串中截取出一个子字符串
//11 substring(int beginIndex,int endIndex)：在字符串中截取出一个子字符串 String s4 = "Java是世界上最好的语言,Java第一,Java真牛"; String substring = s4.substring(0, 4); String substring1 = s4.substring(s4.length() - 6); System.out.println(substring); System.out.println(substring1); -
public int compareTo(String anotherString) :比较两个字符串的大小(字符表位置,或长度)
//12 compareTo() 比较两个字符串的大小(字符表位置,或长度) String s5 = "abc"; //97 String s6 = "xyz"; //120 System.out.println(s5.compareTo(s6)); //如果一个字符串是另一个字符串的前缀, 比较长度 String s7 = "abcxyz"; System.out.println(s5.compareTo(s7)); -
public boolean equals(Object anObject): 比较字符串是否相同
System.out.println(s5.equals(s6)); -
public native String intern() :
判断常量池是否包含此数据 如果有, 直接返回常量池中的地址 如果没有, 复制一份地址放入常量池, 然后返回这个地址
2.1 练习
eg:
需求：已知String str = "this is a text";
将str中的单词单独获取出来
将str中的text替换为practice
在text前面插入一个easy
将每个单词的首字母改为大写
res:
/**
* @author 胡昊龙
* @version 1.0
* @description: TODO 需求：已知String str = "this is a text";
* 将str中的单词单独获取出来
* 将str中的text替换为practice
* 在text前面插入一个easy
* 将每个单词的首字母改为大写
* @date 2024/1/8 11:24
*/
public class TestString04 {
public static void main(String[] args) {
String str = "this is a text";
//将str中的单词单独获取出来
String[] split = str.split(" ");
for (String s : split) {
System.out.println(s);
}
//将str中的text替换为practice
String replace = str.replace("text", "practice");
System.out.println(replace);
//在text前面插入一个easy
String replace1 = str.replace("text", "easy text");
System.out.println(replace1);
//将每个单词的首字母改为大写
for (String s : split) {
/*
方法一:
String first = s.substring(0, 1);
first = first.toUpperCase();
*/
//方法二
char first = s.charAt(0);
first = Character.toUpperCase(first);
//拼接
s=first+s.substring(1);
System.out.println(s);
}
}
}
3 可变字符串
概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。
优点：执行效率高于String。
StringBuilder：JDK5.0提供，运行效率快、线程不安全。(单)
StringBuffer：JDK1.0提供，运行效率慢、线程安全。(多)
3.1 常用方法
创建可变字符串对象
StringBuilder builder = new StringBuilder();
-
append(String str)
-
//1 append(); 追加内容 builder.append("java第一"); builder.append("java真牛"); System.out.println(builder); -
insert(String str)
-
//2 insert(); 插入内容 builder.insert(0,"java是世界上最好的语言"); System.out.println(builder); -
replace()
-
//3 replace(); 替换内容 builder.replace(0,4,"JAVA"); System.out.println(builder); -
reverse()
-
//4 reverse(); 反转内容 builder.reverse(); System.out.println(builder); -
delete()
-
//5 delete(); 删除内容 builder.delete(0,4); builder.delete(0, builder.length());// 清空内容
3.2 验证StringBuilder的高效性
eg:
用两种方式运行同一种操作, 比较所消耗时间
/**
* @author 胡昊龙
* @version 1.0
* @description: TODO
* @date 2024/1/8 14:46
*/
public class StringB2 {
public static void main(String[] args) {
//验证StringBuilder的效率
String s = "";
long start = System.currentTimeMillis();
for (int i = 0; i < 50000; i++) {
s+=i;
}
long end = System.currentTimeMillis();
System.out.println("用时: "+(end-start));
System.out.println("=======================================");
StringBuilder builder = new StringBuilder();
long start1 = System.currentTimeMillis();
for (int i = 0; i < 50000; i++) {
builder.append(i);
}
long end1 = System.currentTimeMillis();
System.out.println("用时: "+(end1-start1));
}
}
res:
用时: 6438
==============
用时: 2
3.3 练习
把“18987425.99”转成“18,987,425.99”
public class StringB3 {
public static void main(String[] args) {
String s = "18987425.99";
StringBuilder num = new StringBuilder(s);
int pos = num.indexOf(".");
for (int i = pos-3; i >0 ; i-=3) {
num.insert(i,",");
}
System.out.println(num);
}
}
3.4 面试题:
请说出代码的运行结果？
第一题图解:
第二题图解:
如果将图2中的s4和s5换一下位置, 运行结果是?
4 正则表达式
概念: 正则表达式就是一个验证字符串格式是否满足要求的字符串，使用一个字符串匹配一组字符串,这个字符串就是正则表达式。
正则表达式的用途
- 匹配 拆分 获取 替换
4.1 元字符
概念: 正则表达式中通常包含一些具有特殊含义的字符。
| 字符 | 解释 |
|---|---|
| a | 匹配字符****a |
| [abc] | 匹配 a或b或c |
| [^abc] | 任何字符，除了 a、b 或 c（否定） |
| [a-zA-Z] | a 到 z 或 A 到 Z，两头的字母包括在内（范围） |
| [a-d[m-p]] | a 到 d 或 m 到 p：[a-dm-p]（并集） |
| [a-z&&[def]] | d、e 或 f（交集） |
| [a-z&&[ ^bc]] | a 到 z，除了 b 和 c：[ad-z]（减去） |
| [a-z&&[ ^m-p]] | a 到 z，而非 m 到 p：[a-lq-z]（减去） |
4.2 其他字符
4.2.1 预定义字符
| 字符 | 解释 |
|---|---|
| . | 任意字符（与行结束符可能匹配也可能不匹配） |
| \d | 数字：[0-9] |
| \w | 单****个字符：[a-zA-Z_0-9] |
4.2.2 边界匹配
| 字符 | 解释 |
|---|---|
| ^ | 表示行开始 |
| $ | 表示行结束 |
4.2.3 数量
| 字符 | 解释 |
|---|---|
| X? | 一次或0次 |
| X* | 0次或多次(包括1次) |
| X+ | 一次或多次 |
| X{n} | 恰好n次 |
| X{n, } | 至少n次 |
| X{n,m} | 至少n次，不超过m次 |
4.3 正则表达式的应用
正则表达式大全
4.3.1 匹配
//1 匹配
//手机号
String reg = "^1[35789][0-9]{9}$";
String phone = "11632145345";
System.out.println(phone.matches(reg));
//创建模式对象
Pattern p = Pattern.compile("^1[35789][0-9]{9}$");
//获取匹配器
Matcher m = p.matcher("16632145345");
//调用匹配器的matcher()
boolean b = m.matches();
System.out.println(b);
//qq邮箱
String reg2 = "^[1-9][0-9]{4,9}@[qQ]{2}.[cC][oO][Mm]$";
String qq = "[email protected]";
System.out.println(qq.matches(reg2));
4.3.2 拆分
//2 拆分
String s = "this is a text";
/*
一个符号用双引号包裹即可
多个符号先用双引号再用中括号包裹
+ 表示前面的符号可以出行1次或多次
*/
String[] arr = s.split("[ .]+");
System.out.println(arr.length);
for (String string : arr) {
System.out.println(string);
}
4.3.3 获取
//3 获取
String s1 = "Java是世界上最好的语言,java第一,Java真牛";
//需求: 获取字符串中的 Java 字符 (不区分大小写)
Pattern p1 = Pattern.compile("[jJ]ava");
Matcher m1 = p1.matcher(s1);
//find(); 找到则返回true, 没有找到则返回false
while (m1.find()) {
//group(); 返回找到的数据
System.out.println(m1.group());
}
4.3.4 替换
//4 替换
String s2 = s1.replaceAll("[jJ]ava", "JAVA");
System.out.println(s2);
Pattern p3 = Pattern.compile("[jJ]AVA");
Matcher m3 = p3.matcher(s2);
String s3 = m3.replaceAll("Python");
System.out.println(s3);