devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中字符串有关的方法·_return new string

作者：我家自动化 | 2024-03-30 07:07:41

赞

踩

return new string

 这两个方法非常非常重要

外加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码可以通过这种方式求出来

  1.        char  ch='A';
  2.  
  3.        int  num=ch-'0';
  4.  
  5.        System.out.println(num);//17  ‘0’的ascii码是48，所以A的ascii码就是65

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

下面两种方法都可以：

  1.     String string=new String("HelloWorld");
  2.     String string="HelloWorld";

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

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

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

（1）字符数组转字符串

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

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

  1. String s="abcdefghijk"
  2.  
  3. char[] result=s.toCharArray();

4.StringBuilder转字符串String

StringBuildr.toString();

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

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

char[] array=string.toCharArray();

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

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

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

s1.equals(s2)

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

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

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

9. startswith方法和endswith方法：

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

10.字符串按字典序排序

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

  1. System.out.println("ah1x".compareTo("ahb"));
  2. //会输出 -49−49，这个数是两个字符串第一个不一样的位置的两个字符的 ASCII 值之差，如果小于零则说明第一个字符串小于第二个字符串。
  1. public class LuckyDog
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         String[] words = {"Ruby", "C", "Python", "Java"};
  6.         for (int i = 0; i < words.length - 1; i++) {
  7.             for (int j = i + 1; j < words.length; j++) {
  8.                 //如果前面的字符比后面的字符大，交换相邻两个字符串
  9.                 if (words[i].compareTo(words[j]) > 0) {
  10.                     // words[i] 与 words[j] 交换
  11.                     String temp = words[i];
  12.                     words[i] = words[j];
  13.                     words[j] = temp;
  14.                 }
  15.             }
  16.         }
  17.         System.out.println("按照字典顺序:");
  18.         for (int i = 0; i < words.length; i++)
  19.         {
  20.             System.out.println(words[i]);
  21.             //C,Java,Python,Ruby
  22.         }
  23.     }
  24. }

或者是：

  1. public class LuckyDog
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         String[] words = {"Ruby", "C", "Python", "Java"};
  6.         ArrayList<String> arraylist=new ArrayList();
  7.         for (int i = 0; i < words.length ; i++)
  8.         {
  9.             arraylist.add(words[i]);
  10.         }
  11.         Collections.sort(arraylist);
  12.         System.out.println("按照字典顺序:");
  13.         for (int i = 0; i < arraylist.size(); i++)
  14.         {
  15.             System.out.println(arraylist.get(i));
  16.             //C,Java,Python,Ruby
  17.         }
  18.     }
  19. }

11.string.replace()方法

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

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

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

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

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

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

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

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

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

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

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

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

例题

（1）力扣替换空格

  1. class Solution
  2.  {
  3.     public String replaceSpace(String s) 
  4.     {
  5.         //定义一个数组，这个数组长度是字符串长度的三倍
  6.         //因为一个空格换成%20三个字符，所以三倍长度才能完全容纳字符串
  7.         char[] array = new char[s.length() * 3];
  8.         int size = 0;//size是我们定义的数组中的下标
  9.         //用i来取出字符串中每一个字符
  10.         for (int i = 0; i < s.length(); i++) 
  11.         {
  12.             char c = s.charAt(i);
  13.             if (c == ' ') 
  14.             {
  15.                 array[size] = '%';
  16.                 size++;
  17.                 array[size] = '2';
  18.                 size++;
  19.                 array[size] = '0';
  20.                 size++;
  21.             } 
  22.             else 
  23.             {
  24.                 array[size] = c;
  25.                 size++;
  26.             }
  27.         }
  28.        //注意这里不能 String result = new String(array)，因为你开的数组是s.length() * 3，但是实际上你很肯可能并没有全部填满
  29.         String result = new String(array, 0, size);
  30.         return result;
  31.     }
  32. }

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

  1. class Solution
  2.  {
  3.     public String defangIPaddr(String address)
  4.     {
  5.       String result=address.replace(".","[.]");
  6.  
  7.       return  result;
  8.     }
  9. }
  1. class Solution {
  2.     public String defangIPaddr(String address) {
  3.         StringBuilder s = new StringBuilder();
  4.         for (int i = 0; i < address.length(); i++) {
  5.             if (address.charAt(i) == '.') {
  6.                 //s.append('[');
  7.                 //s.append('.');
  8.                 //s.append(']');
  9.                 s.append("[.]");
  10.             } else {
  11.                 s.append(address.charAt(i));
  12.             }
  13.         }
  14.         return s.toString();
  15.     }
  16. }

