String类中的trim()方法实现

String 类中的 trim() 方法的作用是去除字符串前后的空字符串,自己写代码实现了一个 trim() 方法,并不断优化.

代码

public class MyString {
    private String str;

    private char[] chars;

    public MyString(String str) {
        this.str = str;
        this.chars = str.toCharArray();
    }

    /**
     * 先从右往左对空格进行删除
     * 再从右往左对空格进行删除
     * 例: _da_tou_
     * 第一次结果: uot_ad_
     * 第二次结果: da_tou
     *
     * @return
     */
    public String trim1() {
        char[] newChars = new char[str.length()];
        // 1.第一次从右往左删除空格
        int index = 0;
        char[] chars = str.toCharArray();
        boolean preFlag = false;
        for (int i = chars.length - 1; i > -1; i--) {
            if (chars[i] == 0) {
                continue;
            }
            if (!preFlag && ' ' == chars[i]) {
                continue;
            } else {
                preFlag = true;
                newChars[index++] = chars[i];
            }
        }
        // 2.第二次从右往左删除空格
        index = 0;
        char[] newChars2 = new char[newChars.length];
        preFlag = false;
        for (int i = newChars2.length - 1; i > -1; i--) {
            if (newChars[i] == 0) {
                continue;
            }
            if (!preFlag && ' ' == newChars[i]) {
                continue;
            } else {
                preFlag = true;
                newChars2[index++] = newChars[i];
            }
        }

        return new String(newChars2);
    }

    /**
     * 同时从两端开始遍历字符串,并记录结束下标
     *
     * @return
     */
    public String trim2() {
        char[] chars = str.toCharArray();
        int i = 0;
        int j = chars.length - 1;
        boolean preFlag = false;
        boolean suffFlag = false;
        while (i < j && (!preFlag || !suffFlag)) {
            // 从左往右遍历
            if (!preFlag && ' ' == chars[i]) {
                i++;
            } else {
                preFlag = true;
            }

            // 2.从右往左遍历
            if (!suffFlag && ' ' == chars[j]) {
                j--;
            } else {
                suffFlag = true;
            }
        }

        return str.substring(i, j + 1);
    }

    /**
     * 同时从两端开始遍历字符串,并记录结束下标
     * 去掉标志位
     *
     * @return
     */
    public String trim3() {
        int i = 0;
        int j = chars.length - 1;
        // 只需要循环字符串长度一半的次数就能达到目标
        for (int k = 0; k < chars.length / 2 + 1; k++) {
            // 如果需要减少循环次数,可以添加下面的代码
            /*if(' ' != chars[i] && ' ' != chars[j]) {
                break;
            }*/
            // 从左往右遍历
            if (' ' == chars[i]) {
                i++;
            }

            // 2.从右往左遍历
            if (' ' == chars[j]) {
                j--;
            }
        }
        // 如果字符串全部由空字符串组成,会出现 i > j 的情况
        return i > j ? "" : str.substring(i, j + 1);
    }

    /**
     * 同时从两端开始遍历字符串,并记录结束下标
     * 减少循环次数
     *
     * @return
     */
    public String trim4() {
        int i = 0;
        int j = chars.length - 1;
        //
        while (i < j && (' ' == chars[i] || ' ' == chars[j])) {
            // 从左往右遍历
            if (' ' == chars[i]) {
                i++;
            }

            // 2.从右往左遍历
            if (' ' == chars[j]) {
                j--;
            }
        }
        // 如果字符串全部由空字符串组成,会出现 i > j 的情况
        return i < j ? str.substring(i, j + 1) : "";
    }

    /**
     * 先从左到右遍历
     * 再从右到左遍历
     * 最后截取字符串
     * 如果只使用一个 while 循环,循环体里面需要进行判断
     *
     * @return
     */
    public String trim5() {
        int i = 0;
        int j = chars.length;
        while (i < j && ' ' == chars[i]) {
            i++;
        }
        while (j > i + 1 && ' ' == chars[j - 1]) {
            j--;
        }
        return (i > 0 || j < chars.length) ? str.substring(i, j) : str;
    }

    /**
     * String 类中的原生 trim() 方法
     *
     * @return
     */
    public String trim() {
        int len = chars.length;
        int st = 0;
        char[] val = chars;    /* avoid getfield opcode */

        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < chars.length)) ? str.substring(st, len) : str;
    }

}

总结

• 对于 trim() 方法这种删除前后字符串的,通过记录下标比保存中间量要好很多.