2.9、String常用操作方法（重点）
2.9.1、常用方法概述
每个基本类型封装类都有将string转换为基本数据类型的方法
对于非常大的数字请使用Long,代码如下
int age = Integer.parseInt(“10”);
long id = Long.parseLong(“190”); // 假如值可能很大.
将char字符转换为string string Chraracter.toString(char),将char转换为string
将stringBuilder转换为string，stringBuilder.tostring();
string[] string.spilt(“ “);//根据空格符进行分割，返回值是string数组
string string.replaceAll(“a”,”b”);//将a取代成b
int string.indexOf(substr);//返回substr在string中第一个index
string string.subString(fromIndex.endIndex);//返回被截取的字符串
string string.subString(fromIndex);//从第几位开始往后截取
char string.charAt(index);返回第几个字符
一切的前提，谨记string是final类的，不能更改。保存在方法区的常量池中。
用stringBuilder将string相反过来，因为stringBuilder.toReverse()方法，然后再stringBuilder.toReverse().toString()转换为字符串
谨记千万不要采用string1+string2+string3这种引用变量的相加，这种会容易造成内存溢出，常量池内存溢出，因为这是引用变量，在程序运行时才会操作。若想string1这种相加，可以采用字面值相加，如“123”+“abc”+”cbb”,因为这种是编译器会优化，优化成一个string。或者采用，stringBuilder的append(string)方法，将一个stringB附加到主stringBuilder后面。
2.9.2、String操作方法
默认会生成一个新的String保存在常量池中，不会改变原来常量池中的String。因为常量池，string是final的，一经创建无法改变。
String str = "abcde";
str.toUpperCase();
System.out.println(str);
//输出还是abcde,而非ABCDE。因为string是final的，string的改变内容的操作方法会生成一个新的string在常量池中。
2.9.3、引用变量指向常量池中的新的str
String str = "abcde";
str = str.toUpperCase();
System.out.println(str);
//常量池中新生成一个string，以前的引用变量指向新地址
2.9.4、字符串反转
用string缓存类，StringBuffer或者stringBuilder. 因为String缓存类，预先在堆内存中开辟一个16字符的存储空间，借以不断改变String的值
String str = "abcde";
StringBuilder stringBuilder = new StringBuilder(str);
stringBuilder.reverse();
str = stringBuilder.toString();
System.out.println(str);//输出edcba
StringBuilder是在堆内存开辟一个存储空间，对stringBuilder的修改全是在修改stringBuilder对象内存本身。
2.9.5、判断字符串是否对称
String str = "abcde";
StringBuilder stringBuilder = new StringBuilder(str);
String str2 = stringBuilder.reverse().toString();
System.out.println(str.equal(str2));
2.9.6、输出字符串的子串
比如String str = “@abc efg . ghk”;
String[] strArray = String.split(“byChar”);
String.split(“byChar”)方法
要求输出abc efg ghk
String str = "ab@cd ghk efg";
str = str.replaceAll("@", " ");
String[] strArray = str.split(" ");
for(String str1:strArray)
{
System.out.println(str1);
}
2.9.7、字符串反转
“To be or not to be”，将变成”oT eb ro ton ot eb.”
public static void main(String[] args) {
String s = "To be or not to be";
String ss[] = s.split(" ");
StringBuffer sb2 = new StringBuffer();
for (int i = 0; i < ss.length; i++) {
StringBuffer sb = new StringBuffer(ss[i]);
sb.reverse();
sb2.append(sb);
if(i == ss.length-1){
sb2.append(".");
}else{
sb2.append(" ");
}
}
System.out.println(sb2);
}
2.9.8、字符串拆分
String s=”name=zhangsan age=18 classNo=090728”;
将上面的字符串拆分，结果如下:
zhangsan 18 090728
public static void main(String[] args) {
String s="name=zhangsan age=18 classNo=090728";
String[] ss = s.split(" ");
StringBuffer sb =new StringBuffer();
for (int i = 0; i < ss.length; i++) {
String[] ss2 =ss[i].split("=");
sb.append(ss2[1]);
sb.append(" ");
}
System.out.println(sb);
}
2.9.9、判断一个字符串是否包含另一个字符串
给定一个字符串,判断该字符串中是否包含某个子串.如果包含,求出子串的所有出现位置。
如:”abcbcbabcb34bcbd”中,”bcb”子串的出现位置为: 1,7,12.字符串和子串均由用户输入
String str = "abcdefghkabcdefdef";
String subStr = "def";
AppMain appMain = new AppMain();
appMain.calculateSubStrIndexFromString(str,subStr,0);
}
public void calculateSubStrIndexFromString(String string,String subStr,int startIndexFirst) {
int startIndex = startIndexFirst;
int existingIndex = string.indexOf(subStr, startIndex);
while(existingIndex != -1)
{
System.out.println("存在的index为： "+existingIndex);
calculateSubStrIndexFromString(string,subStr,existingIndex+subStr.length());
break;
}
}
2.9.10、总结
字符串的常见操作无非几种
- 字符串反转 用stringBuilder.reverse();
- 字符串切割String[] strArray = str.spilt(“spiltChar”);
- 字符串拼接 用stringBuilder.append(“str”);
2.9.11、有关String常见操作的范例
/*
* 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
* {"nba","abc","cba","zz","qq","haha"}
*
* 思路：
* 1,对数组排序。可以用选择，冒泡都行。
* 2,for嵌套和比较以及换位。
* 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。
* 字符串对象怎么比较呢？爽了，对象中提供了用于字符串对象比较的功能。
*
*
*/
public class StringTest_1 {
/**
* @param args
*/
public static void main(String[] args) {
String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
printArray(arr);
sortString(arr);
printArray(arr);
}
public static void sortString(String[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if(arr[i].compareTo(arr[j])>0)//字符串比较用compareTo方法
swap(arr,i,j);
}
}
}
private static void swap(String[] arr, int i, int j) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(String[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
System.out.print(arr[i] + ", ");
else
System.out.println(arr[i] + "]");
}
}
}
/*
* 2，一个子串在整串中出现的次数。
* "nbaernbatynbauinbaopnba"
* 思路：
* 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。
* 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，
* 而剩余字符串的起始位是出现位置+子串的长度.
* 3,以此类推，通过循环完成查找，如果找不到就是-1，并对 每次找到用计数器记录。
*
*/
public class StringTest_2 {
/**
* @param args
*/
public static void main(String[] args) {
String str = "nbaernbatnbaynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount_2(str,key);
System.out.println("count="+count);
}
public static int getKeyStringCount_2(String str, String key) {
int count = 0;
int index = 0;
while((index = str.indexOf(key,index))!=-1){
index = index + key.length();
count++;
}
return count;
}
/**
* 获取子串在整串中出现的次数。
* @param str
* @param key
* @return
*/
public static int getKeyStringCount(String str, String key) {
//1,定义计数器。
int count = 0;
//2，定义变量记录key出现的位置。
int index = 0;
while((index = str.indexOf(key))!=-1){
str = str.substring(index+key.length());
count++;
}
return count;
}
}
/*
* 3，两个字符串中最大相同的子串。
* "qwerabcdtyuiop"
* "xcabcdvbn"
*
* 思路：
* 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。
* 如果存在，短的那个字符串就是最大子串。
* 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。
* 如果存在就已找到，就不用在找了。
*
*
*/
public class StringTest_3 {
/**
* @param args
*/
public static void main(String[] args) {
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s2, s1);
System.out.println("s=" + s);
}
/**
* 获取最大子串
*
* @param s1
* @param s2
* @return
*/
public static String getMaxSubstring(String s1, String s2) {
String max = null,min = null;
max = (s1.length()>s2.length())?s1:s2;
min = max.equals(s1)?s2:s1;
System.out.println("max="+max);
System.out.println("min="+min);
for (int i = 0; i < min.length(); i++) {
for(int a = 0,b = min.length()-i; b != min.length()+1; a++,b++){
String sub = min.substring(a, b);
// System.out.println(sub);
if(max.contains(sub))
return sub;
}
}
return null;
}
}
/*
* 4，模拟一个trim功能一致的方法。去除字符串两端的空白
* 思路：
* 1，定义两个变量。
* 一个变量作为从头开始判断字符串空格的角标。不断++。
* 一个变量作为从尾开始判断字符串空格的角标。不断--。
* 2,判断到不是空格为止，取头尾之间的字符串即可。
*/
public class StringTest_4 {
/**
* @param args
*/
public static void main(String[] args) {
String s = " ab c ";
s = myTrim(s);
System.out.println("-" + s + "-");
}
public static String myTrim(String s) {
int start = 0, end = s.length() - 1;
while (start <= end && s.charAt(start) == ' ') {
start++;
}
while (start <= end && s.charAt(end) == ' ') {
end--;
}
return s.substring(start, end + 1);
}
}
转载请注明来源