（2）左旋转字符串

力扣剑指offer58 

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

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

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

  1. class Solution 
  2. {
  3.     public String reverseLeftWords(String s, int n) 
  4.     {
  5.         //substring是前闭后开
  6.         String s1=s.substring(0, n);
  7.         String s2=s.substring(n, s.length());
  8.         return s2+s1;
  9.  
  10.     }
  11. }

方法二：

  1. class Solution 
  2. {
  3.     public String reverseLeftWords(String s, int n) 
  4.     {
  5.         StringBuilder result = new StringBuilder();
  6.         
  7.         //先把后面的字符添加进StringBuilder里面
  8.         for(int i = n; i < s.length(); i++)
  9.         {
  10.             result.append(s.charAt(i));
  11.         }
  12.         //再把前面的字符添加进StringBuilder里面
  13.   1      for(int i = 0; i < n; i++)
  14.         {
  15.             result.append(s.charAt(i));
  16.         }   
  17.         //将StringBuilder转化为String字符串    
  18.         return result.toString();
  19.     }
  20. }

方法三：

  1.  
  2. class Solution 
  3. {
  4.     public String reverseLeftWords(String s, int n) 
  5.     {
  6.         String result = "";
  7.         for(int i = n; i < s.length(); i++)
  8.         {
  9.             result += s.charAt(i);
  10.         }
  11.         for(int i = 0; i < n; i++)
  12.         {
  13.             result += s.charAt(i);
  14.         }
  15.         return result;
  16.     }
  17. }
  18.

（3）实现strStr()

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

