力扣-字符串

字符串不能被修改，所以如果有想修改字符串的行为，需要转换为StringBuilder

StringBuilder里也有很多封装方法String没有，比如reverse()

StringBuilder sb = new StringBuilder();

// 添加字符串
sb.append("Hello");
sb.append(", ");
sb.append("World!");

// 添加整数
sb.append(123);

// 添加布尔值
sb.append(true);

System.out.println(sb.toString()); 
//不管添加什么类型，都存成字符串了，输出：Hello, World!123true

// 在索引为 5 的位置插入字符串 " Java"
sb.insert(5, " Java");

// 删除从索引 5 到索引 10（不包含）的字符
sb.delete(5, 10);

// 删除索引为 4 的字符
sb.deleteCharAt(4);

// 将从索引 6 到索引 11（不包含）的字符替换为 "Java"
sb.replace(6, 11, "Java");

StringBuilder 没重写equals方法，则比较的是对象的引用，而不是内容。需要比较内容的时候，转换成String比较，String重写了equals方法

125. 验证回文串 - 力扣（LeetCode）

双指针

Character.isLetterOrDigit(s.charAt(left))如果是字母或数字，返回true

Character.toLowerCase(s.charAt(left)）转成小写

Character.toUpperCase(s.charAt(left)）转成小写

class Solution {
    public boolean isPalindrome(String s) {
        int n = s.length();
        int left = 0, right = n - 1;
        while (left < right) {
            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
                ++left;
            }
            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
                --right;
            }
            if (left < right) {
                if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
                    return false;
                }
                ++left;
                --right;
            }
        }
        return true;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/valid-palindrome/solutions/292148/yan-zheng-hui-wen-chuan-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

ASCLL码：

A  ~ Z                   a   ~  z                           a - A  = 32

65   90                 97 ~  122

69. x 的平方根 - 力扣（LeetCode）

用二分查找找target  的中间值，就是target的平方根

public int mySqrt(int x) {
        int l = 0, r = x;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if ((long) mid * mid <= x) {
                
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return l-1;
    }

牛顿迭代

解题思路参考：69. x 的平方根 - 力扣（LeetCode）

同样的方法可以用在其它的近似值计算中

   public int mySqrt(int a) {
        long x = a;
        while (x * x > a) x = (x + a / x) / 2;
        return (int)x;
    }

242. 有效的字母异位词 - 力扣（LeetCode）

String-->char[]

char[] str1 = s.toCharArray();

判断两个char[]是否相等

Arrays.equals(str1, str2);

这个equals适用于所有类型的数组比较，int数组，对象数组（但要重写equals方法）等都行 

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/valid-anagram/solutions/493231/you-xiao-de-zi-mu-yi-wei-ci-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这道题为了判断是否是元音字母，我用来HashSet存小写元音字母，用contains判断是否存在。为了让大小写字母都算存在，每次传给contains的char都是set.contains(Character.toLowerCase(str.charAt(head)))被toLowerCase处理过的

但实际上可以用indexOf

public boolean isVowel(char ch) {
        return "aeiouAEIOU".indexOf(ch) >= 0;
    }

290. 单词规律 - 力扣（LeetCode）

class Solution {
    public boolean wordPattern(String pattern, String str) {
        String[] words = str.split(" ");
        //字符和单词是互相映射，数量必须相等
        if (words.length != pattern.length()) {
            return false;
        }
        Map<Object, Integer> map = new HashMap<>();
        for (Integer i = 0; i < words.length; i++) {
            /*
                如果key不存在，插入成功，返回null；如果key存在，返回之前对应的value。

                以pattern = "abba", str = "dog cat cat dog"为例，
                第1次：map.put('a',0)返回null，map.put("dog",0)返回null，两者相等；
                第2次：map.put('b',1)返回null，map.put("cat",1)返回null，两者相等；
                第3次：map.put('b',2)返回1，map.put("cat",2)返回1，两者相等；
                第4次：map.put('a',3)返回0，map.put("dog",3)返回0，两者相等，
                结果为 true。

                以pattern = "abba", str = "dog cat cat fish"为例，
                第1次：map.put('a',0)返回null，map.put("dog",0)返回null，两者相等；
                第2次：map.put('b',1)返回null，map.put("cat",1)返回null，两者相等；
                第3次：map.put('b',2)返回1，map.put("cat",2)返回1，两者相等；
                第4次：map.put('a',3)返回0，map.put("fish",3)返回null，两者不相等，
                结果为 false。
            */
            if (map.put(pattern.charAt(i), i) != map.put(words[i], i)) {
                return false;
            }
        }
        return true;
    }
}

 这里用 Integer i，因为int值在[-128,127]范围内是使用缓存中的对象，超过这个范围就创建新的Integer对象，这样在新对象是不同的，导致在map.put(pattern.charAt(i), i) != map.put(words[i], i)时候会返回false。

434. 字符串中的单词数 - 力扣（LeetCode）

官方

题解借鉴：459. 重复的子字符串 - 力扣（LeetCode）

简单理解，放大s的概念，如果s可以由重复子串构成，那说明s中至少由两个相同字串，那么str = s+s也一定能由重复字串构成，str则至少有4个相同字串，去掉首尾字符，相当于破坏了第一个s的字串1，留下字串2，破坏了第二个s的字串2，留下字串1（本质上就是将s的两个字串中改变顺序，将后一个字串拿到前面）那么剩下的两个字串，如果能构成s（也就是题主说的包含原来的s），那说明s确实是由重复子串构成
这里注意一个概念，把s的概念放大，不要去纠结s的具体组成字符

class Solution {
   public boolean repeatedSubstringPattern(String s) {
        String str = s + s;
        return str.substring(1, str.length() - 1).contains(s);
    }
}