String类的练习题
String类的练习题：包括：模拟一个 个trim方法，去除字符串两端的空格；反转字符串，可指定反转字符串指定部分；获取一个字符串在另一个字符串中出现的次数；获取两个字符串中最大相同子串；对字符串中的字符进行自然顺序排序
String类的练习题：包括：模拟一个 个trim方法，去除字符串两端的空格；反转字符串，可指定反转字符串指定部分；获取一个字符串在另一个字符串中出现的次数；获取两个字符串中最大相同子串；对字符串中的字符进行自然顺序排序。
目录：
思路比代码重要，解题思路不止一种，下面仅为个人练习，若有错误，欢迎评论指出。
练习题一：
☃ 模拟一个 个trim方法，去除字符串两端的空格；如:" --中国的 HangKong "➠"--中国的 HangKong"
☄ 思路一：获取字符串的前m个空格数和末尾的n个空格数，调用string.substring(int start,int end)截取字符串 start = m,end = str.length()-n
☄ 思路二：将字符串str转为字符数组value[],顺序for循环value[]数组并标记第一个出现的非空字符为第m个，逆序for循环value[]数组并标记第一个出现的非空字符位第n个调用new String(int offset,int count)新建一个字符串返回，offset = m ；count=length-m-n
代码实现：
public String trimMethod(String str){
/*方法一*/
int startCount = 0,endCount = 0;
String startN = "",endN = "";
//判断前空格数
while (true){
startN += " ";
if (!str.startsWith(startN)){
break;
}
startCount++;
}
//判断后空格数
while (true){
endN += " ";
if (!str.endsWith(endN)){
break;
}
endCount++;
}
//如果前空格数等于后空格数，要么字符串为""要门为多个空格
if(startCount == endCount){
return "";
}else {
System.out.println("方法一：" + str + "的前空格数："+startCount+ "，后空格数:"+endCount);
//调用substring(int start,int end)截取字符串
String result = str.substring(startCount,str.length()-endCount);
System.out.println(result);
System.out.println("---------------------------");
// return result;
}
/*方法二*/
char value[] = str.toCharArray();
int sc = 0,ec = 0;
for (int i = 0; i < value.length; i++) {
if(value[i] == ' '){
sc++;
}else{
break;
}
}
for (int i = value.length-1; i >= 0; i--) {
if(value[i] == ' '){
ec++;
}else{
break;
}
}
System.out.println("方法二：" + str + "的前空格数："+ sc+ "，后空格数:"+ec);
String rs = new String(value,sc,value.length-sc-ec);
System.out.println(rs);
System.out.println("---------------------------");
return rs;
}
实现效果：
练习题二：
☃ 反转指定部分字符串；如：I love uoy for every反转uoy结果为I love you for every
☄ 思路：截取[start,end)的字符串，将字符串转为字符数组，反转该数组后转为字符串rStr，结果为截取[0,start)字符串+反转后的rStr字符串+截取[end,length)的字符串
调用的方法有，截取字符串substring(int start,int end) [start,end)
字符串转为字符数组：string.toCharArray()
字符数组转为字符串：new String(char value)
代码实现：
public String reversString(String str,int start,int end){
if(str != null){
start -= 1;
String reStr = str.substring(start,end);
char subChar[] = reStr.toCharArray();
char reChar[] = new char[subChar.length];
for (int i = 0; i < reStr.length(); i++) {
reChar[reStr.length()-i-1] = subChar[i];
}
String result = str.substring(0,start) + new String(reChar) + str.substring(end,str.length());
System.out.println(str + "反转" + "第" + (start+1) + "位到第" + end + "位结果：" + result);
return result;
}
return null;
}
实现效果：
练习题三：
☃ 获取一个字符串在另一个字符串中出现的次数 如：获取“ ab”在“abkkcadkabkebfkabkskab”中出现的次数
☄ 思路：将比较的字符串cStr与被比较的字符串oStr转为字符数组，定义一个index监控当前cStr在oStr比较的位置，定义一个count计数统计次数
代码实现：
public int getStrCountInOriginString(String origin,String str){
if (str.length() < origin.length()) {
char sChar[] = str.toCharArray();
char oChar[] = origin.toCharArray();
int count = 0;
int index = 0;
while (index < oChar.length) {
int sIndex = 0;
for (int i = 0; i < sChar.length; i++) {
if (sChar[i] == oChar[index]) {
index++;
sIndex++;
} else {
index++;
break;
}
}
if (sIndex == sChar.length) {
count++;
} else {
index -= sIndex;
}
/* 未考虑str前面部分匹配后面不匹配，导致下次对比跳过了这部分内容，如ab--aabbabab
a-a;b-a;-->a-b-->a-bx-->a-a;b-b;(v)-->a-a;b-b(v)这里只会匹配到两次，忽略了第2个字符的比较机会，
在部分字符匹配的情况下应当回退到上次未匹配字符的下一个字符开始
boolean flag = true;
for (int i = 0; i < sChar.length; i++) {
if (sChar[i] != oChar[index]) {
flag = false;
index++;
break;
}else {
index++;
}
}
if (flag){
count++;
}*/
}
return count;
}else {
return 0;
}
}
实现效果：
练习题四：
☃ 获取两个字符串中最大相同子串。比如：abcwehhelloortworldyuiodhellof和cvhellobnhellomheworld中找到2个最大子串：[hello, world]
☄ 思路：将短的那个串进行长度依次递减的子串与较长的串比较
代码实现：
public String[] getSameSubstring(String str1,String str2){
//区分传入的两个字符串谁比较短
String minStr = (str1.length()<str2.length())?str1:str2;
//注意minStr与maxStr使用三目运算符时要错开比较，避免str1和str长度相同时minStr和maxStr指向了同一个变量
String maxStr = (str2.length()>str1.length())?str2:str1;
//传入""字符串返回""并退出
if (minStr.length()==0){
return null;
}
//当最大相同字串为一个字符时，返回的字符串数组的大小最大为minStr.length()
String str[] = new String[minStr.length()];
int count = 0; //计数器，统计有多少个最大字串
for (int y = minStr.length(); y>=0;y--) { //逆序，y是minStr右端下标，依次缩短一个字符
if (count!=0){break;} //上一次循环匹配到最大子串，退出循环
for (int i = 0; i < minStr.length()-y+1; i++) { //当子串长度为y时，需要与maxStr比较minStr.length()-y+1次
String s1 = minStr.substring(i,y+i); //截取minStr上对应长度的子串s1
if(maxStr.contains(s1)){ //判断s1是否包含在maxStr字符串上，如果是添加到str[]数组中
str[count++] = s1;
}
}
}
//此时已经获取到最大子串，但是str[]数组中存在空元素，去掉空元素和重复的元素
String rStrs[] = new String[count];
int rc = 0;
for (int i = 0; i < count; i++) {
boolean flag = true; //用于标记当前元素是否与后面的元素重复
for (int j = i+1; j < count; j++) {
if (str[i].equals(str[j])){ //不能用==判断
flag = false;
break;
}
}
if (flag){
//无重复元素，添加到rStr[]数组中，rc标记++
rStrs[rc++] = str[i];
}
}
//创建value[]数组，保存最终结果，去掉rStrs[]中的空元素
String value[] = new String[rc];
for (int i = 0; i < rc; i++) {
value[i] = rStrs[i];
}
return value;
}
实现效果：
练习题五：
☃ 对字符串中字符进行自然顺序排序； 如："gAeg21Fjew(&o539我giJoe736我国&("排序后为"&&((12335679AFJeeegggijoow国我我"
☄ 思路：
1）字符串变成字符数组。
2）对数组排序，选择，冒泡，Arrays.sort(); （字符对应的有Ascii值比较大小）
3）将排序后的数组变成字符串。
代码实现：
public String sortString(String str){
char value[] = str.toCharArray();
//方法一：调用Arrays.sort()方法快速排序
//Arrays.sort(value);
//方法二：选择排序
/*for (int i = 0; i < value.length; i++) {
for (int j = i+1; j < value.length; j++) {
if(value[i] > value[j]){
char temp = value[j];
value[j] = value[i];
value[i] = temp;
}
}
}*/
//方法三：冒泡排序
for (int i = 0; i < value.length-1; i++) {
for (int j = 0; j < value.length-i-1; j++) {
if (value[j]>value[j+1]){
char temp = value[j];
value[j] = value[j+1];
value[j+1] = temp;
}
}
}
String result = new String(value);
return result;
}
实现效果：
其他实现方式：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
/*
* 1.模拟一个trim方法，去除字符串两端的空格。
*
* 2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
*
* 3.获取一个字符串在另一个字符串中出现的次数。
比如：获取“ab”在 “cdabkkcadkabkebfkabkskab”
中出现的次数
4.获取两个字符串中最大相同子串。比如：
str1 = "abcwerthelloyuiodef“;str2 = "cvhellobnm"//10
提示：将短的那个串进行长度依次递减的子串与较长
的串比较。
5.对字符串中字符进行自然顺序排序。"abcwerthelloyuiodef"
提示：
1）字符串变成字符数组。
2）对数组排序，选择，冒泡，Arrays.sort(str.toCharArray());
3）将排序后的数组变成字符串。
*/
public class StringExer {
// 第1题
public String myTrim(String str) {
if (str != null) {
int start = 0;// 用于记录从前往后首次索引位置不是空格的位置的索引
int end = str.length() - 1;// 用于记录从后往前首次索引位置不是空格的位置的索引
while (start < end && str.charAt(start) == ' ') {
start++;
}
while (start < end && str.charAt(end) == ' ') {
end--;
}
if (str.charAt(start) == ' ') {
return "";
}
return str.substring(start, end + 1);
}
return null;
}
// 第2题
// 方式一：
public String reverse1(String str, int start, int end) {// start:2,end:5
if (str != null) {
// 1.
char[] charArray = str.toCharArray();
// 2.
for (int i = start, j = end; i < j; i++, j--) {
char temp = charArray[i];
charArray[i] = charArray[j];
charArray[j] = temp;
}
// 3.
return new String(charArray);
}
return null;
}
// 方式二：
public String reverse2(String str, int start, int end) {
// 1.
String newStr = str.substring(0, start);// ab
// 2.
for (int i = end; i >= start; i--) {
newStr += str.charAt(i);
} // abfedc
// 3.
newStr += str.substring(end + 1);
return newStr;
}
// 方式三：推荐 （相较于方式二做的改进）
public String reverse3(String str, int start, int end) {// ArrayList list = new ArrayList(80);
// 1.
StringBuffer s = new StringBuffer(str.length());
// 2.
s.append(str.substring(0, start));// ab
// 3.
for (int i = end; i >= start; i--) {
s.append(str.charAt(i));
}
// 4.
s.append(str.substring(end + 1));
// 5.
return s.toString();
}
@Test
public void testReverse() {
String str = "abcdefg";
String str1 = reverse3(str, 2, 5);
System.out.println(str1);// abfedcg
}
// 第3题
// 判断str2在str1中出现的次数
public int getCount(String mainStr, String subStr) {
if (mainStr.length() >= subStr.length()) {
int count = 0;
int index = 0;
// while((index = mainStr.indexOf(subStr)) != -1){
// count++;
// mainStr = mainStr.substring(index + subStr.length());
// }
// 改进：
while ((index = mainStr.indexOf(subStr, index)) != -1) {
index += subStr.length();
count++;
}
return count;
} else {
return 0;
}
}
@Test
public void testGetCount() {
String str1 = "cdabkkcadkabkebfkabkskab";
String str2 = "ab";
int count = getCount(str1, str2);
System.out.println(count);
}
@Test
public void testMyTrim() {
String str = " a ";
// str = " ";
String newStr = myTrim(str);
System.out.println("---" + newStr + "---");
}
// 第4题
// 如果只存在一个最大长度的相同子串
public String getMaxSameSubString(String str1, String str2) {
if (str1 != null && str2 != null) {
String maxStr = (str1.length() > str2.length()) ? str1 : str2;
String minStr = (str1.length() > str2.length()) ? str2 : str1;
int len = minStr.length();
for (int i = 0; i < len; i++) {// 0 1 2 3 4 此层循环决定要去几个字符
for (int x = 0, y = len - i; y <= len; x++, y++) {
if (maxStr.contains(minStr.substring(x, y))) {
return minStr.substring(x, y);
}
}
}
}
return null;
}
// 如果存在多个长度相同的最大相同子串
// 此时先返回String[]，后面可以用集合中的ArrayList替换，较方便
public String[] getMaxSameSubString1(String str1, String str2) {
if (str1 != null && str2 != null) {
StringBuffer sBuffer = new StringBuffer();
String maxString = (str1.length() > str2.length()) ? str1 : str2;
String minString = (str1.length() > str2.length()) ? str2 : str1;
int len = minString.length();
for (int i = 0; i < len; i++) {
for (int x = 0, y = len - i; y <= len; x++, y++) {
String subString = minString.substring(x, y);
if (maxString.contains(subString)) {
sBuffer.append(subString + ",");
}
}
System.out.println(sBuffer);
if (sBuffer.length() != 0) {
break;
}
}
String[] split = sBuffer.toString().replaceAll(",$", "").split("\\,");
return split;
}
return null;
}
// 如果存在多个长度相同的最大相同子串：使用ArrayList
// public List<String> getMaxSameSubString1(String str1, String str2) {
// if (str1 != null && str2 != null) {
// List<String> list = new ArrayList<String>();
// String maxString = (str1.length() > str2.length()) ? str1 : str2;
// String minString = (str1.length() > str2.length()) ? str2 : str1;
//
// int len = minString.length();
// for (int i = 0; i < len; i++) {
// for (int x = 0, y = len - i; y <= len; x++, y++) {
// String subString = minString.substring(x, y);
// if (maxString.contains(subString)) {
// list.add(subString);
// }
// }
// if (list.size() != 0) {
// break;
// }
// }
// return list;
// }
//
// return null;
// }
@Test
public void testGetMaxSameSubString() {
String str1 = "abcwerthelloyuiodef";
String str2 = "cvhellobnmiodef";
String[] strs = getMaxSameSubString1(str1, str2);
System.out.println(Arrays.toString(strs));
}
// 第5题
@Test
public void testSort() {
String str = "abcwerthelloyuiodef";
char[] arr = str.toCharArray();
Arrays.sort(arr);
String newStr = new String(arr);
System.out.println(newStr);
}
}
String类的常用方法↷传送门
本博客与CSDN博客༺ཌ༈君☠纤༈ད༻同步发布
梦想是一场华美的旅途，每个人在找到它之前，都只是孤独的少年。
