Java中字符串有关的方法·

 这两个方法非常非常重要

外加charAt()方法

0-9      48-57

A-Z   65-90

a-z    97-122

需要记住的是0-9是最小的，然后A-Z是处在中间的，a-z是最大的，也就是“0大小”

具体ascii值为多少你可以不用记，记住0的ascii码值为48即可

其他字符的ascii码可以通过这种方式求出来

       char  ch='A';

       int  num=ch-'0';

       System.out.println(num);//17  ‘0’的ascii码是48，所以A的ascii码就是65

1.如何定义一个字符串：

下面两种方法都可以：

    String string=new String("HelloWorld");
    String string="HelloWorld";

2.string.charAt(i)取出字符串中某个字符

      String string="HelloWorld";
      System.out.println(string.charAt(4));
      //得到o

3.字符数组和字符串的相互转换

（1）字符数组转字符串

        char[] array=new char[5];
        array[0]='g';
        array[1]='o';
        array[2]='o';
        array[3]='d';
        array[4]='!';
        String result=new String(array,0,array.length);//显然这里是左闭右开[0,array.length)
        System.out.println(result);
        //输出：good!
       或者直接String result=new String(array)

(2)字符串转字符数组（非常非常重要，因为数组我们非常非常熟)

String s="abcdefghijk"

char[] result=s.toCharArray();

4.StringBuilder转字符串String

StringBuildr.toString();

注意：StringBuilder有reverse方法，反转字符串，String没有这个反转方法

5.字符串转化为字符数组

char[] array=string.toCharArray();

6.字符串截取子串string.substring() ：前闭后开

String s=“Hello，World!”;
String s2=s.substring(1,5)
//"ello,"

7.判断两个字符串是否相等

s1.equals(s2)

 判断两个字符串的值是否相等，而不是判断地址是否相等

8.split分割方法：最后得到的是一个字符串数组，也就是数组中每一个元素都是字符串

下面的例子就是以空格为分割符切分字符串

9. startswith方法和endswith方法：

startsWith()方法和endsWith()方法，可以判断某字符串是否以指定字符串开始或结束

10.字符串按字典序排序

本意是按照英文单词在字典中的先后顺序进行排列，但是字符串不仅仅是英文字母，还包括数字，特殊字符等，于是引申为字符串大小比较:

System.out.println("ah1x".compareTo("ahb"));
//会输出 -49−49，这个数是两个字符串第一个不一样的位置的两个字符的 ASCII 值之差，如果小于零则说明第一个字符串小于第二个字符串。

public class LuckyDog
{
    public static void main(String[] args)
    {
        String[] words = {"Ruby", "C", "Python", "Java"};
        for (int i = 0; i < words.length - 1; i++) {
            for (int j = i + 1; j < words.length; j++) {
                //如果前面的字符比后面的字符大，交换相邻两个字符串
                if (words[i].compareTo(words[j]) > 0) {
                    // words[i] 与 words[j] 交换
                    String temp = words[i];
                    words[i] = words[j];
                    words[j] = temp;
                }
            }
        }
        System.out.println("按照字典顺序:");
        for (int i = 0; i < words.length; i++)
        {
            System.out.println(words[i]);
            //C,Java,Python,Ruby
        }
    }
}

或者是：

public class LuckyDog
{
    public static void main(String[] args)
    {
        String[] words = {"Ruby", "C", "Python", "Java"};
        ArrayList<String> arraylist=new ArrayList();
        for (int i = 0; i < words.length ; i++)
        {
            arraylist.add(words[i]);
        }
        Collections.sort(arraylist);
        System.out.println("按照字典顺序:");
        for (int i = 0; i < arraylist.size(); i++)
        {
            System.out.println(arraylist.get(i));
            //C,Java,Python,Ruby
        }
    }
}

11.string.replace()方法

返回的是一个新字符串，原字符串不会发生改变

注意：replace是一次性把所有的都替换掉

而且可以字符串换字符串，字符串换字符，字符换字符，字符换字符串

12.stringbuilder.deleteCharAt(i) 删除指定位置的字符

是stringbuilder的方法，直接对原stringbuilder进行改造，而不是返回一个一个新的stringbuilder

