String.split()分割字符串，转义字符

1、String.split()

String有个方法是分割字符串  .split()。但是有写字符串是需要转义才能分割，不然就会出错。

需要转义的字符串：.  $  |   (   )  [   {   ^  ?  *  +  \\      共12个特殊字符，遇到以这些字符进行分割字符串的时候，需要在这些特殊字符前加双反斜杠 \\

例如：

str.split("\\.")

str.split("\\$")

str.split("\\|")  

str.split("\\(")  

str.split("\\)") 

str.split("\\[")

str.split("\\{")

str.split("\\^")  

str.split("\\?")  

str.split("\\*") 

str.split("\\+")

str.split("\\\\")

2、源码：

 

  

   

    

   
   

    

     public String[] split(String regex) {
    
   
  

   

    

   
   

    

             
     return split(regex, 
     0);
    
   
  

   

    

   
   

    

         } 
    
   
  

   

    

   
   

    

     public String[] split(String regex, 
     int limit) {
    
   
  

   

    

   
   

    
 
     /* fastpath if the regex is a
    
   
  

   

    

   
   

    

      (1)one-char String and this character is not one of the
    
   
  

   

    

   
   

    

      RegEx's meta characters ".$|()[{^?*+\\", or
    
   
  

   

    

   
   

    

      (2)two-char String and the first char is the backslash and
    
   
  

   

    

   
   

    

      the second is not the ascii digit or ascii letter.
    
   
  

   

    

   
   

    

      */
    
   
  

   

    

   
   

    
 
     char ch = 
     0;
    
   
  

   

    

   
   

    
 
     if (((regex.value.length == 
     1 &&
    
   
  

   

    

   
   

    
 
      ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
    
   
  

   

    

   
   

    

      (regex.length() == 
     2 &&
    
   
  

   

    

   
   

    

      regex.charAt(
     0) == 
     '\\' &&
    
   
  

   

    

   
   

    

      (((ch = regex.charAt(
     1))-
     '0')|(
     '9'-ch)) < 
     0 &&
    
   
  

   

    

   
   

    

      ((ch-
     'a')|(
     'z'-ch)) < 
     0 &&
    
   
  

   

    

   
   

    

      ((ch-
     'A')|(
     'Z'-ch)) < 
     0)) &&
    
   
  

   

    

   
   

    

      (ch < Character.MIN_HIGH_SURROGATE ||
    
   
  

   

    

   
   

    

      ch > Character.MAX_LOW_SURROGATE))
    
   
  

   

    

   
   

    

      {
    
   
  

   

    

   
   

    
 
     int off = 
     0;
    
   
  

   

    

   
   

    
 
     int next = 
     0;
    
   
  

   

    

   
   

    
 
     boolean limited = limit > 
     0;
    
   
  

   

    

   
   

    

      ArrayList<String> list = 
     new ArrayList<>();
    
   
  

   

    

   
   

    
 
     while ((next = indexOf(ch, off)) != -
     1) {
    
   
  

   

    

   
   

    
 
     if (!limited || list.size() < limit - 
     1) {
    
   
  

   

    

   
   

    

      list.add(substring(off, next));
    
   
  

   

    

   
   

    

      off = next + 
     1;
    
   
  

   

    

   
   

    

      } 
     else { 
     // last one
    
   
  

   

    

   
   

    
 
     //assert (list.size() == limit - 1);
    
   
  

   

    

   
   

    

      list.add(substring(off, value.length));
    
   
  

   

    

   
   

    

      off = value.length;
    
   
  

   

    

   
   

    
 
     break;
    
   
  

   

    

   
   

    

      }
    
   
  

   

    

   
   

    

      }
    
   
  

   

    

   
   

    
 
     // If no match was found, return this
    
   
  

   

    

   
   

    
 
     if (off == 
     0)
    
   
  

   

    

   
   

    
 
     return 
     new String[]{
     this};
    
   
  

   

    

   
   

    
 
    
   
  

   

    

   
   

    
 
     // Add remaining segment
    
   
  

   

    

   
   

    
 
     if (!limited || list.size() < limit)
    
   
  

   

    

   
   

    

      list.add(substring(off, value.length));
    
   
  

   

    

   
   

    
 
    
   
  

   

    

   
   

    
 
     // Construct result
    
   
  

   

    

   
   

    
 
     int resultSize = list.size();
    
   
  

   

    

   
   

    
 
     if (limit == 
     0)
    
   
  

   

    

   
   

    
 
     while (resultSize > 
     0 && list.get(resultSize - 
     1).length() == 
     0)
    
   
  

   

    

   
   

    

      resultSize--;
    
   
  

   

    

   
   

    

      String[] result = 
     new String[resultSize];
    
   
  

   

    

   
   

    
 
     return list.subList(
     0, resultSize).toArray(result);
    
   
  

   

    

   
   

    

      }
    
   
  

   

    

   
   

    
 
     return Pattern.compile(regex).split(
     this, limit);
    
   
  

   

    

   
   

    

      }