字符串操作相关题目

public class ReverseWorlds{
    String s = "  i   am  a  student";
    // 借助数组拆分然后反向遍历
   String[] str2arr = s.split(" ");
   System.out.println(Arrays.toString(str2arr));
   int n  = str2arr.length;
   for(int i =n-1;i>=0;--i){
     if(str2arr[i].equals(" ") continue;
    sb.append(str2arr[i]+" ");
    }
    System.out.println(sb.toString().trim());
}

 

class Solution {
    public boolean isAnagram(String s, String t) {
        /**
            利用hashmap统计第一个字符串中各个字符出现的次数，然后遍历第二个字符串取hanshmap中找存在的，存在就次数减一
         */
        //  Map<Character,Integer> map = new HashMap<>();
        //  for(char c: s.toCharArray()){
        //      map.put(c,map.getOrDefault(c,0)+1); // 初始为0，每次遍历到+1
        //  }
        //  for(char c : t.toCharArray()){
        //      Integer count = map.get(c); // 可能不存在，则返回null,int 不能为null
        //      if(count == null){
        //          return false;
        //      }else if(count>1){
        //          // 存在多个
        //          map.put(c,count-1);
        //      }else{
        //          // 存在一个
        //          map.remove(c);
        //      }
        //  }
        //  return map.isEmpty();

        // 方法 2
        int[] cnts = new int[26];   // 题目规定只有小写字母
        for(char ch :s.toCharArray()){
            // 用索引代表字母
            cnts[ch-'a']++;
        }
        for(char ch : t.toCharArray()){
            cnts[ch-'a']--;
        }

        for(int i =0;i<cnts.length;++i){
            if(cnts[i] != 0){
                return false;
            }
        }
        return true;


    }
}

 ASCII码

class Solution {
    public boolean isIsomorphic(String s, String t) {
       /**
           题目要求找到所有对应位置的映射关系都要一一对应，不能一对多或者多对一，因此，
           只需要同步遍历两个字符串对应位置字符，给他们打上唯一的关联标识，并且标识不能重复;
           利用ASCII码值来表示
          
        */

        int[] preIndexOfS = new int[128];  // 初始化默认都是0
        int[] preIndexOfT = new int[128];

        for(int i =0;i<s.length();++i){
            // 获取的是字符，字符做索引就是以其ascill码作为索引
            char sc = s.charAt(i),tc = t.charAt(i);
            // 最少是第二次出现，才能是出现不相等的情况
            if(preIndexOfS[sc] != preIndexOfT[tc]){
               //  出现了一对多的情况
               return false;
            }
            // 第一次出现更新时间戳   
            preIndexOfT[tc] = i+1;
            preIndexOfS[sc] = i+1;
        }
        return true;
    }
}

class Solution {
    private int cnt = 0;
    public int countSubstrings(String s) {
        /**
        涉及到回文字符串的题目，一般都需要用到双指针，
        从头遍历字符串s，然后每一次都让双指针指向当前遍历的字符位置，以它为中点位置恰好切割回文串两边，指针向两边移动，
        只要满足对称位置相等我们就记录一个子串为一个回文串；
        回文串有两种情况：奇数个数，则中间的一个拉单，偶数个数
         */

         for(int i = 0;i<s.length();++i){
             extendSubStrings(s,i,i); // 回文串为奇数的情况
             extendSubStrings(s,i,i+1); // 回文串为偶数的情况
         }
         return cnt;

    }
    private void extendSubStrings(String s ,int start,int end){
        while(start>=0 && end <s.length() && s.charAt(start) == s.charAt(end)){
            start--;
            end++;
            cnt++;
        }
    }
}

class Solution {
    /**
      将整数转化成字符串的方式：
      1、String s = String.valueOf(x)
      2、String s = Integer.toString(x);
      3、String s = '' +x;
      本题要求不能转化成字符串操作
     */

     /**
        对半拆分，然后倒置右半部分的数字，然后判断右半部分和左半部分的数是否值相等
      */
    public boolean isPalindrome(int x) {
        if(x==0) return true;
        if(x<0 || x%10 ==0) return false;

        int right = 0;
        while(x>right){
            // 取出左右两部分
            right = right*10 +x % 10;
            x /= 10;
        }
        // 回文可能是偶数个数和奇数个数
        return x==right || x== right/10;


    }
}