JAVA String
前言
断更好久了，目前准备持续更新中。
之前学过也用过String的方法，但是好多都忘了，导致使用的时候想不起来，所以打算出一个测试jdk自带方法的测试。
使用前注意需要把字符集编码设置为UTF-8
以下涉及到单元测试，不懂请百度，下面只会简单的讲怎么使用
以下只是纯粹的个人见解，菜鸟一枚如有争议敬请发言
以下加？表示不知或者不确定
提示：以下是本篇文章正文内容，下面案例可供参考
一、String官方解释
String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
注意一般不建议使用 String str = new String("a,b,c"); 这样的
二、单元测试简介
1.单元测试简单使用方法
敲如下代码，注意不需要main方法即可
@Test
public void sayHello() {
System.out.println("HelloWorld!");
}这里会发现@Test报错，鼠标移到这里，选择Add Junit 4 library to the build path;
这里导入单元测试需要的Junit4，当然选择Junit5也可以，但是没必要
单元测试的作用是：写完方法体之后可以单独测试某个方法体。因为后期需要的方法很多，代码很多，如果只是为了测试一个小方法就需要运行整个程序就太麻烦了，
这里可以直接运行此方法，选中方法名称比如上面的sayhello右键run as 1Junit test就OK了
注意单元测试不能有返回值，还有其他很多限制，请自行百度。
三、测试开始
1.charAt() - 常用
首先看看官方API：
/*
* charAt(n) n表示下标索引，因为eclipse用的是utf-8字符集编码，因而不管是英文还是中文
* 都只会被编译器认为是一个，因而charAt(1)就是 爱
*/
@Test
//charAt()
public void Test_charAt()
{
String str1 = "我爱中国!";
System.out.println(str1.charAt(1));//爱
}打印结果一般会放在打印行的备注里面
注意： 此方法比较常用。主要用法就是截取字符串的某一个字符，注意返回值是char ，注意从0开始
2.codePointAt()
官方API：
/**
* codePointAt(index) 表示返回下标为index位置的字符的字符集编码对应的数字
*/
@Test
//codePointAt()
public void Test_codePointAt()
{
String str = "我爱中国!A";
System.out.println(str.codePointAt(5)); //65
}打印下标为5位置的字符（A)的字符集编码对应的数字。
3.codePointBefore()
注意对比上一个
API
/**
* codePointBefore(index) 表示返回下标为index位置的前一个位置的字符的字符集编码对应的数字
*/
@Test
//codePointBefore()
public void Test_codePointBefore()
{
String str = "我爱中国!A";
System.out.println(str.codePointBefore(6));//65
}
4.codePointCount()
-注意区分length（）方法
API
/**
* codePointAt(index) 简单理解为返回字符个数，
* 相比于length();length() 返回的是使用的是UTF-8编码的字符代码单元数量，
*不一定是实际上我们认为的字符个数。
*/
@Test
//codePointCount()
public void Test_codePointCount()
{
String str = "我爱中国!A";
System.out.println(str.codePointCount(0,str.length()));//6
System.out.println(str.length());//此时是6，当区分两者的区别
}注意：相比于length();length() 返回的是使用的是UTF-8编码的字符代码单元数量，不一定是实际上我们认为的字符个数。
其实我自己没有测试出区别，有知道的大佬可以告知一下；
5.compareTo(); 偶尔使用
API：
/**
* compareTo();
* 简单理解为：按照字典顺序比较，连个字符串相等返回0；
* 如果前者（方法体之前那个）在字典顺序之后，返回正整数
*/
@Test
public void Test_compareTo()
{
String str1 = "我爱中国！";
System.out.println(str1.compareTo("我爱中国！"));//0
//System.out.println(str1.compareToIgnoreCase("我爱中国！哈哈哈"));//-3
}这里是： 按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只在方法 equals(Object) 返回 true 时才返回 0。
这是字典排序的定义。如果这两个字符串不同，那么它们要么在某个索引处的字符不同（该索引对二者均为有效索引），要么长度不同，或者同时具备这两种情况。如果它们在一个或多个索引位置上的字符不同，假设 k 是这类索引的最小值；则在位置 k 上具有较小值的那个字符串（使用 < 运算符确定），其字典顺序在其他字符串之前。在这种情况下，compareTo 返回这两个字符串在位置 k 处两个char 值的差，
简单理解为：按照字典顺序比较，连个字符串相等返回0；如果前者（方法体之前那个）在字典顺序之后，返回正整数；反之负整数
一般情况下不会在意他的值，只需要在意其是否为0，是大于0还是小于0。
比较连个字符串是否相等一般用equals()；见第12点
6. concat() -较常用
表示连接两个字符串，但是我们更加常用的是连接符'+';
API
/**
* concat() 将字符串连接到指定字符串的末尾
* @param args
*/
@Test
public void Test_concat()
{
String str1 = "我爱中国！";
System.out.println(str1.concat("你呢"));//我爱中国！你呢
}我们更加常用的写法是：
System.out.println(str1 + "你呢");
7.contains() -较常用
API:
/**
* contains();当且仅当字符串包含指定的char值序列是才返回true
*/
@Test
public void Test_contains()
{
String str = "我爱中国！";
System.out.println(str.contains("我"));//true
}这里他让使用 CharSequence，这个我没怎么使用，查了一下字典是字符序列，我这里使用字符串成功了。
官方解释是：
-
CharSequence是
char值的可读序列。 该界面提供统一的，只读访问许多不同类型的char序列。char值代表基本多语言平面（BMP）或代理中的一个字符
8.contentEquals()
API：
/**
* contentEquals();将此字符串与指定的StringBuffer进行 ??
*/
@Test
public void Test_contentEquals()
{
String str = "我爱中国！";
StringBuffer sb = new StringBuffer("我爱中国!");
System.out.println(str.contentEquals(sb));//fasle
}StringBuffer用得少，不知道是不是这么用。至于为何返回false，请仔细看两个字符串，一个感叹号是中文状态下的，一个是英文状态下的，中文的感叹号占得位置要大一点；
注意对比第5点的compareTo()和第12点的equals()方法
9.copyValueof(char[] ch)
API：
valueOf(char[])的官方解释是：
/**
* copyValueof(char[] ch)；将字符数组输出为String类型，注意使用String.copyValueof()
*/
@Test
public void Test_copyValueof()
{
//String str ;
char[] ch = {'我','爱','中','国','！'};
System.out.println(String.copyValueOf(ch));//我爱中国
}注意对比 Arrays.toString(char[] ch);这种数组包装类的方法转化成字符串是[,,,,]类型的，
再此的输出结果是：[我, 爱, 中, 国, ！]
注意多考虑字符数组怎么转化为字符串，字符串又怎么转化为数组；基本数据类型又怎么转化为字符串，字符串又怎么转化为基本数据类型；
10.endsWith() -较常用
API
注意suffix翻译为后缀
/**
* endsWith();测试此字符串是否以指定的后缀结尾。
*/
@Test
public void Test_endWith()
{
String music = "来自天堂的魔鬼-邓紫棋.mp3";
boolean isMusic = music.endsWith(".mp3");
if(isMusic)
System.out.println("是一首音乐！");
else
System.out.println("不是一首音乐！");
}运行结果：是一首音乐
联系下面的startWith();一般用于判断文件格式；
11.startsWith(String prefix) - 较常用
API：
prefix翻译：前缀
/**
* startsWith(String prefix) 测试此字符串是否以指定的前缀开头。
*/
@Test
public void Test_startWith()
{
String str = "tp_book";
System.out.println(str.startsWith("tp_"));//true
//startsWith(String prefix, int toffset)
//测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。
str = "abcdefg_tp_guist";
System.out.println(str.startsWith("tp_",str.indexOf("t")));//true
}说明：“tp_” 一般是数据库常用的前缀
12 equals() -常用
API：
/**
* equals();与指定对象进行比较
*/
@Test
public void Test_equals()
{
String str1 = "我爱中国！";
String str2 = "a";
String str3 = "abc123";
System.out.println(str1.equals("我爱中国"));//false
System.out.println(str1.equals("我爱中国！"));//true
System.out.println(str2.equals('a'));//false
System.out.println(str2.equals('A'));//false
System.out.println(str3.equals("abc123"));//true
System.out.println(str3.equals('a'));//false
}注意：API说的是与Objcet对象进行比较，总所周知java所有的方法都直接或者间接的继承于Object，因此理论上String能与所有的对象比较；
注意上面的单引号与双引号，一个表示字符一个表示字符串，注意区分！
13.getBytes();
API
/**
* getBytes();使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
*/
@Test
public void Test_getBytes()
{
String str = "aA0!";
byte[] b = str.getBytes();
System.out.println(Arrays.toString(b));//[97, 65, 48, 33]
}Arrays.toString(byte[] b)表示将短整型数组转换为字符串
14.getChars
API：
/**
* getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：
*将此字符串中的字符复制到目标字符数组中。
*/
@Test
public void Test_getChars()
{
char[] ch = new char[50];
String str = "我爱中国！";
str.getChars(0, 5, ch,10);
System.out.println(Arrays.toString(ch));
}注意此方法返回void即返回空，因此不能直接输出;
自己试一试结果，改变一下那三个数字试试。
15.hashCode()
API
/**
* hashCode();返回此字符串的哈希码。
*/
@Test
public void Test_hashCode()
{
String str = "AV";
int hashCode = str.hashCode();
System.out.println(hashCode);//2101
}本人不怎么使用哈希码，甚至不知道其应用方向，个人猜测会用到但是绝对不常用。
16.indexOf() -常用
API
/**
* indexOf();
*/
@Test
public void Test_indexOf()
{
String str = "我爱中国!我爱中国！我爱中国！";
//返回指定字符第一次出现的字符串内的索引。
int index = str.indexOf("我");
System.out.println("第一次出现 我 的位置（下标）是：" + index);//0
//返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
index = str.indexOf("我", 7);
System.out.println(index);//10
//返回指定子字符串第一次出现的字符串内的索引。
index = str.indexOf("中国");
System.out.println(index);//2
}关注下一个lastIndexOf()
17.lastIndexOf() -常用
API
/**
* lastIndexOf();返回指定字符的最后一次出现的字符串中的索引。
*/
@Test
public void Test_lastIndexOf()
{
String str = "我爱中国！我爱中国！我爱中国！";
//lastIndexOf() 括号内皆可以使用字符又可以使用字符串
System.out.println(str.lastIndexOf("！"));//14 （-1表示没找到相对应的，注意感叹号是中文的)
//lastIndexOf(int ch, int fromIndex) 返回指定字符的最后一次出现的字符串中的索引，从指定的索引开始向后搜索。
System.out.println(str.lastIndexOf("我",3));//5 这里我觉得是从指定索引向前搜索。
}
18.intern()
API
/**
* intern();返回字符串对象的规范表示。
* 暂时不知道用处
*/
@Test
public void Test_intern()
{
String str = "我 爱 中 国！";
System.out.println(str.intern());
}自行测试，暂时不知道有什么用
19. isEmpty() -常用
API:
/**
* isEmpty();为空返回true
*/
@Test
public void Test_isEmpty()
{
String str = "我爱中国！";
System.out.println(str.isEmpty());//false
}常常用于判断字符串是否为空
20.legth() -常用
API
/**
* legth();返回长度，注意是设置了字符集后，中文只算一个，注意区别数组的lenth，后者没有括号
*/
@Test
public void Test_length()
{
String str = "我爱中国！我爱中国！我爱中国！";
System.out.println(str.length());//15
}注意这里的一个中文只算了一个，众所周知，中文占2-4个字节（根据字符集编码不同，占得字节数可能不同）
21.matches(String regex)
API
regex:正则表达式
/**
* matches(String regex):告诉这个字符串是否匹配给定的 regular expression 。
* regex是正则表达式
* 这个不会
*/
@Test
public void Test_matches()
{
String str = "我爱中国！我爱中国！我爱中国!";
System.out.println(str.matches("!"));//不会正则表达式
}正则表达式涉及到我的知识盲区，喜欢的自己研究
22.replace() -常用
API
/**
* replace(char oldChar, char newChar);返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。
*/
@Test
public void Test_replace()
{
//返回String
String str = "我爱中国！我爱中国！我爱中国!";
System.out.println(str.replace("中国", "四川"));//我爱四川！我爱四川！我爱四川!
//replace(CharSequence target, CharSequence replacement)
//将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。
System.out.println(str.replace(str, "hahah"));//没搞懂
}replace(char oldChar, char newChar) ，用括号里面第二个字符或者字符串替换括里面第一个字符或者字符串
replace(CharSequence target, CharSequence replacement) 这种不清楚，还没见过CharSequence这种类型数据
23.replaceFirst()
API
垃圾翻译，简单来说就是替换第一个出现的字符或者字符串，不过注意regex可以使字符串或者正则表达式。
/**
* replaceFirst(String regex, String replacement) ;用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。
*/
@Test
public void Test_replaceFirst()
{
String str = "我爱中国！我爱中国！我爱中国!";
System.out.println(str.replaceFirst("中国", "四川"));//我爱四川！我爱中国！我爱中国!
//试试正则表达式 .表示第一个？
System.out.println(str.replaceFirst(".", "四川"));//四川爱中国！我爱中国！我爱中国!
}建议自行测试正则表达式，有时候非常有用。
24.split() -常用
API：
简单理解为：使用某个标志将字符串拆分为2段或者多段并且存储在字符串数组中。
/**
* split(String regex)
* 简单来说吧一个字符串通过给定的关键字分割成几段，其值存在字符串型数组（不包含关键字）
*/
@Test
public void split()
{
String str = "1我爱中国！2我爱中国！3我爱中国";
//Arrays.toString的作用是将数组（任意类型数组，一元数组）转化成字符串[str[0],str[1],……] 这样子的
System.out.println(Arrays.toString(str.split("！")));//[1我爱中国, 2我爱中国, 3我爱中国]
//以下为注意事项
str = "aa_bbb___cc_d__eeeee__ff_g_hh___iii";
//如果关键字设置为_ 那么不管 _的左右有没有其他字符，都会被分割，会产生空字符，但是会占用数组的位置
System.out.println(Arrays.toString(str.split("_")));//[aa, bbb, , , cc, d, , eeeee, , ff, g, hh, , , iii]
//注意很多符号被正则表达式占用。比如 . 号，因而使用的话需要\. 但是\也是一种正则表达式，因而需要再来一个\ 所以写法就是 \\.
str = "aa.bbb.cc.d..eeeee..ff.g.hh...iii";
System.out.println(Arrays.toString(str.split("\\.")));
//split(String regex, int limit) .将这个字符串拆分为给定的 regular expression的匹配。
//简单来说就是从做开始拆分为几个，一旦个数满足则不再拆分
System.out.println(Arrays.toString(str.split("\\.",5)));//[aa, bbb, cc, d, .eeeee..ff.g.hh...iii]
}解释：上文中 str.split("！") 中，请注意是中文状态下的感叹号；str中共出现2次，因而这里的作用便是把str字符串拆分为3段，如果存储在str1数组里面，那么str1[0] 的值是 1我爱中国 ,str1[1]的值是 2我爱中国 ,str1[2]的值是 3我爱中国;
总所周知，任何数组不能直接输出，如果强制输出会返回什么呢：看下面代码：
String str = "1我爱中国！2我爱中国！3我爱中国";
String[] str1 = str.split("！");
System.out.println(str1);//[Ljava.lang.String;@5a2e4553其结果返回的是[Ljava.lang.String;@5a2e4553。
这里要么通过循环输出，要么调用Arrays的方法能把字符串数组直接变成字符串，再输出。
切记切记切分的标志可以使正则表达式，英文的句号和\ 都是被占用了的，如果要通过英文句号来切分，则需要一个转义字符\ ，然后转义字符也被占用了，因此需要再来一个转义字符\
所以 "\\."的作用就是通过英文句号拆分
25.substring(): -常用
API
理解为从当前下标开始，字符串后面所有的字符返回一个新的字符串（包含当前下标）
/**
* substring(int beginIndex):
*返回一个字符串，该字符串是此字符串的子字符串。
*可以做份切分字符串的一种方式,
*且是以下标位置开始，字符后面所有的部分（包括当前下标）返回新的字符串
*/
@Test
public void Test_substring()
{
String str = "1我爱中国！2我爱中国！3我爱中国！";
System.out.println(str.substring(6));//2我爱中国！3我爱中国！
System.out.println(str.substring(12));//3我爱中国
//substring(int beginIndex, int endIndex) 一个开始下标和结束下标
str = "1我爱中国！2我爱中国！3我爱中国！";
System.out.println(str.substring(6,11));//2我爱中国 注意左闭右开
}注意str.substring(6,11) 6到11是 左闭右开区间，数学表示为： [5,11)
可以作为字符切分，想切分哪里就切分哪里，具体截取的哪里不建议去记忆，来一个输出语句看看，错了就调整就是了
26.subSequence():
API
/**
* subSequence(int beginIndex, int endIndex):返回一个字符序列，该序列是该序列的子序列。
*/
@Test
public void Test_subSequence()
{
String str = "我爱中国！hahahhaha！啊哈控股！";
System.out.println(str.subSequence(5, 9));//haha 注意左闭右开！
}区分上面的substring()
以下来自csdn某位大佬解释： subSequence和substring的区别
返回类型不一样，subString返回的是String，
subSequence返回的是实现了CharSequence接口的类，
也就是说使用subSequence得到的结果，只能使用CharSequence接口中的方法。
不过在String类中已经重写了subSequence，调用subSequence方法，可以直接下转为String对象
27.toCharArray()
API
/**
* toCharArray() :将此字符串转换为新的字符数组。
* 注意数组转字符的方法可以用Arrays.toString(数组)；此方法为一元数组，且转化后的字符串带有[,,,,]这些符号
*/
@Test
public void Test_toCharArray()
{
String str = "我爱中国！我爱中国！我爱中国！";
//注意使用字符数组接收
char[] ch = str.toCharArray();
//循环的方式看看字符数组的值
for(int i = 0; i < ch.length;i++)
{
System.out.print("下标为" + i +"的值是" + ch[i] + " ");
}
System.out.println();
//调用Arrays的方法输出数组,返回值是String
System.out.println(Arrays.toString(ch));
}每个英文中文都切分为一个个字符
28.toLowerCase() -常用
API
全部转小写
/**
* toLowerCase() ;将所有在此字符 String使用默认语言环境的规则，以小写。
*/
@Test
public void Test_toLowerCase()
{
String name = "AaronLee";
System.out.println(name.toLowerCase());//aaronlee
//toLowerCase(Locale locale)
Locale l = new Locale("A");
System.out.println(name.toLowerCase(l));//aaronlee 不太懂Local这里不晓得
}目前测试结果中，中文不会有任何改变，英文会全部转化为小写，怎么不分转小写呢？参考下面的转大写方法，有例子
Local类型没怎么用过，不知道用法，可能能够简单的定位到某一个位置，
29.toUpperCase()
API
/**
* toUpperCase() ,简单理解为转大写
*/
@Test
public void Test_toUpperCase()
{
String name = "AaronLee";
System.out.println(name.toUpperCase());//AARONLEE
//同理不太懂toUpperCase(Locale locale) 展示不演示
//怎么将部分字母大写？不如 my name is aaronlee haha;把a..l 和haha大写
String str = "my name is aaronlee haha";
//使用charAt将a 和l截取出来
char c2 = str.charAt(11);
char c4 = str.charAt(16);
System.out.println(c2 + " " + c4);//看看结果对不对
//把最后的haha和其他部分一并截取出来
String s1 = str.substring(0,11);//注意左闭右开区间
String s3 = str.substring(12,16);
String s5 = str.substring(17,20);
String s6 = str.substring(20,str.length());//haha位置
//注意char要转化为String才能调用toUpperCase方法
String s2 = c2 + "";
String s4 = c4 + "";
System.out.println(s1+s2.toUpperCase()+ s3 + s4.toUpperCase() + s5 +s6.toUpperCase());//my name is AaronLee HAHA
//其实可以直接打印
System.out.println(str.substring(0,11) + (str.charAt(11)+"").toUpperCase() + str.substring(12,16)+(str.charAt(16) + "").toUpperCase() + str.substring(17,20)+ str.substring(20,str.length()).toUpperCase() );
//应该有简单的方法，比如toUpperCase(Locale locale)可能有效，不过不懂locale
}仔细研究代码，能够实现不分转大写。上面的小写同理
30.trim()
API
简单来说，删除字符串最开始和末尾的无用空格
/**
* trim() ;返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
* 大致意思就是删除前面和后面空格之类的吧
*/
@Test
public void Test_trim()
{
String str = " My name is AaronLee ";
System.out.println(str.trim());//My name is AaronLee 注意开始和末尾的很多空格都不在了
}
31.valueOf()
API
其大致意思是指把各种类型转化为字符串
仔细看，他没有举例字节整形，短整型，整形，长整形，单精度浮点型和双精度浮点型的数组，这些返回的或许不是你想要的
/**
* valueOf() ，大致意思是指把各种类型转化为字符串
*/
@Test
public void Test_valueOf()
{
//valueOf(boolean b)
boolean b = false;
String str1 = String.valueOf(b);//这里主要是提示用String来接收，就是返回值为字符串类型
System.out.println(str1);//false
//valueOf(char c)
char c = '我';
System.out.println(String.valueOf(c));//我
//valueOf(char[] data)
char[] ch = {'我','爱','中','国','！'};
System.out.println(String.valueOf(ch));//我爱中国！
//valueOf(char[] data, int offset, int count) 返回 char数组参数的特定子阵列的字符串 char形式。
System.out.println(String.valueOf(ch,2,3));//这里我的理解是，从下标为2的开始，输出3个
//valueOf(double d)
System.out.println(String.valueOf(123.12d));//123.12
//double d = String.valueOf(123.12d);//报错。返回值是String
//int long同理 还可以带入Object类型，因为java所有的方法都继承于Object，理论上来说所有的都能转换为String。这只是我个人猜测
//测试byte[] byte,short型数组最好不要使用此方法
byte[] b1 = {1,23,4,12,14};
System.out.println(String.valueOf(b1));//[B@5a2e4553
short[] s1 = {1,23,23,43,1,35};
System.out.println(String.valueOf(s1));//[S@28c97a5
int[] i1 = {1,2231,1,321,3,1,4234,23,4};
System.out.println(String.valueOf(i1));//[I@6659c656
double[] d1 = {1.3,4d,63d,121.3,12d,12.45d};
System.out.println(String.valueOf(d1));//[D@6d5380c2
char[] ch1 = {'我','爱','中','国','！'};
System.out.println(String.valueOf(ch1));//我爱中国
String[] str2 = {"我爱中国1","我爱中国2","我爱中国3","我爱中国4"};
System.out.println(String.valueOf(str2));//[Ljava.lang.String;@45ff54e6
/*
* 除了字符型数组，其他数组不建议使用此方法
*/
}总结
本次测试了String的很多方法，未来会持续更新其他测试。
如果发现问题，欢迎大家指正，更加欢迎大佬的意见或者建议。
创作不易，转载请注明出处。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
