字符串（一)-easy

• @新建一个栈，遍历字符串，遇到开头符则把对应的末尾符进栈，遇到尾弧则弹出栈顶比对，有不相同则返回false

public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();
        for(char c: s.toCharArray()){
            if(c=='(')stack.push(')');
            else if(c=='[')stack.push(']');
            else if(c=='{')stack.push('}');
            else if(stack.isEmpty()||c!=stack.pop()) return false;
        }
        return stack.isEmpty();
    }

• @用哈希表存储，遍历规律，判断规律里的字符是否存在于哈希表，存在则判断和s中对应下标的字符串是否匹配，不匹配即为false,然后还要判断s中对应下标的字符串是否已经在map中出现过，出现过说明两个以上字符对应一个字符串，为false,最后再把对应字符和字符串存入map。

public boolean wordPattern(String pattern, String str) {
        String[] s=str.split(" ");
        if(pattern.length()!=s.length)
            return false;
        HashMap<Character,String> map=new HashMap();
        for(int i=0;i<pattern.length();i++)
        {
            char tmp=pattern.charAt(i);
            if(map.containsKey(tmp))
            {
                if(!map.get(tmp).equals(s[i]))
                {
                    return false;
                }
            }
            else if(map.containsValue(s[i])){
                return false;
            }
            else
            {
                map.put(tmp,s[i]);
            }
        }
        return true;
    }

HashMap<String,Integer> dic;/*=new HashMap<>();*/
    public void WordsFrequency(String[] book) {
        for(String word:book)
        {
            dic.put(word,dic.getOrDefault(word,0)+1);
        }
    }
    public int get(String word) {
        return  dic.getOrDefault(word,0);
    }

反转单词顺序（内部字符不变，空格压缩为一个）

public String reverseWords(String s) {
        //将传进来的字符串以空格拆分
        String[] strings = s.trim().split(" ");
        StringBuffer stringBuffer = new StringBuffer();
        //从尾巴开始遍历
        for (int i = strings.length - 1; i >= 0; i--) {
            if (strings[i].equals("")) {
                continue;
            }
            //到头了，append然后去空格
            if (i == 0) {
                stringBuffer.append(strings[i]);
            } else {
                // 怕有多余的空格，去掉，再加上去
                stringBuffer.append(strings[i]).append(" ");
            }
        }
        //输出String 完事，安排！
        return stringBuffer.toString();
    }

• @ACSII

//100% & 25%
public char findTheDifference1(String s, String t) {
        int sum=0;
        for(char a:t.toCharArray())
        {
            sum+=a;
        }
        for(char a:s.toCharArray())
        {
            sum-=a;
        }
        return (char)sum;
    }

• @异或

 public char findTheDifference(String s, String t) {
        char res = 0;
        int lens = s.length();
        for (int i = 0; i < lens; i ++) {
            res ^= s.charAt(i)^ t.charAt(i);
        }
        res ^= t.charAt(lens);
        return res;
    }

• @哈希字典

public char findTheDifference1(String s, String t) {
        int[] record = new int[26];
        int lenS = s.length();
        int lenT = t.length();
        for (int i = 0; i < lenS; i++){
            record[s.charAt(i) - 'a'] += 1;
        }
        for (int i = 0; i < lenT; i++){
            record[t.charAt(i) - 'a'] -= 1;
            if (record[t.charAt(i) - 'a'] < 0) return t.charAt(i);

        }
        return ' ';
    }

public int lengthOfLongestSubstring(String s) {
        int res = 0;
        Set<Character> set = new HashSet<>();
        for(int l = 0, r = 0; r < s.length(); r++) {
            char c = s.charAt(r);
            while(set.contains(c)) {
                set.remove(s.charAt(l++));
            }
            set.add(c);
            res = Math.max(res, r - l + 1);
        }
        return res;
    }

@双指针前后对比，相中靠拢(最高效)

 //双指针，99.8%
    public boolean isPalindrome(String s) {
        if(s == null){
            return true;
        }
        s = s.toLowerCase();
        char[] array1 = s.toCharArray();
        int low = 0;
        int high = array1.length-1;
        while(low < high)
        {
            if((array1[low] >= '0' && array1[low] <= '9') 
                    || (array1[low] >= 'a' && array1[low] <= 'z'))
            {
                if((array1[high] >= '0' && array1[high] <= '9') 
                        || array1[high] >= 'a' && array1[high] <= 'z')
                {
                    if(array1[low] != array1[high])
                    {
                        return false;
                    }else{
                        low++;
                        high--;
                    }
                }else{
                    high--;
                }
            }else{
                low++;
            }
        }
        return true;
    }

• @用两个栈分别保存字符串从前往后的顺序和从后往前的顺序，然后两个栈弹出对比，不同为false

//10ms   25%
    public boolean isPalindrome(String s) {
        Stack<Character> c1 = new Stack<>();
        Stack<Character> c2 = new Stack<>();
        char[] ch1 = s.toCharArray();
        int n=ch1.length;
        for(int i=0;i<n;i++)
        {
            if((ch1[i]>='a'&&ch1[i]<='z')||(ch1[i]>='0')&&(ch1[i]<='9'))
                c1.push(ch1[i]);
            if(ch1[i]>='A'&&ch1[i]<='Z')
                c1.push((char)(ch1[i]+32));
        }
        for(int i=n-1;i>=0;i--)
        {
            if((ch1[i]>='a'&&ch1[i]<='z')||(ch1[i]>='0')&&(ch1[i]<='9'))
                c2.push(ch1[i]);
            if(ch1[i]>='A'&&ch1[i]<='Z')
                c2.push((char)(ch1[i]+32));
        }
        while (!c1.isEmpty())
        {
            char t1=c1.pop();
            char t2=c2.pop();
            if(t1!=t2)
            {
                return false;
            }
        }
        return true;
    }

• @直接用reverse函数倒置字符串，然后通过equals函数和原来比对

//4ms 75%
    public boolean isPalindrome(String s) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9'))) sb.append(c);
            if ((c >= 'A') && (c <= 'Z')) sb.append((char)(c+32));
        };
        return sb.toString().equals(sb.reverse().toString());
    }