字符串part01 + part02 + 字符串知识总结

Java字符串相关基础知识总结

String与基本数据类型、包装类之间的转换

String --> 基本数据类型、包装类：调用包装类的静态方法：Integer.parseXxx(str)
基本数据类型、包装类 --> String: 调用String重载的 String.valueOf(xxx)

String与字符数组之间的转换

String-> char[]： .toCharArray()方法
char[] ->String： 构造方法 new String(char[])

String与StringBuffer、StringBuilder之间的转换

String -->StringBuffer、StringBuilder ： new StringBuffer(str)、new StringBuilder(str)
StringBuffer、StringBuilder -->String： new String()

1.反转字符串

题目链接
利用中间变量temp原地交换即可

class Solution {
    public void reverseString(char[] s) {
        char temp;
        for(int i=0;i<s.length/2;i++){
            temp=s[i];
            s[i]=s[s.length-i-1];
            s[s.length-i-1]=temp;
        }

    }
}

2.反转字符串II

题目链接
这道题目其实也是模拟，实现题目中规定的反转规则就可以了。
为了实现处理逻辑：每隔2k个字符的前k的字符，其实在遍历字符串的过程中， 只要让 i += (2 * k)，i 每次移动 2 * k就可以了，然后判断是否需要有反转的区间。
所以当需要固定规律一段一段去处理字符串的时候，要想想用区间的方法并在for循环的表达式上做做文章。

class Solution {
    public String reverseStr(String s, int k) {
        char[] arr = s.toCharArray();
        for(int i=0; i<s.length(); i+=2*k){
            int start=i;
            int end=Math.min(start+k-1,s.length()-1);
            while(start<end){
                char temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
                start++;
                end--;
            }
        }
        return new String(arr);
    }
}

3.翻转字符串里的单词

题目链接
建议: 这道题目基本把字符串操作都覆盖了，不过就算知道解题思路，本题代码并不容易写，要多练一练。

方法1：创建新字符数组，逆序遍历原字符串进行填充。操作简单，时间复杂度O(n)，空间复杂度: O(n)。
✅ 删除字符串开头和结尾的空格，有两种角度/方式
（1）除了第一个单词外，每个单词前加一个空格。
if(sb.length()!=0) { sb.append(’ '); }
（2）每个单词后加一个空格。循环结束删除最后一个空格。
sb.deleteCharAt(sb.length()-1);

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb=new StringBuilder();
        //逆序遍历整个字符串
        for(int end=s.length()-1;end>=0;end--){
            //找到单词
            if(s.charAt(end)!=' '){
                int start=end;
                while(start>=0 && s.charAt(start)!=' '){
                    start--;
                }
                //不是第一个单词，添加一个空格
                if(sb.length()!=0){
                    sb.append(' ');
                }
                sb.append(s.substring(start+1, end+1));
                end=start;
            }
        }
        return new String(sb);
    }
}

方法2：不创建新字符数组，原地操作。时间复杂度O(n)，空间复杂度: O(1)。
源字符串为："the sky is blue "，分为3步
（1）移除多余空格 : “the sky is blue”
（2）整个字符串反转：“eulb si yks eht”
（3）单个单词反转：“blue is sky the”
✅ 利用快慢指针移除多余空格（参考数组中删除指定元素，由于数组是连续空间，除了删除，涉及到填充的过程）
快指针：指向符合条件的元素（非空格字符）
慢指针：指向可以填充/安置的位置
✅ 相当于 c++ 里的 resize()

    char[] newChars = new char[slow];
    System.arraycopy(chars, 0, newChars, 0, slow); 
    return newChars;

class Solution {
    public String reverseWords(String s) {
        char[] chars = s.toCharArray();
        //1.去除首尾以及中间多余空格
        chars = removeSpace(chars);
        reverse(chars,0,chars.length-1);
        reverseWord(chars);
        return new String(chars);
    }

    //快慢指针移除多余空格
    public char[] removeSpace(char[] chars){
        int slow=0, fast=0;
        while(fast<chars.length){
            //外层遍历单词
            if(chars[fast]!=' '){
                if(slow!=0){
                    //除开头外每个单词前有空格
                    chars[slow]=' ';
                    slow++;
                }
                //遍历一个单词中的字母
                while(fast<chars.length && chars[fast]!=' '){
                    chars[slow]=chars[fast];
                    slow++;
                    fast++;
                }
            }
            fast++;
        }
        //相当于 c++ 里的 resize()
        char[] newChars = new char[slow];
        System.arraycopy(chars, 0, newChars, 0, slow); 
        return newChars;
    }

    //双指针反转子字符串
    public void reverse(char[] chars, int left, int right){
        while(left<right){
            char temp=chars[right];
            chars[right]=chars[left];
            chars[left]=temp;
            left++;
            right--;
        }
    }

    //转置单个单词
    public void reverseWord(char[] chars){
        int start=0, end=0;
        while(end<chars.length){
            if(chars[end]==' '){
                reverse(chars, start, end-1);
                start=end+1;
            }
            else if(end==chars.length-1){
                reverse(chars, start, end);
            }
            end++;
        }
    }
}