[TOC]
>[danger] ##### 字符串的比较
|方法声明 |功能介绍|
| --- | --- |
| boolean equals(Object anObject) | 两个字符串内容是否相等返回布尔|
|boolean equalsIgnoreCase(String anotherString) |忽略大消息判断两个字符串的内容是否相等|
|双等 |内存地址是否相等|
~~~
public class StringTest {
public static void main(String[] args) {
String str = "abc"; // 同一个字符串常量池
String str1 = "abc"; // 同一个字符串常量池
String str2 = new String("abc"); // 构造参数是同一个字符串常量池
String str3 = "ABC";
// 内存比较
System.out.println(str == str1); // true
System.out.println(str == str2);// false
// 具体内容比较
System.out.println(str.equals(str2)); // true
// 忽略大小写比较
System.out.println(str.equalsIgnoreCase(str3));// true
}
}
~~~
>[danger] ##### 数组和字符转换
|方法声明 |功能介绍|
| --- | --- |
|String toString() |返回字符串本身|
|byte[] getBytes() |将当前字符串内容转换为byte数组并返回|
|char[] toCharArray() |用于将当前字符串内容转换为char数组并返回|
~~~
import java.util.Arrays;
public class TestStr {
public static void main(String[] args) {
String str = new String("你好word");
// 调用toString 方法返回字符串
System.out.println(str.toString());
// 将字符串转换为 字节数组 byte
byte[] bArr = str.getBytes();
System.out.println(Arrays.toString(bArr));
// 打印每个字节
for (byte s : bArr) {
System.out.println(s);
}
// 将字节转换会字符串
System.out.println(new String(bArr));
// 将字符串转换为 字符数组 char
char[] cArr = str.toCharArray();
System.out.println(Arrays.toString(cArr));
// 打印每个字符
for (char s : cArr) {
System.out.println(s);
}
// 将字符转换会字符串
System.out.println(new String(cArr));
}
}
~~~
* 打印结果
~~~
你好word
[-60, -29, -70, -61, 119, 111, 114, 100]
-60
-29
-70
-61
119
111
114
100
你好word
[你, 好, w, o, r, d]
你
好
w
o
r
d
好w
o
r
d
你好word
~~~
>[danger] ##### 判断字符长度和是否为空
|方法声明 |功能介绍|
| --- | --- |
|int length()| 返回字符串字符序列的长度|
|boolean isEmpty() |判断字符串是否为空|
~~~
public class TestStr {
public static void main(String[] args) {
String str = "";
System.out.println("当前字符串是否为空" + (str.length() == 0)); // 打印结果：当前字符串是否为空true
System.out.println("当前字符串是否为空" + str.isEmpty()); // 打印结果：当前字符串是否为空true
}
}
~~~
>[danger] ##### 通过位置获取字符
1. 指数范围为**0至length() - 1** 。 序列的第一个char值位于索引0 ，下一个位于索引1 ，依此类推，就像**数组索引一样**
2. **IndexOutOfBoundsException**- 如果 index参数为负数或不小于此字符串的长度
|方法声明 |功能介绍|
| --- | --- |
|char charAt(int index) |方法charAt用于返回字符串**指定位置的字符（char 类型）**。|
~~~
public class TestStr {
public static void main(String[] args) {
String str = "word";
System.out.println(str.charAt(0)); // w
System.out.println(str.charAt(1)); // o
System.out.println(str.charAt(2)); // r
System.out.println(str.charAt(3)); // d
System.out.println(str.charAt(4)); // java.lang.StringIndexOutOfBoundsException: String index out of range: 4
}
}
~~~
>[danger] ##### 字符串大小比较
1. 比较的前后两个字符串的 **对应位置字符 的ASCII码的差值**，两个字符串如果首字符**相同**，则**比较下一个字符**，直到有不同的为止，返回**该不同的字符的ASCII码差值**。如果**两个字符串不一样长**，可以参与比较的字符**又完全一样**，则返回**两个字符串的长度差值**
2. 如果参数字符串**等于**此字符串，**则值0** ; 如果此字符串按字典顺序**小于**字符串参数，则**小于0** ; 如果此字符串按字典顺序**大于**字符串参数，则值**大于0** 。
|方法声明 |功能介绍|
| --- | --- |
|int compareTo(String anotherString) |用于比较调用对象和参数对象的大小关系|
|int compareToIgnoreCase(String str) |不考虑大小写，也就是'a'和'A'是相等的关系|
~~~
public class TestStr {
public static void main(String[] args) {
String str = "abcba";
System.out.println(str.compareTo("acc")); // b 和 c 比较 98 - 99 = -1
System.out.println(str.compareTo("abcbaaA")); // abcba 都一样则长度比较 5-7 = -2
System.out.println(str.compareTo("ABCBA")); // a 和 A 比较 97 - 65 = 32
System.out.println(str.compareTo("abcba")); // 0
// 使用 compareToIgnoreCase 忽略大小写
System.out.println(str.compareToIgnoreCase("ABCBA")); // 0
}
}
~~~
* 打印结果
~~~
-1
-2
32
0
0
~~~
>[danger] ##### 字符串拼接
1. 使用 concat 可以拼接字符串，和加号不同点如下
| **点** | **concat()方法** | **+运算符** |
| --- | --- | --- |
| **定义** | 一种**concat()方法**是组合两个字符串的方法。 | **+运算符**用于连接任意数量的字符串。 |
| **参数数量** | 在**CONCAT()**方法，仅接受字符串的一个参数，然后将其与另一个字符串连接。 | 在**+运算符**接受任意数量的参数并组合所有字符串。 |
| **参数类型** | **CONCAT()**方法仅接受字符串类型的参数。 | **+运算符**接受任何类型的参数并将其转换为字符串类型，然后将它们组合。 |
| **创建新的字符串** | **CONCAT()**将两个字符串连接起来，并仅在字符串长度大于0的情况下返回新的字符串对象，否则返回相同的对象。 | **+运算符**每次与字符串长度无关都创建一个新的字符串对象。 |
| **空指针异常** | 在**CONCAT()**当string与null串联时，此方法引发NullPointer Exception。 | **+运算符**连接字符串，没有任何错误。 |
| **性能** | **concat()方法**比+运算符更好，因为它仅在字符串长度大于零(0)时创建一个新对象，因此它使用较少的内存。 | **+运算符**始终会创建一个新字符串，而与字符串长度无关，因此会占用更多内存。 |
~~~
public class TestStr {
public static void main(String[] args) {
String str = "abcba";
String conStr = str.concat("some");
System.out.println(conStr); // abcbasome
}
}
~~~
>[danger] ##### 转换字符串大小写
|方法声明 |功能介绍|
| --- | --- |
|String toLowerCase() |返回字符串的小写形式|
|String toUpperCase() |返回字符串的大写形式|
~~~
public class TestStr {
public static void main(String[] args) {
String str = "abcba";
// 大写
String upStr = str.toUpperCase();
System.out.println(upStr); // ABCBA
// 小写
String lowStr = str.toLowerCase();
System.out.println(lowStr); // abcba
}
}
~~~
>[danger] ##### 字符串判断包含方法
|方法声明 |功能介绍|
| --- | --- |
| boolean contains(CharSequence s) | 用于判断当前字符串是否包含参数指定的内容String |
| boolean startsWith(String prefix) | 判断字符串是否以参数字符串开头|
| boolean startsWith(String prefix, int toffset) | 从指定位置开始是否以参数字符串开头|
| boolean endsWith(String suffix) | 判断字符串是否以参数字符串结尾|
~~~
public class TestStr {
public static void main(String[] args) {
String str = "abcba";
// 是否包含字符
boolean b1 = str.contains("cba"); // true
System.out.println(b1);
b1 = str.contains("ABC");
System.out.println(b1); // false 区分大小写
// 判断字符串是否以...开头
b1 = str.startsWith("ab");
System.out.println(b1); // true
// 从下标1开始开头是否是bc
b1 = str.startsWith("bc", 1);
System.out.println(b1); // true
// 判断字符串是否以...结尾
b1 = str.endsWith("ba");
System.out.println(b1); // true
}
}
~~~
>[danger] ##### 去掉前后空格
1. `String trim()`，去掉前后空格
~~~
public class TestStr {
public static void main(String[] args) {
String str = " ab cba ";
String trimStr = str.trim();
System.out.println(trimStr); // ab cba
}
}
~~~
>[danger] ##### 字符和字符串的查找（脚标位置）
| 方法声明 | 功能介绍|
| --- | --- |
| int indexOf(int ch) | 用于返回当前字符串中参数ch指定的字符第一次出现的下标|
| int indexOf(int ch, int fromIndex)| 用于从fromIndex位置开始查找ch指定的字符|
| int indexOf(String str) | 在字符串中检索str返回其第一次出现的位置，若找不到返回-1|
| int indexOf(String str, int fromIndex)| 表示从字符串的fromIndex位置开始检索str第一次出现的位置|
| int lastIndexOf(int ch)| 用于返回参数ch指定的字符最后一次出现的下标|
| int lastIndexOf(int ch, in fromIndex)| 用于从fromIndex位置开始查找ch指定字符出现的下标|
| int lastIndexOf(String str) | 返回str指定字符串最后一次出现的下标|
| int lastIndexOf(String str, int fromIndex)| 用于从fromIndex位置开始反向搜索的第一次出现的下标。|
~~~
public class TestStr {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("Good Good Study, Day Day Up!");
// 2.实现字符串中指定字符和字符串的查找功能
int pos = str1.indexOf('g');
System.out.println("pos = " + pos); // -1 代表查找失败
pos = str1.indexOf('G');
System.out.println("pos = " + pos); // 0 该字符第一次出现的索引位置
// 表示从下标0开始查找字符'G'第一次出现的索引位置，包含0
pos = str1.indexOf('G', 0);
System.out.println("pos = " + pos); // 0
pos = str1.indexOf('G', 1);
System.out.println("pos = " + pos); // 5
// 查找字符串
pos = str1.indexOf("day");
System.out.println("pos = " + pos); // -1
pos = str1.indexOf("Day");
System.out.println("pos = " + pos); // 17 字符串中第一个字符的下标
pos = str1.indexOf("Day", 17);
System.out.println("pos = " + pos); // 17 字符串中第一个字符的下标
pos = str1.indexOf("Day", 18);
System.out.println("pos = " + pos); // 21 字符串中第一个字符的下标
// 编写通用代码实现将字符串str1中所有"Day"出现的索引位置找到并打印出来
pos = 0;
while ((pos = str1.indexOf("Day", pos)) != -1) {
System.out.println("pos = " + pos);
pos += "Day".length();
}
}
}
~~~
>[danger] ##### 字符串截取
1. 子字符串从指定的beginIndex开始，并扩展到索引**endIndex - 1处的字符。 因此子串的长度是endIndex-beginIndex** 。
2. **IndexOutOfBoundsException**- 如果 beginIndex为负数，或者 endIndex大于此 String对象的长度，或者 beginIndex大于 endIndex 。
|方法声明 |功能介绍|
| --- | --- |
|String substring(int beginIndex, int endIndex)|返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串|
|String substring(int beginIndex)|返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串|
~~~
public class TestStr {
public static void main(String[] args) {
String str = new String("Good Good Study, Day Day Up!");
String str1 = str.substring(5);
System.out.println(str1); // Good Study, Day Day Up!
String str3 = str.substring(5, 7);
System.out.println(str3); // Go
String str2 = str.substring(5, 100);
System.out.println(str2); // IndexOutOfBoundsException
}
}
~~~
>[danger] ##### 字符串分割
1. `String[] split(String regex) `参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组
* 注单个字符或者字符串都也可算为正则表达式
~~~
import java.util.Arrays;
public class TestStr {
public static void main(String[] args) {
String str = "a1b2c3d5e";
String[] strArr = str.split("c");
System.out.println(Arrays.toString(strArr)); // [a1b2, 3d5e]
String[] strArr1 = str.split("\\d");
System.out.println(Arrays.toString(strArr1)); // [a, b, c, d, e]
}
}
~~~
>[danger] ##### 字符串替换
|方法名称 |方法说明|
| --- | --- |
|String replace(char oldChar, char newChar)|使用参数newChar替换此字符串中出现的所有参数 oldChar|
|String replaceFirst(String regex,String replacement)|替换此字符串匹配给定的正则表达式的第一个子字符串|
|String replaceAll(String regex, String replacement)|将字符串中匹配正则表达式regex的字符串替换成replacement|
~~~
public class TestStr {
public static void main(String[] args) {
String str = "a1b2c3d5ec";
String rStr = str.replace('c', 'z');
System.out.println(rStr); // a1b2z3d5ez
String rStr1 = str.replaceFirst("c", "f");
String rStr2 = str.replaceFirst("\\d", "f");
System.out.println(rStr1); // a1b2f3d5ec
System.out.println(rStr2); // afb2c3d5ec
String rStr3 = str.replaceAll("c", "f");
String rStr4 = str.replaceAll("\\d", "f");
System.out.println(rStr3); // a1b2f3d5ef
System.out.println(rStr4); // afbfcfdfec
System.out.println(str); // a1b2c3d5ec
}
}
~~~
>[danger] ##### 字符串拼接 -- join
|方法名称 |方法说明|
| --- | --- |
|static String join(CharSequence delimiter, CharSequence... elements)|`delimiter`：每个元素要添加的分隔符，`elements`：需要添加分隔符的字符串|
|static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) |`delimiter`：每个元素要添加的分隔符，`elements`：表示被连接的数组（也可以是集合）|
~~~
public static void main(String[] args) {
// 字符串数组
String []arr={"ab","ce","df"};
System.out.println(String.join(",",arr));
// 集合
List<String> list=new ArrayList<>();
list.add("s1");
list.add("s5");
list.add("s3");
System.out.println(String.join("-",list));
// 显示时间
String date = String.join("/","01","25","2020");
System.out.print(date);
String time = String.join(":", "12","10","10");
System.out.println(" "+time);
}
~~~
* 打印结果
~~~
ab,ce,df
s1-s5-s3
01/25/2020 12:10:10
~~~
- windows -- 环境变量
- Vscode -- 编写java
- 初始java
- java -- 关键字
- 编写第一个java程序
- java -- 注释
- 计算机存储 -- 进制
- java -- 类型
- java -- 变量
- 数字类型
- 布尔类型
- 字符类型
- 类型转换
- 双等比较是什么
- java -- 运算符
- 算数运算符
- 字符串拼接
- 关系/比较运算符
- 自增减运算符
- 逻辑运算符
- 三目运算
- 赋值运算符
- 移位运算符
- 位运算符
- 运算符优先级
- java -- 流程控制语句
- if /else if /if -- 判断
- switch case分支结构
- for -- 循环
- 用双重for循环
- while -- 循环
- do while -- 循环
- 案例练习
- java -- 数组
- 数组的存储
- 数组的增删改查
- 数组的特点
- 数组案例
- 二维数组
- 数组的工具方法
- java -- 方法
- java -- 方法的重载
- java -- 方法的调用流程
- java -- 类方法传参注意事项
- java -- 方法练习案例
- 对比 return break continue
- for each循环
- java -- 基础练习
- java -- 面向对象
- java -- 创建类和对象
- java -- 访问控制符
- java -- 类成员方法
- java -- 构造方法
- java -- this
- java -- 封装
- java -- 对象内存图
- java -- 创建对象案例
- java -- static
- java -- 继承
- super -- 关键字
- java -- 构造块和静态代码块
- java -- 重写
- java -- final
- java -- 多态
- java -- 抽象类
- java -- 接口
- 引用类型数据转换
- 综合案例
- java -- 内部类
- java -- 回调模式
- java -- 枚举类型
- java -- switch 使用枚举
- java -- 枚举方法使用
- java -- 枚举类实现接口
- java -- javaBean
- java -- package 包
- java -- import
- java -- 递归练习
- java -- 设计模式
- 单例模式
- java -- 注解
- java -- 元注解
- Java -- 核心类库
- java -- 处理字符串
- Java -- String
- String -- 常用方法
- String -- 正则
- Java -- StringBuilder 和 StringBuffer
- 知识点
- Java -- StringJoiner 字符串拼接
- 练习题
- 字符串的总结
- Java -- 包装类
- Integer
- Double
- Boolean
- Character
- java -- 集合类
- java -- util.Collection
- Iterator接口
- java -- util.List
- java -- ArrayList
- java -- util.Queue
- java -- util.Set
- java -- util.Map
- java -- util.Collections
- Java -- Math
- Java -- java.lang
- Java -- Object
- Java -- 获取当前时间戳
- Java -- 异常
- Java -- java.util
- java -- Date
- java -- Calender
- Java -- java.text
- Java -- SimpleDateFormat
- Java -- java.time
- Java -- java.io
- java -- io.File
- java -- 泛型
- IDEA -- 用法