Java字符串常见操作

1. indexOf(String str)返回字符串中某个字符串位置
2. indexOf(char ch, int fromIndex)从某一位置开始查找某字符位置
3. substring(int beginIndex )从指定位置返回后面的字符串
4. substring(int beginIndex, int endIndex)截取两个指定位置间的字符
5. 字符串翻转
6. lastIndexOf(String str)查找字符串中字符最后一次出现的位置
7. 通过下标获取字符串中对应下标的字符
8. 字符转数字
9. 判断字符是不是数字
10. 利用StringBuilder替换a到b之间的字符串
11. 利用StringBuilder替换某一下标处的字符
12. 利用StringBuilder在指定位置之前插入字符(串)
13. 利用StringBuilder删除起始位置（含）到结尾位置（不含）之间的字符串
14. 字符串小写转大写
15. 字符串大写转小写
16. 字符串不区分大小写比较
17. 去除首尾空格
18. 判断字符串中是否包含子字符串
19. 替换字符串中字符为其他字符
20. 字符串分割
21. List<String>转换为字符串数组
22. List<String>拼接为一个字符串
23. List<String>转换为List<Integer>
24. List<String>转换为Integer[]数组
25. 字符串去重
26. 字符串数组去重

---

以字符串**String str="abc${def}ab}c";**为例子。

indexOf(String str)返回字符串中某个字符串位置

indexOf(String str)返回字符串中某个字符串出现的位置，返回下标，不存在则返回-1

int chPostion1 = str.indexOf("}");  //将返回8。str中有两个"}"
int chPostion2 = str.indexOf("bc");  //将返回1
int chPostion3 = str.indexOf(99);   //将返回2。99为字符“c”的ascall码值，等同于str.indexOf("c")

indexOf(char ch, int fromIndex)从某一位置开始查找某字符位置

indexOf(char ch, int fromIndex)从某一位置开始查找某字符位置，返回下标，不存在则返回-1

int chPostion1 = str.indexOf("a",3);  //将返回9。从下标为3即从$开始查找“a”的位置
int chPostion2 = str.indexOf(97,3);  //将返回9。97为字符“a”的ascall码

substring(int beginIndex )从指定位置返回后面的字符串

String getsubStr = str.substring(3); //将返回${def}ab}c

substring(int beginIndex, int endIndex)截取两个指定位置间的字符

substring(int beginIndex, int endIndex)截取两个指定位置间的字符。起始位包括，结束位不包括

String getsubStr = str.substring(1,4); //将返回bc$

截取第一个"{“到第一个”}"间的字符串：

String getsubStr = str.substring(str.indexOf("{")+1,str.indexOf("}")); //将返回def

截取第一个"{“到第二个”}"间的字符串：

String getsubStr = str.substring(str.indexOf("{")+1,str.indexOf("}",str.indexOf("}")+1)); //将返回def}ab

字符串翻转

利用StringBuilder的内置reverse方法进行逆序

String reverse = new StringBuilder(str).reverse().toString(); //将返回 c}ba}fed{$cba 

lastIndexOf(String str)查找字符串中字符最后一次出现的位置

lastIndexOf(String str)查找字符串中字符最后一次出现的位置，若不存在则返回-1

int lastPostion = str.lastIndexOf("}"); // 将返回11

通过下标获取字符串中对应下标的字符

String getC = String.valueOf(str.charAt(2));//将返回c。str.charAt(2)返回的是char类型，所以需要通过String.valueOf转                                              //化为字符串

字符转数字

如果一个字符是数字可通过 -'0’操作转化为数字

char ch = '3';
int charNamber = ch-'0';//charNamber结果为数字型3

判断字符是不是数字

char ch = '3';
boolean isOrNo = Character.isDigit(ch);//isOrNo结果为true

利用StringBuilder替换a到b之间的字符串

StringBuffer buffer = new StringBuffer(str);
buffer.replace(0, 3, "123");  //包含0位置，不包含3位置
str = buffer.toString();       //str下标0到2的位置替换成了123，str为123${def}ab}c

利用StringBuilder替换某一下标处的字符

String str = "abeecsabxt";
StringBuilder strBuild = new StringBuilder(str);
strBuild.setCharAt(1, 'w');
String  result = String.valueOf(strBuild);
System.out.println(result);//输出：aweecsabxt

利用StringBuilder在指定位置之前插入字符(串)