另外要注意：当字符串太长的时候，如果要分成两行写，不能直接就分成两行：

        System.out.println("I love          
                         Java!");

这样是无法通过编译的，而是需要用+将两个字符串连接起来

        System.out.println("I love"+          
                            "Java!");

刷完下面的题你会发现，将字符串转化为字符数组很常用，String和StringBuilder之间的相互转化也非常常见

13.判断字符串中是否包含某个字符：

string.contains("a");//返回true或者false

例题

（1）力扣替换空格

class Solution
 {
    public String replaceSpace(String s) 
    {
        //定义一个数组，这个数组长度是字符串长度的三倍
        //因为一个空格换成%20三个字符，所以三倍长度才能完全容纳字符串
        char[] array = new char[s.length() * 3];
        int size = 0;//size是我们定义的数组中的下标
        //用i来取出字符串中每一个字符
        for (int i = 0; i < s.length(); i++) 
        {
            char c = s.charAt(i);
            if (c == ' ') 
            {
                array[size] = '%';
                size++;
                array[size] = '2';
                size++;
                array[size] = '0';
                size++;
            } 
            else 
            {
                array[size] = c;
                size++;
            }
        }
       //注意这里不能 String result = new String(array)，因为你开的数组是s.length() * 3，但是实际上你很肯可能并没有全部填满
        String result = new String(array, 0, size);
        return result;
    }
}

有一道很相似的题目：力扣1108  IP地址无效化

class Solution
 {
    public String defangIPaddr(String address)
    {
      String result=address.replace(".","[.]");

      return  result;
    }
}

class Solution {
    public String defangIPaddr(String address) {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < address.length(); i++) {
            if (address.charAt(i) == '.') {
                //s.append('[');
                //s.append('.');
                //s.append(']');
                s.append("[.]");
            } else {
                s.append(address.charAt(i));
            }
        }
        return s.toString();
    }
}

（2）左旋转字符串

力扣剑指offer58 

k就是说把前k个字符放到字符串最后面去

比如这里k=2，就是说把前面两个字符放到字符串最后面去

方法一：利用substring方法截取字符串子串的方法，将字符串先变成两个字符串，第一个字符串str1是前k个字符组成的，第二个字符串str2是由剩下的字符组成的，然后两个字符串进行拼接，而且是str2放在前面，str1放在后面，也就是说str2+str1

class Solution 
{
    public String reverseLeftWords(String s, int n) 
    {
        //substring是前闭后开
        String s1=s.substring(0, n);
        String s2=s.substring(n, s.length());
        return s2+s1;

    }
}

方法二：

class Solution 
{
    public String reverseLeftWords(String s, int n) 
    {
        StringBuilder result = new StringBuilder();
        
        //先把后面的字符添加进StringBuilder里面
        for(int i = n; i < s.length(); i++)
        {
            result.append(s.charAt(i));
        }
        //再把前面的字符添加进StringBuilder里面
  1      for(int i = 0; i < n; i++)
        {
            result.append(s.charAt(i));
        }   
        //将StringBuilder转化为String字符串    
        return result.toString();
    }
}

方法三：

class Solution 
{
    public String reverseLeftWords(String s, int n) 
    {
        String result = "";
        for(int i = n; i < s.length(); i++)
        {
            result += s.charAt(i);
        }
        for(int i = 0; i < n; i++)
        {
            result += s.charAt(i);
        }
        return result;
    }
}

（3）实现strStr()

力扣28 :找出一个字符串在另一个字符串中出现的位置

暴力法：

