常见算法题目 String类的常见方法练习

1. 模拟一个trim方法，去除字符串两端的空格。

public class StringTest5 {
    public static void main(String[] args) {
        String a = "  java BC  ";
        System.out.println("未去除两端空格："+a +"!");
        System.out.println("去除两端空格后："+a.trim()+"!");
    }
}

结果：

未去除两端空格：  java BC  !
去除两端空格后：java BC!

2. 将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”

方法一：

public class StringTest5 {
    public static void main(String[] args) {
        String str = "abcdefg";
        String reverse2 = reverse(str,2,5);
        System.out.println(reverse2);  //---->abfedcg
    }
    public static String reverse(String str, int start, int end){
        if(str != null){//不为空的情况下再进行反转，否则返回null
            char[] array = str.toCharArray();
            //交换两个字符的值达到反转的目的
            for(int i = start,j = end; i < j;i++,j--){
                char temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
            return new String(array);//通过String构造器，将数组型array转成String类型
        }
        return null;//str为空返回null
    }
}

方法二：使用String的拼接

public class StringTest5 {
      @Test
        public void test(){String str = "abcdefg";
          String reverse2 = reverse1(str,2,5);
          System.out.println(reverse2);  //---->abfedcg
      }      
    //方式二：使用String的拼接
    public String reverse1(String str,int startIndex,int endIndex){
       if (str!=null) {
           //第一部分：
           String reverseStr = str.substring(0, startIndex);
           //第二部分
           for (int i = endIndex; i >= startIndex; i--) {
               reverseStr += str.charAt(i);
           }
           //第三部分
           reverseStr += str.substring(endIndex + 1);
           return reverseStr;
       }
       return null;
    }
}

方法三：StringBuffer 的反转方法

public class StringTest5 {
    public static void main(String[] args) {
        StringBuffer stu = new StringBuffer("abcdefg");
        String str1 = stu.substring(0, 2);
        System.out.println(str1);

        String str3 = stu.substring(6, 7);
        System.out.println(str3);

        stu.reverse();
        String str2 = stu.substring(1, 5);
        System.out.println(str2);

        System.out.println("结果：" + str1 + str2 + str3); //abfedcg
    }
}

方式四：StringBuilder

public class StringTest5 {
    public String reverse1(String str,int startIndex,int endIndex) {
        StringBuilder builder = new StringBuilder(str.length());
        if (str != null) {
            //  第一部分：
            builder.append(str.substring(0, startIndex));
            //第二部分
            for (int i = endIndex; i >= startIndex; i--) {
                builder.append(str.charAt(i));
            }
            //第三部分
            builder.append(str.substring(endIndex + 1));
            return builder.toString();
        }
        return null;
    }

    @Test
        public void test(){String str = "abcdefg";
          String reverse2 = reverse1(str,2,5);
          System.out.println(reverse2);  //---->abfedcg
      }

3. 获取一个字符串在另一个字符串中出现的次数。比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

public class StringTest5 {
    public static void main(String[] args) {
        String str1 ="abkkcadkabkebfkabkskab";
        String str2 ="ab";
        int total = total(str1,str2);
        System.out.println(total);
    }
    public static int total(String str1,String str2){//str2为子字符串即题目中的"ab" ,str1为“abkkcadkabkebfkabkskab”
        int total = 0;
        for (;;){
            int i = str1.indexOf(str2);
            if (i == -1){
                break;
            }
            str1 = str1.substring(i+str2.length());
            total++;
        }
        return total;
    }
}

返回4；

4.获取两个字符串中最大相同子串。比如：str1 = "abcwerthelloyuiodef“;str2 = "cvhellobnm"提示：将短的那个串进行长度依次递减的子串与较长的串比较。

public class StringTest5 {
    public static void main(String[] args) {

        String str1 = "abcwerthelloyuioabdef";
        String str2 = "cvhellobnmabdef";
        //造一个当前类的对象
        StringTest5 mss = new StringTest5();
        String[] maxSameString = mss.getMaxSameString1(str1, str2);
        System.out.println(Arrays.toString(maxSameString));

    }

    //两个字符串中，存在多个长度相同的最大子串：
    //在这里采用的是返回String[];其实也可以通过集合中的ArrayList，较方便
    public String[] getMaxSameString1(String str1, String str2) {
        //不加这个判断的话，如果str1或者str2有一个为null，下边会出现空指针的异常
        if (str1 != null && str2 != null) {
            //用StringBuffer的对象来存储，因为StringBuffer的大小也是可以变的(可扩容)
            StringBuffer sBuffer = new StringBuffer();
            // 先找出哪个串比较短
            String maxString = (str1.length() >= str2.length()) ? str1 : str2;
            String minString = (str1.length() < str2.length()) ? str1 : str2;

            // 需要两层for循环来实现
            /*
             * 将短的那个串，进行长度依次递减的字串与较长的字串进行比较 外层循环控制的是：一共可以length-1进行多少次（第一次不进行-1，直接比较）
             */
            for (int i = 0; i < minString.length(); i++) {
                for (int start = 0, end = minString.length() - i; end <= minString.length(); start++, end++) {
                    // 因为length-1 可能是从左侧划掉一个char，也可能是从右侧。
                    // 并且，minstring与循环的控制条件有关，所以不应该将对于短的字符串的修改保留在minstring上
                    String subString = minString.substring(start, end);
                    if (maxString.contains(subString)) {
                        /*
                         * 如果maxstring中包含当前的修改	过后的minstring（也就是substring），
                         * 由于minstring是从大到小（串的长度是依次递减的）的范围找，
                         * 那么，此时得到的就是str1、str2的最大子串
                         */
                        sBuffer.append(subString + ",");
                    }
                }
//				System.out.println(sBuffer);
                //已经找到最大子串了，跳出外层循环----再往下找，找出来的长度会比真正的最大子串 小
                if (sBuffer.length() != 0) {
                    break;
                }
            }
            /*
             * 运用正则：
             * replaceAll(",$","")----去掉结尾的','
             * split("\\,")----以','作为一个切割
             */
            String[] split = sBuffer.toString().replaceAll(",$", "").split("\\,");
            return split;
        }
        return null;
    }
}

[hello, abdef]

5.对字符串中字符进行自然顺序排序。

提示：
1）字符串变成字符数组。
2）对数组排序，选择，冒泡，Arrays.sort();
3）将排序后的数组变成字符串。

public class StringTest5 {
    public static void main(String[] args) {
        String str = "143683450980967";
        String s = sort(str);
        System.out.println(s);

    }

    private static String sort(String str) {
        //把字符串转化成字符数组
        char[] chs = stringToCharArray(str);

        //对字符数组进行排序
        charSort(chs);

        //把字符数组转化成字符串
        String s = new String(chs);

        return s;
    }

    private static void charSort(char[] chs) {
        Arrays.sort(chs);
    }

    private static char[] stringToCharArray(String str) {
        return str.toCharArray();
    }
}

001334456678899