String算法考察小练习（康师傅较优解法）

package day2_9;

import java.util.Arrays;

/**
 * @Author Tianhao
 * @create 2021-02-09-15:05
 */
public class StringExer {



    //实现和trim()一样的作用，去掉收尾空格
    public String myTrim(String str) {

        int start = 0;
        int end = 0;
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (!String.valueOf(chars[i]).equals(" ")) {
                start = i;
                break;
            }
        }
        for (int i = chars.length -1; i >= 0; i--) {
            if (!String.valueOf(chars[i]).equals(" ")) {
                end = i;
                break;
            }
        }
        return str.substring(start, end + 1);
    }


    //实现数组的反转，将字符串中指定部分进行反转
    //比如“abcdefg",将其中的cdef反转后，输出为abfedcg
    //方式一： 两个数组的元素赋值
//    public String myReverse(String src,int start, int end) {
//        if (src!=null) {
//            String substring = src.substring(start, end+1);
//            char[] chars = substring.toCharArray();
//            int len = chars.length;
//            char[] newChars = new char[len];
//            for (int i = 0,j=len-1; i < len; i++,j--) {
//                newChars[j] = chars[i];
//            }
//            String newS = new String(newChars);
//            return src.substring(0,start)+ newS + src.substring(end+1);
//        }
//        return null;
//    }



    //方式二: 数组内元素的对调
//    public String myReverse(String src,int start, int end) {
//        if (src!=null) {
//            char[] chars = src.toCharArray();
//            char tmp;
//            for (int i = start, j = end; i < j; i++, j--) {
//                tmp = chars[i];
//                chars[i] = chars[j];
//                chars[j] = tmp;
//            }
//            return new String(chars);
//        }
//        return null;
//    }

    //方式三 拼接
//    public String myReverse(String src,int start, int end) {
//        if (src!=null) {
//            //第一部分
//            String target = src.substring(0, start);
//            //第二部分
//            for (int i = end; i >= start ; i--) {
//                target += src.charAt(i);
//            }
//            //第三部分
//            target += src.substring(end + 1);
//            return target;
//        }
//        return null;
//    }

    //方式三 使用StringBuffer/StringBuilder 替换String
    public String myReverse(String src, int start, int end) {
        if (src!=null) {
            //注意选择适合的构造器（考虑到src字符串长度可能超过16）
            StringBuilder builder = new StringBuilder(src.length());
            builder.append(src.substring(0, start));
            for (int i = end; i >= start ; i--) {
                builder.append(src.charAt(i));
            }
            builder.append(src.substring(end + 1));

            return new String(builder);
        }
        return null;
    }



    //获取一个字符串在另一个字符串中出现的次数
    //方式一
//    public int myContainsCount(String src,String target) {
//        int srcLen = src.length();
//        int targetLen = target.length();
//        int count = 0;
//        int index;
//        if (srcLen>=targetLen) {
//            for (; ; ) {
//                index = src.indexOf(target);
//                if (index == -1) {
//                    break;
//                }
//                count++;
//                src = src.substring(index+targetLen);
//            }
//
//            return count;
//        }
//        return 0;
//    }

    //获取一个字符串在另一个字符串中出现的次数
    //方式一
    public int myContainsCount(String src, String target) {
        int srcLen = src.length();
        int targetLen = target.length();
        int count = 0;
        int index = 0;
        if (srcLen>=targetLen) {
            //关键方法indexOf(String target,int index)
            //从自定索引开始查询目标字符串出现的索引位置
            while ((index = src.indexOf(target,index) )!= -1) {
                count++;
                index += targetLen;
            }
            return count;
        }
        return 0;
    }


    //获取两个字符串中最大相同子串
    //第一种方式