class Solution 
{
    //求出s2在s1中出现的位置    
    public int strStr(String s1, String s2)
    {
        if(s2.equals(""))     
        {
          return 0;  
        }
        if(s1.length()<s2.length())   return -1;
        if(s1.length()==s2.length())    
        {
            if(s1.equals(s2))    return 0;
            else
            {
               return -1;
            }
        }
        
       //先将两个字符串都转成字符数组
        char[]  c1=s1.toCharArray();
        char[]  c2=s2.toCharArray();

        //其实就是暴力法，对于s1中的每个字符，如果这个字符是s2的首字符，就继续比较          
        //但是不是用i来比较，而是用temp来代表str1来进行比较，用j来代表str2来进行比较
        for(int i=0;i<c1.length;i++)
        {
         //一个优化，如果i走到了str1剩下的字符串长度小于str2的字符串长度
         //那说明str2不可能是str1的子串
         //c1.length-i<c2.length
            if(i>c1.length-c2.length)   return -1;
            int temp=i;
            for(int j=0;j<c2.length;)
            {
                if(c2[j]==c1[temp])
                {
                    temp++;
                    j++;
                }
                else
                {
                    break;
                }
                if(j==c2.length)    return i;
            }  
        }
        return -1;
    }

（4）最长公共前缀

力扣14

将第一个字符串(字符串1）作为基准，其他所有的字符串（字符串2，3，4，5）和它一起比较

class Solution 
{
    public String longestCommonPrefix(String[] strs) 
    {
        //遍历str[0]这个字符串的每一个字符
        for(int i=0;i<strs[0].length();i++)
        {
           char temp=strs[0].charAt(i);
           //和其他字符串str[1]，str[2]....进行比较
           for(int j=1;j<strs.length;j++)
           {
               //如果此时i已经超出了字符串str[1]，str[2]...的长度或者此时别的字符串第i个位置不等于str[0]的第i个位置那就可以停止比较了
               if(i==strs[j].length()||strs[j].charAt(i)!=temp)
               {
                   return strs[0].substring(0,i);
               }
           }
        }
        return strs[0];
    } 
}

（5）力扣557 反转字符串中的单词|||

class Solution 
{
    public String reverseWords(String s) 
    {
        //得到一个字符串数组
        String[] array=s.split(" ");

        StringBuilder result=new StringBuilder();
        
        //遍历字符串数组里的每一个字符串
        for(int i=0;i<array.length;i++)
        {
          //遍历字符串中每一个字符，从最后一个字符遍历到第一个字符,翻转字符串
          for(int j=array[i].length()-1;j>=0;j--)
          {
             result.append(array[i].charAt(j));
          }

          //每翻转完一个字符串就添加一个空格
          if(i!=array.length-1)
          {
             result.append(" ");
          }     
        }
        return result.toString();
    }
}

（6）力扣541反转字符串||

class Solution 
{
    public String reverseStr(String s, int k)
    {
        int n=s.length();
        //将字符串转化为字符数组
        //这里先将字符串转化为字符数组，最后再将字符数组转回字符串
        char[]  result=s.toCharArray();

        //太优秀了：i每次的取值是0，2k，4k，6k......
        //也就是说跳跃间距不是i++的1，而是2k
        for(int i=0;i<s.length();i=i+2*k)
        {
           //每次反转的起点就是i，终点就是i+k-1，一共k个数
           //也有可能是起点是i，终点是n-1(最后一轮字符数小于k)
           //所以最后终点是Math.min(i+k-1,n-1)
            reverse(result,i,Math.min(i+k,n)-1);
        }
        return new String(result);
    }
    public void reverse(char[] result,int left,int  right)
    {
        while(left<right)
        {
            char temp=result[left];
            result[left]=result[right];
            result[right]=temp;
            left++;
            right--;
        }
    }
}

(7)力扣剑指offer50 第一个只出现一次的字符

class Solution 
{
    public char firstUniqChar(String s)
    {
        HashMap<Character,Integer> map=new HashMap();

        
        for(int i=0;i<s.length();i++)
        {
          char temp=s.charAt(i);
          map.put(temp,map.getOrDefault(temp,0)+1);
        }
        for(int i=0;i<s.length();i++)
        {
            char temp=s.charAt(i);
            if(map.get(temp)==1)   return temp;
        }
        return ' ';
    }
}

（8）力扣165 比较版本号

class Solution
{
    public int compareVersion(String version1, String version2)
    {
        //比较两个版本号的大小
        //1.0版本小于1.1

        //以.作为分隔符的时候，需要加上转义气分割符\\
        String[]  string1=version1.split("\\.");
        String[]  string2=version2.split("\\.");
        //分割后是一个字符数组,数组中每一个元素是字符串（不是单个字符）
        //比如：版本号本身为：1.001.01,split后：[“1”,"001","01"]
        
        int n1=string1.length;
        int n2=string2.length;
        int i=0,j=0;
        while(i<n1||j<n2)
        {
            int num1=0,num2=0;
            if(i<n1)
            {
                //001和01是相等的，Integer.parseInt()转成整数的时候会帮你去掉前导0
                num1=Integer.parseInt(string1[i]);
                i++;
            }
            if(j<n2)
            {
                num2=Integer.parseInt(string2[j]);
                j++;
            }
            if(num1!=num2)
            {
                if(num1>num2)
                {
                    return 1;
                }
                else
                {
                    return -1;
                }
            }
        }
        return 0;
    }
}

（9）力扣字符串相加

class Solution 
{
    public String addStrings(String string1, String string2) 
    {
        //4 5 6
        //  7 7
        //5 3 3
        //从字符串最后一位加到第一位，所以i，j初始值是string1.length( ) - 1，string2.length( ) - 1;
        int i =string1.length( ) - 1;
        int j =string2.length( ) - 1;

        int flag = 0;

        StringBuilder result = new StringBuilder( );

        while (i >= 0 || j >= 0)
        {
            
            int num1=0,num2=0,sum=0;
            if (i >= 0) 
            {
                num1 = string1.charAt( i ) - '0';
            } 
            if (j >= 0) 
            {
                num2= string2.charAt(j) - '0';
            } 
            sum= num1 + num2 + flag;
            
            flag=sum/10;
            sum=sum%10;

            result.append( sum % 10 );
            i--;
            j--;
        }
        if (flag == 1)
        {
            result.append( 1 );
        }
        return result.reverse( ).toString( ) ;  // write code here
    }
}

（10）力扣LCP17  速算机器人

class Solution 
{
    public int calculate(String s) 
    {
        int x=1,y=0;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='A')
            {
                x = 2 * x + y;
            }
            if(s.charAt(i)=='B')
            {
                y = 2 * y + x;
            }
        }
        return x+y;     
    }
}

