了解的几题String算法-JavaSE篇

算法题1：将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”

//方式一：转换为char[]
    public String reverse(String str, int startIndex, int endIndex) {

        if (str != null) {
            char[] arr = str.toCharArray();//String 转char[]数组
            for (int x = startIndex, y = endIndex; x < y; x++, y--) { //x向后y向前 进行数组反转
                char temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
     }

//方式二：string 的拼接 先把数组第一部分startIndex前的元素取出来
//   比如“abcdefg”反转为”abfedcg” 将ab一部分不变取出来 在把第二部分cde反转拼接到第一部分后边 最后把第三部分没反转的fg拼接
    public String reverse1(String str, int startIndex, int endIndex) {

       if(str != null){
           //第一部分将需要反转的数组startIndex前的元素取出来先
           String str1 = str.substring(0,startIndex);
           //第二部分 再把反转后的第二部分拼接到第一部分
           for(int i = endIndex;i >= startIndex ;i--){//倒着取第二部分 终止条件的意思是要取到开始的这个元素e (倒回来后abedcfg)
               //charAt() 返回 char指定索引处的值。
               str1 += str.charAt(i);//取每个字符拼接到第一部分中
           }
           //第三部分
           str1 += str.substring(endIndex + 1);
        return str1;
       }
        return null;
    }

//方法三:使用StringBuffer/StringBuilder替换String
    public String reverse2(String str, int startIndex, int endIndex) {

        if(str != null){
            //此时没有涉及多线程可以使用StringBuilder提高效率
            StringBuilder builder = new StringBuilder(str.length());//造一个在原有数组长度+16的长度


            //第一部分
            builder.append(str.substring(0,startIndex));//与方式二差不多方法 将元素添加到builder中
            //第二部分，反转
            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 = new String("abcdefg");
        String reverse = reverse1(str, 2, 5);
        System.out.println(reverse);//此时成功反转成abedcfg
    }

方式一：调用了toCharArray()的方法让char[]接收。
方式二：看似好像内存省了不少其实并没多大提高效率。
方式三：使用Stringbuilder的方法提高了效率。

算法题2： 获取一个字符串在另一个字符串中出现的次数。
如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

/**
     * 获取subStr在mainStr出现的次数
     * @param mainStr
     * @param subStr
     * @return
     */
    public int getCount(String mainStr,String subStr){

        int mainLength = mainStr.length();
        int subLength = subStr.length();
        int count = 0;//记录出现的次数
        int index = 0;

        //首先需要判断mianStr的长度是否大于等于subStr的长度，如果不大于则没得比
        if(mainLength >= subLength){

            //方式一：
            //indexOf()  返回subStr的字符串在mainStr中出现的索引，如果索引不是-1代表找到
//            while ((index = mainStr.indexOf(subStr)) != -1){
//                count++;
//                //找到了subStr字符串后，截取在出现相同字符后mainStr的子串
//                mainStr = mainStr.substring(index + subLength);
//            }
            //方式二：在原有的字符串中操作
            //返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
            while ((index = mainStr.indexOf(subStr, index)) != -1){//从索引0处开始找
                count++;
                index += subLength;
            }
            return count;
        }else{
            return 0;
        }
    }

    @Test
    public void testGetCount(){

        String mianStr = "abkkcadkabkebfkabkskab";
        String subStr = "ab";

        int count = getCount(mianStr, subStr);
        System.out.println(count);//4
    }

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

    //方法1，前提只有一对最大相同子串
    public String getMaxSameString(String str1, String str2) {

        if (str1 != "null" && str2 != "null") {
            //先判断str1与str2的长度
            String maxStr = (str1.length() >= str2.length()) ? str1 : str2;//返回长度大的str  判断str1长度是否大于str2
            String minStr = (str1.length() < str2.length()) ? str1 : str2;//返回长度短的str 判断str1长度是否小于str2的长度
            int length = minStr.length();
            //外层大轮，去掉的元素不能要小于字符串的长度
            for (int i = 0; i < length; i++) {//每一轮考虑去掉一个字符
                //一大轮去一个字符
                for (int x = 0, y = length - i; y <= length; x++, y++) {//先让x从0开始
                    //返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
                    String subStr = minStr.substring(x, y);//开始是x 结束是y 。第一大轮后返回的是有消去元素的字符串
                    //contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列 时，返回 true
                    if (maxStr.contains(subStr)) {//如果当前maxStr里包含有subStr字符时返回true
                        return subStr;
                    }
                }
            }
        }
        return null;
    }
``

// 方法,如果存在多个长度相同的最大相同子串
    // 此时先返回String[]，后面可以用集合中的ArrayList替换，较方便
    public String[] getMaxSameString1(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;
    }

    @Test
    public void testGetMaxSameString() {
        String str1 = "abcwerthello1yuiodefabcdef";
        String str2 = "cvhello1bnmabcdef";
        String[] maxSameStrings = getMaxSameString1(str1, str2);
        System.out.println(Arrays.toString(maxSameStrings));

    }

String的常用方法如下：
String类常用方法一：

String类常用方法二：

String类常用方法3：

***StringBuffer类的常用方法 ***