//    public String myLongSubstring(String one, String two) {
//        if (one != null && two != null) {
//            //max 长的字符串，min 短的字符串
//            String max;
//            String min;
//            if (one.length() >= two.length()) {
//                max = one;
//                min = two;
//            } else {
//                max = two;
//                min = one;
//            }
//            String sub;
//            String targetSub = "没有相同的子串";
//            int subLen = 0;
//            int index;
//            for (int i = 0; i < min.length(); i++) {
//                for (int j = min.length(); j > i; j--) {
//                    sub = min.substring(i, j);
//                    index = max.indexOf(sub);
//                    if (index != -1) {
//                        if (subLen < sub.length()) {
//                            targetSub = sub;
//                            subLen = sub.length();
//                        }
//                    }
//                }
//            }
//            return targetSub;
//        }
//        return null;
//    }

    //获取两个字符串中最大相同子串
    //第二种方式：
    public String myLongSubstring(String one, String two) {
        if (one != null && two != null) {
            //找出较长串和较短串
            String max = (one.length() >= two.length()) ? one : two;
            String min = (one.length() < two.length()) ? one : two;
            int length = min.length();
            for (int i = 0; i < length; i++) {
                //较短串的子串逐渐减短，看较长串是否包含
                for (int j = 0,k=length-i; k <= length; j++,k++) {
                    String sub = min.substring(j, k);
                    if (max.contains(sub)) {
                        return sub;
                    }
                }
            }
        }
        return null;
    }


    //拓展：获取两个字符串中最大相同子串并且是满足要求的所有最大相同子串
    public String[] myAllLongSubstring(String one, String two) {
        if (one != null && two != null) {
            StringBuilder builder = new StringBuilder();
            //找出较长串和较短串
            String max = (one.length() >= two.length()) ? one : two;
            String min = (one.length() < two.length()) ? one : two;
            int length = min.length();
            for (int i = 0; i < length; i++) {
                //较短串的子串逐渐减短，看较长串是否包含
                for (int j = 0,k=length-i; k <= length; j++,k++) {
                    String sub = min.substring(j, k);
                    if (max.contains(sub)) {
                        builder.append(sub + ",");
                    }
                }

                if (builder.length() != 0) {
                    break;
                }
            }
            //将最后一个,更换为"",以,切分为String[]
            return builder.toString().replaceAll(",$","")
                    .split("\\,");
        }
        return null;
    }

    //对字符串中字符进行自然顺序排序
    public String mySort(String str) {
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        String newStr = new String(chars);
        return newStr;
    }

}

测试

package day2_9;

import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.Arrays;

import static org.junit.Assert.*;

/**
 * @Author Tianhao
 * @create 2021-02-09-15:12
 */

public class StringExerTest {
    StringExer stringExer = new StringExer();

    @Test
    public void myTrim() {
        String s = stringExer.myTrim("  wang tian  ");
        System.out.println(s);
    }

    @Test
    public void myReverse() {
        String s = stringExer.myReverse("abcdefg", 2,5);
        System.out.println(s);
    }

    @Test
    public void myContainsCount() {
        int count = stringExer.myContainsCount("xiaoqiang and xiaohong", "ng");
        System.out.println(count);

    }


    @Test
    public void myLongSubstring() {
        String target = stringExer.myLongSubstring("xiaoqiang and xiaohong", "hong is female,qiang is male.");
        System.out.println(target);

    }

    @Test
    public void myAllLongSubstring() {
        String[] target = stringExer.myAllLongSubstring("xiaoming and xiaohong", "hongis female,mingis male.");
        System.out.println(Arrays.toString(target));

    }

    @Test
    public void mySort() {
        String str = stringExer.mySort("yienhaodlcjkf");
        System.out.println(str);
    }


    //补充知识点
    @Test
    public void test() {
        String s = "wang tian";
        char[] chars = s.toCharArray();
        //数组工具类Arrays的复制方法copyOf(xx[],newLength)
        char[] chars1 = Arrays.copyOf(chars, chars.length-3);
        System.out.println(Arrays.toString(chars));
        System.out.println(Arrays.toString(chars1));


        //基本数据类型与String的转换
        //第一种方式：String.valueOf(xxx)
        int i = 1;
        System.out.println(String.valueOf(i));
        char c = 'w';
        System.out.println(String.valueOf(c));

        //第二种方式：基本数据对应的包装类.toString()
        //下面其实也是String.valueOf(int)的内部实现
        System.out.println(Integer.toString(i));

        //对于char型，有第三种方式：
        //下面是valueOf(char)的内部实现
        char[] charArr = {c};
        String s1 = new String(charArr);
        System.out.println(s1);



    }
}