String str = "abeecsabxt";
StringBuilder strBuild = new StringBuilder(str);
strBuild.insert(1, "qq"); //插入字符串
//strBuild.insert(1, 'q'); //插入字符
String  result = String.valueOf(strBuild);
System.out.println(result);//输出：aqqbeecsabxt

利用StringBuilder删除起始位置（含）到结尾位置（不含）之间的字符串

String str = "abeecsabxt";
StringBuilder strBuild = new StringBuilder(str);
strBuild.delete(1, 3);
String  result = String.valueOf(strBuild);
 System.out.println(result);//输出：aecsabxt

字符串小写转大写

str = str.toUpperCase();//str为ABC{DEF}AB}C

字符串大写转小写

String str = "ABC{DEF}AB}C";
str = str.toLowerCase();      //str为abc{def}ab}c

字符串不区分大小写比较

String str1 = "abc";
String str2 = "AbC";
System.out.println(str1.equalsIgnoreCase(str2));//true

去除首尾空格

 String str = "  abc{def} ab}c  ";
 str = str.trim();//str为abc{def} ab}c

判断字符串中是否包含子字符串

boolean containsAbc = str.contains("}ab}"); //containsAbc为true

替换字符串中字符为其他字符

替换所有：

String str1 = str.replace("}","777"); //str1将由abc{def}ab}c替换后变为abc{def777ab777c
String str2 = str.replaceAll("}","777"); //str2将由abc{def}ab}c替换后变为变为abc{def777ab777c

replace和replaceAll都是替换所有，区别在于replaceAll的参数是regex , 即基于规则表达式的替换 , 比如 , 可以通过replaceAll("\d", “*”)把一个字符串所有的数字字符都换成星号。

替换第一个：

str = str.replaceFirst("}","777"); //str将为abc{def777ab}c

用replace去除字符串中所有的 “.”：

String str="2020.08.10";
String str1 = str.replace(".","");//str1为20200810

字符串分割

分割为字符串数组：

String   str = "a,b,c,d";
String[] split = str.split(","); //通过","分割为"a","b","c","d"

使用工具类分割：

String   str = "a,b,c,d";
String[] split = StringUtils.split(str,","); //通过","分割为"a","b","c","d"

多空格分割：

String str = "a b  c    d";
String[] split = str.split("\\s+");
System.out.println(Arrays.toString(split));//[a, b, c, d]

分割为List：

List<String> strList = Arrays.asList(str.split(","));

List<String>转换为字符串数组

List<String> strList = new ArrayList<>();
strList.add("a");
strList.add("b");
String[] strArry = strList.stream().map(v -> v.toString()).toArray(String[]::new);//strArry为"a","b"
/*String[] strArry1 = strList.stream().map(v -> v.toString()+"-1").toArray(String[]::new);//strArry1为"a-1","b-1"*/

List<String>拼接为一个字符串

使用apache的字符串工具类StringUtils

List<String> strList = new ArrayList<>();
strList.add("a");
strList.add("b");
String strJoin =  StringUtils.join(strList, ",");//用","拼接为一个字符串"a,b"

List<String>转换为List<Integer>

List<String> strList = new ArrayList<>();
        strList.add("11");
        strList.add("12");
List<Integer> strArry = strList.stream().map(v -> Integer.valueOf(v)).collect(Collectors.toList());

List<String>转换为Integer[]数组

List<String> strList = new ArrayList<>();
        strList.add("11");
        strList.add("12");
Integer[] strArry1 = strList.stream().map(v -> Integer.valueOf(v)).toArray(Integer[]::new);

字符串去重

String str = "abeecsabxt";
char[] strChar = str.toCharArray();
LinkedHashSet<Character> link = new LinkedHashSet<>();
StringBuilder buff=new StringBuilder();
for (char ch : strChar) {
   if(!link.contains(ch)){
       link.add(ch);
       buff.append(ch);
   }
}
String resultStr=String.valueOf(buff);
System.out.println(resultStr);//输出：abecsxt

字符串数组去重

String[] strArry =new String[]{"123","abc","74","123"};
//List<String> strArry = new ArrayList<>();//strArry中数据："123","abc","74","123"
List<String> list = new ArrayList<>();
for (String i : strArry) {
   if(!list.contains(i)){
       list.add(i);
    }
}
System.out.println(list);//输出：[123, abc, 74]