目录
字符串比较
equals
compareTo和compareToIgnoreCase
contentEquals
字符串切割
substring
split
字符串转字节数组
getBytes
大小写转换
toLowerCase 大写转小写
toUpperCase 小写转大写
字符串的替换
replace:替换指定字符
replaceAll：替换所有正则表达式匹配到的字符串
replaceFirst：替换到最先匹配到的元素
获取指定字符下标
indexOf,lastIndexOf(获取最后出现的下标)
某个字符串中是否存在指定字符
contains()
去除字符串两端空格
trim()
获取指定下标的元素
charAt()
将字符串转换为char数组
toCharArray()
返回指定位置索引的Unicode点位
codePointAt()
字符串拼接
concat()
String.join
是否是以指定字符串开头或结尾()
startWith（）以..开头
EndWith（）以..结尾
将字符串常量初始化到常量池
intern()
字符串比较
equals
equals与==的区别：
- ==是判断两个变量或实例是不是指向同一个内存空间，equals是判断两个变量或实例所指向的内存空间的值是不是相同
- ==是指对内存地址进行比较 ， equals()是对字符串的内容进行比较
- ==指引用是否相同， equals()指的是值是否相同
/**
* equals方法测试
* equals比较的是字符串的内容
* ==比较的是地址值
* <p>
* equals方法的实现逻辑：
* 两个字符串进行比较
* ①先判断是否是同一个对象，如果是返回true
* ②如果不是同一个对象，将字符串转为char数组，按下标进行遍历，挨个比较各个元素
*/
@Test
public void equalsTest() {
String abc = new String("abc");
String a1 = "abc";
boolean equals = a1 == abc;
System.out.println(equals);//false
boolean equals1 = a1.equals(abc);
System.out.println(equals1);//true
}compareTo和compareToIgnoreCase
compareTo与compareToIgnoreCase的区别是：
compareToIgnoreCase不区分大小写，compareTo区分大小写
/**
* 比较两个字符串是否相等
* 相等返回0
*/
@Test
public void compareToTest() {
String a1 = "AAadas123";
int aAadas123 = a1.compareTo("AAadas123");
System.out.println(aAadas123);//0
int aaadas123 = a1.compareToIgnoreCase("aaadas123");
System.out.println(aaadas123);//0
}contentEquals
字符串内容比较
/**
* 字符串内容比较
*/
@Test
public void contentEqualsTest() {
String a1 = "AAadas123";
boolean aa = a1.contentEquals("AAadas123");
System.out.println(aa);//true
}字符串切割
substring
截取指定的下标范围内的字符串
/**
* substring方法测试
* 作用：截取指定的下标范围内的字符串
* substring(int beginIndex, int endIndex) 包头不包尾
* <p>
* substring(int beginIndex, int endIndex)的实现逻辑
* 获取到所需的字符长度，以及其实元素的下标，调用System.arraycopy方法
* 将截取到的数据放到一个新的char数组中
* <p>
* substring(int beginIndex)
* 作用：截取当前下标之后的所有字符串（包含当前下标）
* <p>
* 二者区别：只是获取所要截取的字符串长度有变化，其他基本相同
*/
@Test
public void substringTest() {
String a1 = "abcdefg123";
/*
要注意substring的beginIndex，不能大于endIndex，否则会抛出字符串下标越界异常
java.lang.StringIndexOutOfBoundsException: String index out of range: -1
子字符串从指定的beginIndex开始，并扩展到索引endIndex-1处的字符。因此，子字符串的长度为endIndex - beginIndex。
*/
String substring = a1.substring(2, 6);
System.out.println(substring);//cdef
String substring1 = a1.substring(3);
System.out.println(substring1);//defg123
}split
按指定字符串或正则表达式进行分割
普通分割
String a1 = "AAada.s123";
String[] as = a1.split("\\.");
for (String a : as) {
System.out.println(a);
}输出结果：
特殊情况
①空字符串不被解析（逗号放在开头也是同一样的）
String str = "1,2,3,4,,,";
String[] arr = str.split(",");
for (String string : arr) {
System.out.println("str" + string);
}
System.out.println(arr.length);运行结果：
②最后一个被分隔符的分割字符串不为空时，其余空字符串可被解析
String str1 = "1,2,3,4,,,5";
String[] arr1 = str1.split(",");
for (String string : arr1) {
System.out.println("str" + string);
}
System.out.println(arr1.length);运行结果：
split(String regex, int limit) 第一个参数是传入字符类型的分隔符,如 “,” 等(可以是任何字符串) 第二个参数传入整型的limit,代表的是将此字符串分割成n部分(这里的n就是limit)
limit为正数
/**
* 如果limit输入的是一个正数,
* 那么该模式将最多应用limit - 1次(就是说只会用输入的regex去字符串里面匹配limit-1次)，
* 数组的长度将不大于limit，
* 并且数组的最后一个条目将包含最后一个匹配的分隔符之外的所有输入(就是说他分隔的模式是从前逐个往后的).
*/
System.out.println("如果limit输入的是一个正数");
String strs = "1,2,3,4";
String[] s = strs.split(",", 2);
for (String string : s) {
System.out.println("子字符串" + string);
}
System.out.println(s.length);运行结果：
limit为0
/**
* 如果输入的limit为零，则模式将被应用尽可能多的次数，
* 结果数组可以有任何长度，而尾部的空字符串将被丢弃.
* (就是匹配字符串里面所有的regex分隔符),
* 关于空字符串被丢弃
*/
System.out.println("如果输入的limit为零");
String strs1 = "1,2,3,4,,";
String[] s1 = strs1.split(",", 0);
for (String string : s1) {
System.out.println("子字符串" + string);
}
System.out.println(s1.length);运行结果：
limit为负数
/**
* 如果输入limit的值为负数，则模式将被应用尽可能多的次数，数组可以有任何长度(尾部的空字符串也不会被丢失噢)
*/
System.out.println("如果输入limit的值为负数");
String s2 = "1,2,3,4,,";
String[] ss = s2.split(",", -1);
for (String string : ss) {
System.out.println("子字符串" + string);
}
System.out.println(ss.length);
}运行结果：
字符串转字节数组
getBytes
/**
* getBytes方法测试
* 作用：将字符串转为字节数组（可以指定编码格式）
* <p>
* 由于计算机只能识别出数字，无法识别文本，
* 所以我们日常使用的文字都需要进行编码后才能在计算机中进行计算、存储；
* 常见的编码方式有ASCLL编码、GBK编码、UTF-8编码、Unicode编码
* <p>
* encode->编码 （string->byte[]）
* decode->解码（byte[]->string）
* getChars方法
* 作用：将指定范围的字符串内容复制到一个新的char数组中
*/
@Test
public void getBytesTest() {
String a1 = "abcdefg123";
byte[] bytes = a1.getBytes(StandardCharsets.UTF_8);
for (byte aByte : bytes) {
System.out.println(aByte);
}
char[] a = new char[9];
a1.getChars(1, 5, a, 2);
String s = new String(bytes);
System.out.println(s);
System.out.println(a);
}运行结果：
大小写转换
toLowerCase 大写转小写
toUpperCase 小写转大写
/**
* toLowerCase 大写转小写
* toUpperCase 小写转大写
* toLowerCase(Locale locale)指定语言进行转换：
* 希望你指定使用的是哪种语言，不带参数的String.toUpperCase()和String.toLowerCase()使用的是系统缺省的语言，
* 例如操作系统的当前语言。有些语言的大小写转换使用了较特殊的规则，甚
* 至不是1：1的字符对应关系，也就是说转换前和转换后的字符串长度不一定相等。
* 作用：大小写转换
*/
@Test
public void toLowerCaseTest() {
String a1 = "AAadas123";//AAADAS123
String s = a1.toLowerCase(Locale.ROOT);
String s1 = a1.toUpperCase(Locale.TAIWAN);
System.out.println(s1);
}字符串的替换
replace:替换指定字符
replaceAll：替换所有正则表达式匹配到的字符串
replaceFirst：替换到最先匹配到的元素
/**
* replace
* 作用:字符串的替换
* replaceAll(String regex, String replacement)
* 将正则表达式匹配到的内容进行替换
*/
@Test
public void replaceTest() {
String a1 = "AAadas123";
String replace = a1.replace('A', 'b');
System.out.println(replace);//bbadas123
//将匹配到的英语换位数字
String s = a1.replaceAll("[A-Z]", "7777");
System.out.println(s);//77777777adas123
String a2 ="AACd2324" ;
String s1 = a2.replaceFirst("A", "EEE");
System.out.println(s1);//EEEACd2324
}获取指定字符下标
indexOf,lastIndexOf(获取最后出现的下标)
/**
* indexOf,lastIndexOf(获取最后出现的下标)
* 作用:获取指定字符的下标
*/
@Test
public void index() {
String a1 = "AAadas123";
int a = a1.indexOf("A");
//返回此字符串中第一次出现指定字符的索引。
// 如果值ch的字符出现在此String对象表示的字符序列中，则返回第一次出现的索引（以 Unicode 代码单元表示）。
// 对于 0 到 0xFFFF（含）范围内的ch值，这是满足以下条件的最小值k ：this.charAt(k) == ch是真的。
// 对于ch其他值，它是满足以下条件的最小值k ：this.codePointAt(k) == ch是真的。
// 在任一情况下，如果此字符串中没有出现此类字符，则返回-1 。
int i = a1.indexOf(97);
System.out.println(i);//2
System.out.println(a);//0
//从指定下标开始，查找指定字符第一次出现的下标
int a2 = a1.indexOf("A", 3);
System.out.println(a2);//-1
int a3 = a1.indexOf('A', 1);
System.out.println(a3);//0
}某个字符串中是否存在指定字符
contains()
/**
* contains()
* 作用：某个字符串中是否存在指定字符
*/
@Test
public void contains() {
String a1 = "AAadas123";
boolean a = a1.contains("a");
System.out.println(a);//true
}去除字符串两端空格
trim()
/**
* trim()
* 作用：去除字符串两端空格
*/
@Test
public void trimTest() {
String a1 = " AAadas123 ";
String aaa = a1.trim();
System.out.println(aaa);//AAadas123
}获取指定下标的元素
charAt()
/**
* charAt
* 获取指定下标的元素
*/
@Test
public void charAtTest() {
String a1 = " AAadas123 ";
char aaa = a1.charAt(1);
System.out.println(aaa);//A
}将字符串转换为char数组
toCharArray()
/**
* toCharArray()
* 将字符串转换为char数组
*/
@Test
public void toCharArrayTest() {
String a1 = " AAadas123 ";
char[] aaa = a1.toCharArray();
System.out.println(aaa);
}返回指定位置索引的Unicode点位
codePointAt()
/**
* codePointAt()
* 返回指定位置索引的Unicode点位
*/
@Test
public void codePointAtTest() {
String a1 = "AAadas123";
int aaa = a1.codePointAt(2);
System.out.println(aaa);//97
/**
* 返回此字符串的指定文本范围内的Unicode代码点数。文本范围从指定的beginIndex开始，
* 延伸到索引endIndex-1处的字符。
* 因此，文本范围的长度（以字符为单位）为endIndex - beginIndex。
* 文本范围内未配对的代理计算为一个代码点。
* 统计字符个数，左闭右开
*/
int i = a1.codePointCount(1, 8);
System.out.println(i);//7
/**
* 方法返回字符串中指定索引之前的字符的Unicode值
* 值0将生成错误，因为这是一个负数（超出范围）
*/
int i1 = a1.codePointBefore(1);
System.out.println(i1);//65
}字符串拼接
‘’+‘’拼接
原理： 字符串常量之间的拼接操作在未加载到内存之前就已经完成了。在前端编译期间（即将.java源文件编译为.class字节码文件），会对字符串常量之间的拼接操作进行优化
concat()
/**
* 字符串拼接 调用底层 System.arraycopy 进行复制数组
* 频繁拼接字符串推荐使用stringbuffer和stringbuilder
*/
@Test
public void concatTest() {
String a1 = "AAadas123";
String concat = a1.concat("aaa").concat("aa");
System.out.println(concat);//AAadas123aaaaa
}String.join
将不同的字符串用指定的分隔符进行拼接
@Test
public void joinTest() {
String a1 = "AAadas123";
String a2 = "sadsa";
String mm = String.join(",", a1,a2);
System.out.println(mm);//AAadas123,sadsa
}是否是以指定字符串开头或结尾()
startWith（）以..开头
EndWith（）以..结尾
/**
* startsWith()
* 作用:是否是以指定字符串开头（也以匹配正则表达式）
* endsWith()同理
*/
@Test
public void startsWithTest() {
String a1 = "AAadas123";
boolean i = a1.startsWith("A");
//从何处开始查询次字符串
boolean i1 = a1.startsWith("A", 1);
System.out.println(i1);//true
boolean b = a1.endsWith("1");
System.out.println(b);//false
}将字符串常量初始化到常量池
intern()
/**
* intern()
* 作用：如果常量池中存在当前字符串, 就会直接返回当前字符串.
* 如果常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回。
*/
@Test
public void internTest() {
// 创建了2个对象，第一个对象是”aaa”字符串存储在常量池中，第二个对象在JAVA Heap中的 String 对象
String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2); // false s1和s2指向堆中的两个不同对象
// 将字符串s1放入常量池，由于常量池已经存在了"aaa"，于是返回的就是常量池中的对象引用。
String s3 = s1.intern();
// 由于常量池中已有“aaa”，直接返回常量池中的引用
String s4 = "aaa";
System.out.println(s1 == s3); // false s1指向的是堆中的对象，s3指向的是常量池中的对象
System.out.println(s4 == s3); // true
// 在堆中创建了两个匿名对象，还有一个“aaabbb”对象，常量池中有"aaa"和“bbb”对象。
String s5 = new String("aaa") + new String("bbb");
// 将字符串s5放入常量池，这里直接存储的是堆中对象的引用，因为常量池中不需要再存储一份相同对象了。这个引用指向 s5 引用的对象。
String s6 = s5.intern();
System.out.println(s5 == s6); // true s6和s5指向的是同一个对象
String s7 = "aaabbb";
System.out.println(s5 == s7); // true
}