暴力法：

  1. class Solution 
  2. {
  3.     //求出s2在s1中出现的位置    
  4.     public int strStr(String s1, String s2)
  5.     {
  6.         if(s2.equals(""))     
  7.         {
  8.           return 0;  
  9.         }
  10.         if(s1.length()<s2.length())   return -1;
  11.         if(s1.length()==s2.length())    
  12.         {
  13.             if(s1.equals(s2))    return 0;
  14.             else
  15.             {
  16.                return -1;
  17.             }
  18.         }
  19.         
  20.        //先将两个字符串都转成字符数组
  21.         char[]  c1=s1.toCharArray();
  22.         char[]  c2=s2.toCharArray();
  23.  
  24.         //其实就是暴力法，对于s1中的每个字符，如果这个字符是s2的首字符，就继续比较          
  25.         //但是不是用i来比较，而是用temp来代表str1来进行比较，用j来代表str2来进行比较
  26.         for(int i=0;i<c1.length;i++)
  27.         {
  28.          //一个优化，如果i走到了str1剩下的字符串长度小于str2的字符串长度
  29.          //那说明str2不可能是str1的子串
  30.          //c1.length-i<c2.length
  31.             if(i>c1.length-c2.length)   return -1;
  32.             int temp=i;
  33.             for(int j=0;j<c2.length;)
  34.             {
  35.                 if(c2[j]==c1[temp])
  36.                 {
  37.                     temp++;
  38.                     j++;
  39.                 }
  40.                 else
  41.                 {
  42.                     break;
  43.                 }
  44.                 if(j==c2.length)    return i;
  45.             }  
  46.         }
  47.         return -1;
  48.     }

（4）最长公共前缀

力扣14

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

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

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

  1. class Solution 
  2. {
  3.     public String reverseWords(String s) 
  4.     {
  5.         //得到一个字符串数组
  6.         String[] array=s.split(" ");
  7.  
  8.         StringBuilder result=new StringBuilder();
  9.         
  10.         //遍历字符串数组里的每一个字符串
  11.         for(int i=0;i<array.length;i++)
  12.         {
  13.           //遍历字符串中每一个字符，从最后一个字符遍历到第一个字符,翻转字符串
  14.           for(int j=array[i].length()-1;j>=0;j--)
  15.           {
  16.              result.append(array[i].charAt(j));
  17.           }
  18.  
  19.           //每翻转完一个字符串就添加一个空格
  20.           if(i!=array.length-1)
  21.           {
  22.              result.append(" ");
  23.           }     
  24.         }
  25.         return result.toString();
  26.     }
  27. }

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

  1. class Solution 
  2. {
  3.     public String reverseStr(String s, int k)
  4.     {
  5.         int n=s.length();
  6.         //将字符串转化为字符数组
  7.         //这里先将字符串转化为字符数组，最后再将字符数组转回字符串
  8.         char[]  result=s.toCharArray();
  9.  
  10.         //太优秀了：i每次的取值是0，2k，4k，6k......
  11.         //也就是说跳跃间距不是i++的1，而是2k
  12.         for(int i=0;i<s.length();i=i+2*k)
  13.         {
  14.            //每次反转的起点就是i，终点就是i+k-1，一共k个数
  15.            //也有可能是起点是i，终点是n-1(最后一轮字符数小于k)
  16.            //所以最后终点是Math.min(i+k-1,n-1)
  17.             reverse(result,i,Math.min(i+k,n)-1);
  18.         }
  19.         return new String(result);
  20.     }
  21.     public void reverse(char[] result,int left,int  right)
  22.     {
  23.         while(left<right)
  24.         {
  25.             char temp=result[left];
  26.             result[left]=result[right];
  27.             result[right]=temp;
  28.             left++;
  29.             right--;
  30.         }
  31.     }
  32. }

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

  1. class Solution 
  2. {
  3.     public char firstUniqChar(String s)
  4.     {
  5.         HashMap<Character,Integer> map=new HashMap();
  6.  
  7.         
  8.         for(int i=0;i<s.length();i++)
  9.         {
  10.           char temp=s.charAt(i);
  11.           map.put(temp,map.getOrDefault(temp,0)+1);
  12.         }
  13.         for(int i=0;i<s.length();i++)
  14.         {
  15.             char temp=s.charAt(i);
  16.             if(map.get(temp)==1)   return temp;
  17.         }
  18.         return ' ';
  19.     }
  20. }

（8）力扣165 比较版本号

  1. class Solution
  2. {
  3.     public int compareVersion(String version1, String version2)
  4.     {
  5.         //比较两个版本号的大小
  6.         //1.0版本小于1.1
  7.  
  8.         //以.作为分隔符的时候，需要加上转义气分割符\\
  9.         String[]  string1=version1.split("\\.");
  10.         String[]  string2=version2.split("\\.");
  11.         //分割后是一个字符数组,数组中每一个元素是字符串（不是单个字符）
  12.         //比如：版本号本身为：1.001.01,split后：[“1”,"001","01"]
  13.         
  14.         int n1=string1.length;
  15.         int n2=string2.length;
  16.         int i=0,j=0;
  17.         while(i<n1||j<n2)
  18.         {
  19.             int num1=0,num2=0;
  20.             if(i<n1)
  21.             {
  22.                 //001和01是相等的，Integer.parseInt()转成整数的时候会帮你去掉前导0
  23.                 num1=Integer.parseInt(string1[i]);
  24.                 i++;
  25.             }
  26.             if(j<n2)
  27.             {
  28.                 num2=Integer.parseInt(string2[j]);
  29.                 j++;
  30.             }
  31.             if(num1!=num2)
  32.             {
  33.                 if(num1>num2)
  34.                 {
  35.                     return 1;
  36.                 }
  37.                 else
  38.                 {
  39.                     return -1;
  40.                 }
  41.             }
  42.         }
  43.         return 0;
  44.     }
  45. }

（9）力扣字符串相加

  1. class Solution 
  2. {
  3.     public String addStrings(String string1, String string2) 
  4.     {
  5.         //4 5 6
  6.         //  7 7
  7.         //5 3 3
  8.         //从字符串最后一位加到第一位，所以i，j初始值是string1.length( ) - 1，string2.length( ) - 1;
  9.         int i =string1.length( ) - 1;
  10.         int j =string2.length( ) - 1;
  11.  
  12.         int flag = 0;
  13.  
  14.         StringBuilder result = new StringBuilder( );
  15.  
  16.         while (i >= 0 || j >= 0)
  17.         {
  18.             
  19.             int num1=0,num2=0,sum=0;
  20.             if (i >= 0) 
  21.             {
  22.                 num1 = string1.charAt( i ) - '0';
  23.             } 
  24.             if (j >= 0) 
  25.             {
  26.                 num2= string2.charAt(j) - '0';
  27.             } 
  28.             sum= num1 + num2 + flag;
  29.             
  30.             flag=sum/10;
  31.             sum=sum%10;
  32.  
  33.             result.append( sum % 10 );
  34.             i--;
  35.             j--;
  36.         }
  37.         if (flag == 1)
  38.         {
  39.             result.append( 1 );
  40.         }
  41.         return result.reverse( ).toString( ) ;  // write code here
  42.     }
  43. }

（10）力扣LCP17  速算机器人

  1. class Solution 
  2. {
  3.     public int calculate(String s) 
  4.     {
  5.         int x=1,y=0;
  6.         for(int i=0;i<s.length();i++)
  7.         {
  8.             if(s.charAt(i)=='A')
  9.             {
  10.                 x = 2 * x + y;
  11.             }
  12.             if(s.charAt(i)=='B')
  13.             {
  14.                 y = 2 * y + x;
  15.             }
  16.         }
  17.         return x+y;     
  18.     }
  19. }

（11）力扣798 旋转字符串

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

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

  1. class Solution {
  2.     public boolean rotateString(String a, String b)
  3.     {
  4.        if(a.length()!=b.length())   return  false;
  5.        return    (a+a).contains(b); 
  6.     }
  7. }

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

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

如果下面的代码：

  1. class Solution 
  2. {
  3.     public int countSegments(String s)
  4.     {
  5.         if(s.length()==0)  return 0;
  6.         
  7.         //通过空格进行分割
  8.         String   words[]=s.split("\\s+");//\\s表示空格.\\s+表示可能有多个字符
  9.  
  10.         int length=words.length;
  11.  
  12.         return   length;
  13.     }
  14. }

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

  1. class Solution 
  2. {
  3.     public int countSegments(String s)
  4.     {
  5.         if(s.length()==0)  return 0;
  6.         
  7.         //通过空格进行分割
  8.         String   words[]=s.split("\\s+");//\\s表示空格.\\s+表示可能有多个字符
  9.  
  10.         int length=words.length;
  11.  
  12.         int result=0;
  13.  
  14.         //还要判断一下分割出来的字符数组中的元素是不是为空
  15.         for(int i=0;i<length;i++)
  16.         {
  17.             if(words[i].length()>0)   result++;
  18.         }
  19.         return   result;
  20.     }
  21. }

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

  1. class Solution 
  2. {
  3.     public int isPrefixOfWord(String sentence, String searchWord)
  4.     {
  5.         //查找searchWord是否是sentence中某个单词的前缀
  6.         String[]  words=sentence.split("\\s");
  7.  
  8.         //遍历字符串数组中每一个字符串
  9.         for(int i=0;i<words.length;i++)
  10.         {
  11.             String temp=words[i];
  12.             
  13.             //遍历待查找字符串中的每一个字符
  14.             for(int j=0;j<searchWord.length();j++)
  15.             {
  16.                if(j>=temp.length())
  17.                {
  18.                    break;
  19.                }
  20.                else
  21.                {
  22.                   if(searchWord.charAt(j)==temp.charAt(j))//相等就比较下一个字符
  23.                   {
  24.                      if(j==searchWord.length()-1)
  25.                      {
  26.                          return  i+1;
  27.                      }
  28.                      else
  29.                      {
  30.                         continue;
  31.                      }
  32.                   }
  33.                   else//不相等就直接比较下一个单词
  34.                   {
  35.                      break;
  36.                   }
  37.                }
  38.                
  39.             }
  40.         }
  41.         return  -1;
  42.     }
  43. }

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

  1. import java.util.Scanner;
  2. public class Main 
  3. {
  4.     public static void main(String[] args)
  5.     {
  6.         Scanner scanner=new Scanner(System.in);
  7.         String input=scanner.nextLine();
  8.  
  9.         int  result=0;
  10.  
  11.         int i=input.length()-1;
  12.  
  13.         while(i>=0&&input.charAt(i)!=' ')//从后往前遍历字符串中的每一个字符，直到遇到空格
  14.         {
  15.           result++;
  16.           i--;
  17.         }
  18.     
  19.          System.out.println(result);
  20.     }   
  21. }

十六进制转十进制

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Scanner in = new Scanner(System.in);
  4.         String input=in.next();
  5.  
  6.         int result=0;
  7.         
  8.         for(int i=0;i<input.length();)
  9.         {
  10.             char temp=input.charAt(i);
  11.             if(temp>='0'&&temp<='9')
  12.             {
  13.                 result=result*16+(temp-'0');
  14.                 i++;
  15.             }
  16.             else if(temp>='A'&&temp<='F')
  17.             {
  18.                 result=result*16+(temp-'A'+10);
  19.                 i++;
  20.             }
  21.             else
  22.             {
  23.                 i++;
  24.             }
  25.         }
  26.         System.out.println(result);
  27.     }
  28. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/339569
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号