（11）力扣798 旋转字符串

判断a字符串经过旋转能否变成b字符串

只需要判断b字符串是否是a+a的子串即可

class Solution {
    public boolean rotateString(String a, String b)
    {
       if(a.length()!=b.length())   return  false;
       return    (a+a).contains(b); 
    }
}

（12）力扣434  字符串中的单词数

对于split函数而言， \\s表示 空格,回车,换行等空白符,       +号表示一个或多个的意思

如果下面的代码：

class Solution 
{
    public int countSegments(String s)
    {
        if(s.length()==0)  return 0;
        
        //通过空格进行分割
        String   words[]=s.split("\\s+");//\\s表示空格.\\s+表示可能有多个字符

        int length=words.length;

        return   length;
    }
}

 这个测试用例过不了，这是因为这个用例是以空格开头，这样分割出来的字符数组第一个元素是空，所以还有判断一下字符数组中每一个元素是否为空

class Solution 
{
    public int countSegments(String s)
    {
        if(s.length()==0)  return 0;
        
        //通过空格进行分割
        String   words[]=s.split("\\s+");//\\s表示空格.\\s+表示可能有多个字符

        int length=words.length;

        int result=0;

        //还要判断一下分割出来的字符数组中的元素是不是为空
        for(int i=0;i<length;i++)
        {
            if(words[i].length()>0)   result++;
        }
        return   result;
    }
}

（13）力扣   查找searchWord是否是字符串sentence中某个单词的前缀

class Solution 
{
    public int isPrefixOfWord(String sentence, String searchWord)
    {
        //查找searchWord是否是sentence中某个单词的前缀
        String[]  words=sentence.split("\\s");

        //遍历字符串数组中每一个字符串
        for(int i=0;i<words.length;i++)
        {
            String temp=words[i];
            
            //遍历待查找字符串中的每一个字符
            for(int j=0;j<searchWord.length();j++)
            {
               if(j>=temp.length())
               {
                   break;
               }
               else
               {
                  if(searchWord.charAt(j)==temp.charAt(j))//相等就比较下一个字符
                  {
                     if(j==searchWord.length()-1)
                     {
                         return  i+1;
                     }
                     else
                     {
                        continue;
                     }
                  }
                  else//不相等就直接比较下一个单词
                  {
                     break;
                  }
               }
               
            }
        }
        return  -1;
    }
}

字符串最后一个单词的长度

import java.util.Scanner;
public class Main 
{
    public static void main(String[] args)
    {
        Scanner scanner=new Scanner(System.in);
        String input=scanner.nextLine();

        int  result=0;

        int i=input.length()-1;

        while(i>=0&&input.charAt(i)!=' ')//从后往前遍历字符串中的每一个字符，直到遇到空格
        {
          result++;
          i--;
        }
    
         System.out.println(result);
    }   
}

十六进制转十进制

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String input=in.next();

        int result=0;
        
        for(int i=0;i<input.length();)
        {
            char temp=input.charAt(i);
            if(temp>='0'&&temp<='9')
            {
                result=result*16+(temp-'0');
                i++;
            }
            else if(temp>='A'&&temp<='F')
            {
                result=result*16+(temp-'A'+10);
                i++;
            }
            else
            {
                i++;
            }
        }
        System.out.println(result);
    }
}