java字符串切割

標簽（空格分隔）： java

方法一：split() 方法——JDK 1.4 or later##

例子：

public class StringSplit {
    public static void main(String[] args) {
    //一般用法
        String sourceStr = "1,2,3,4,5";
        String[] sourceStrArray = sourceStr.split(",");
        for (int i = 0; i < sourceStrArray.length; i++) {
            System.out.println(sourceStrArray[i]);
        }

        // 限定最多分割出3個字符串
        int maxSplit = 3;
        sourceStrArray = sourceStr.split(",", maxSplit);
        for (int i = 0; i < sourceStrArray.length; i++) {
            System.out.println(sourceStrArray[i]);
        }
    }
}
//輸出結果：
1
2
3
4
5
1
2
3,4,5

分隔符如果用到一些特殊字符，可能會得不到我們預期的結果。在正則表達式中有特殊的含義的字符，我們使用的時候必須進行轉義

public class StringSplit {
    public static void main(String[] args) {
        String value = "192.168.128.33";
        // 注意要加\\,要不出不來,yeah
        String[] names = value.split("\\.");
        //String[] output = test.split(Pattern.quote("."));
        //使用 \\ 跟使用Pattern.quote的效果一樣
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}
//轉義字符總結
1.字符 "|"  "*"  "+"  "."  "," 在正則表達式中用\\.表示，或者用Pattern.quote方法表示。
2.而如果是"\"，那么就得寫成"\\\\"。
3.如果一個字符串中有多個分隔符，可以用"|"作為連字符。

字符串中有多個分隔符，可以用"|"作為連字符的例子：

public static void main(String[] args)
    {
            
            String str ="Java string-split#test";
            String[] sourceStrArray = str.split(" |-|#");
 //注意上面的(" |-|#")的一開始的字符就是空格，看上去好像沒寫一樣喔
            for (int i = 0; i < sourceStrArray.length; i++) {
                System.out.println(sourceStrArray[i]);
            }
    }

有時在分割字符串之前需要對字符串進行一些檢查，如：

public static void main(String[] args)
{

        String test = "abc.def.123";
        //開始檢查
        if(test.contains(".")){
             String[] output = test.split("\\.");
             //第二次檢查
                if(output.length!=3){
throw new IllegalArgumentException(test + " - invalid format!");
                 }else{
                    System.out.println(output[0]);
                    System.out.println(output[1]);
                    System.out.println(output[2]);
                        }
                }else{
throw new IllegalArgumentException(test + " - invalid format!");
                }
                
        }

高級用法：結合正則表達式
但是使用正則的話，效率肯定是有問題的

public class Test01 {  
    public static void main(String[] args) {  
        String str = "one123";  
        String regex = "(?<=one)(?=123)";  
        // String regex = "(?<=one)"; 效果和上面的那句一樣
        String[] strs = str.split(regex);  
        for(int i = 0; i < strs.length; i++) {  
            System.out.printf("strs[%d] = %s%n", i, strs[i]);  
        }  
    }  
}  
結果輸出：
strs[0] = one
strs[1] = 123
為什么呢？表示對正則表達式不是太懂？？？？

方法二：StringTokenizer ——從JDK1.0開始便可以使用StringTokenizer，JDK1.4開始才有String.split()。

注意：StringTokenizer是老版本對方法，因為兼容性的原因不鼓勵使用，推薦使用String.split()。但是StringTokenizer效率高，在后文的三種方法的比較中會說到

簡單用法例子：

public static void main(String[] args) {
     String test = "abc.def.123";
      StringTokenizer token = new StringTokenizer(test, ".");
            while (token.hasMoreTokens()) {
             //利用循環來獲取字符串str1中下一個語言符號
                System.out.println(token.nextToken());
            }
        }
輸出結果：
abc
def
123

格外注意：對于兩個分隔符之間的空字符串會忽略。例如：

 public static void main(String[] args) {
       String ip = "192.168.123..33";//兩個點之間是空字符串
//   String ip = "192.168.123. .33";//兩個點之間是空格
        StringTokenizer token=new StringTokenizer(ip,".");  
        while(token.hasMoreElements()){
//注意這里用的是hasMoreElements()跟hasMoreTokens()效果一樣
         System.out.print(token.nextToken()+"  ");  
        } 

    }
輸出結果：192  168  123  33 //注意"192.168.128...33"中間的...這三個點中間是有兩個空字符串，是空字符串，而不是空格喔！！因為是空字符串，所以切出來的也是空，什么都沒有

例子二：
int num1 = strT1.countTokens();//獲取字符串str1后的個數
hasMoreElements()跟hasMoreTokens()效果一樣
String nextToken()
返回此 string tokenizer 的下一個標記。
String nextToken(String delim)
返回此 string tokenizer 的字符串中的下一個標記。

public static void main(String[] args)
    {
            String str1 = "Hello world!This is Java code,stringTokenizer Demo.";
            //聲明并初始化字符串str1
            String str2 = "How to use StringTokenizer?StringTokenizer?";
            //聲明并初始化字符串str2
            StringTokenizer strT1 = new StringTokenizer(str1," ,.!");
            //創建StringTokenizer類的對象strT1,并構造字符串str1的分析器
            //以空格符、","、"."及"!"作為定界符
            StringTokenizer strT2 = new StringTokenizer(str2," ?");
            //創建StringTokenizer類的對象strT2,并構造字符串str2的分析器
            //以空格符及"?"作為定界符
            int num1 = strT1.countTokens();
            //獲取字符串str1中語言符號的個數
         int num2 = strT2.countTokens();
            //獲取字符串str2中語言符號的個數
            System.out.println("str1 has "+num1+" words.They are:");
            while(strT1.hasMoreTokens())
            {   //利用循環來獲取字符串str1中下一個語言符號,并輸出
                   String str = strT1.nextToken();
                   System.out.print("\""+str+"\" ");
            }
            System.out.println("\nstr2 has "+num2+" words.They are:");
            while(strT2.hasMoreElements())
            {   //利用循環來獲取字符串str2中下一個語言符號,并輸出
                    String str = strT2.nextToken();
                   System.out.print("\""+str+"\" ");
            }
    }

注意還有一個一個參數的StringTokenizer(String str)構造方法
使用默認的定界符，即空格符（如果有多個連續的空格符，則看作是一個）、換行符、回車符、Tab符號等
例子;

    String str1 ="A B   \nC";//情況一C，將空格符、換行符作為定界符，多個連續的空格符，則看作是一個
    //String str1 ="A B   \\nC";情況二，在情況一的基礎上將換行符用“\”轉義了
    StringTokenizer strT1 = new StringTokenizer(str1);
     while(strT1.hasMoreTokens())
        {   //利用循環來獲取字符串str1中下一個語言符號,并輸出
                   String str = strT1.nextToken();
                   System.out.print("'"+str+"'");
            }
輸出結果：情況一：'A''B''C'
          情況二：'A''B''\nC'

方法三：使用String的兩個方法—indexOf()和subString()——subString()是采用了時間換取空間技術，因此它的執行效率相對會很快，只要處理好內存溢出問題，但可大膽使用。而indexOf()函數是一個執行速度非常快的方法##

1、substring(int begin);截取掉s從首字母起長度為begin的字符串，將剩余字符串賦值給s；

 String text ="我愛你";
            String temp= text.substring(1);
            System.out.println(temp); 
輸出：愛你

2、substring(int begin，int end);截取s中從begin開始至end結束時的字符串，并將其賦值給s;注意：不包括end

  String text ="我愛你們";
            String temp= text.substring(0,2);
            System.out.println(temp); 
輸出:我愛

3、indexOf(subString[, startIndex])返回 String 對象內第一次出現子字符串的字符位置。 如果沒有找到子字符串，則返回 -1。
subString 必選項。要在 String 對象中查找的子字符串。
starIndex 可選項。該整數值指出在 String 對象內開始查找的索引。如果省略，則從字符串的開始處查找。

額外注意的：charAt()：charAt()方法可用來獲取指定位置的字符串，index為字符串索引值，從0開始到string.leng - 1，若不在這個范圍將返回一個空字符串

var str = 'abcde';
console.log(str.charAt(2));        //返回c
console.log(str.charAt(8));        //返回空字符串

lastIndexOf()語法與indexOf()類似，它返回的是一個指定的子字符串值最后出現的位置，其檢索順序是從后向前。

將indexOf()和subString()結合來截取的例子

//這個做法十分巧妙
public static void out(){
        String str = "我愛你們,你愛他,他愛她們加一,她愛他";  
//因為不知道到底截取完之后有多少個，所以用集合保存
        List  stringList =new ArrayList<String>();
        String temp = str;  
            while (true) {  
                String splitStr = null; 
                int index = temp.indexOf(",");  
                if (index < 0) {  
                    break;  
                }  
                splitStr = temp.substring(0, index);  
                System.out.println(splitStr);
                stringList.add(splitStr);
                temp = temp.substring(index + 1);  
            }  
    }

如果十分有規律的話，也可以像下面這樣做


此處輸入圖片的描述
此處輸入圖片的描述

上面的做法雖然是可以但是有點笨，其實可以有聰明點的做法：

適合情況：當分隔符是一個字符時
private static List<String> split2( final String str )
{
    final List<String> res = new ArrayList<String>( 10 );
    int pos, prev = 0;
    while ( ( pos = str.indexOf("" + m_separatorChar, prev ) ) != -1 )
    {
        res.add( str.substring( prev, pos ) );
        prev = pos + 1; // start from next char after separator
    }
    res.add( str.substring( prev ) );
    return res;
}

適合情況：當分隔符是多個字符時
private static List<String> split( final String str )
{
    final List<String> res = new ArrayList<String>( 10 );
    int pos, prev = 0;
    while ( ( pos = str.indexOf( m_separator, prev ) ) != -1 )
    {
        res.add( str.substring( prev, pos ) );
        prev = pos + m_separator.length(); // start from next char after separator
    }
    res.add( str.substring( prev ) );
    return res;
}

三種方法的比較：##

1、String.split（String.split是用正則表達式匹配，所以不使用KMP字符串匹配算法）用的都是按順序遍歷的算法，時間復雜度O(m*n)，較高，所以性能上，StringTokenizer好很多，對于頻繁使用字符串分割的應用，例如etl數據處理，使用StringTokenizer性能可以提高很多。

2、在split需要被大量調用的場合，在現有的Android VM里面，String類的split方法肯定是不符合要求的，StringTokenizer是最廉價的替換split的方法，簡單修改成這個實現之后，花費時間能提升一個數量級

3、indexOf結合subString經過充分的優化，對于結構化特別是表格類的數據，效率是最快的

Java 字符串操作常用的各種的方法

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 第5章 引用類型(返回首頁) 本章內容 使用對象 創建并操作數組 理解基本的JavaScript類型 使用基本類型...
    大學一百閱讀 3,271評論 0贊 4
  • Javascript有很多字符串的方法，有的人有W3C的API，還可以去MDN上去找，但是我覺得API上說的不全，...
    頑皮的雪狐七七閱讀 2,226評論 0贊 2
  • 1. Java基礎部分 基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語...
    子非魚_t_閱讀 31,779評論 18贊 399
  • 1 當你看到標題，有沒有立刻想到田震的那首歌曲：“我家住在黃土高坡，大風從坡上刮過，不管是西北風，還是東南風，都是...
    小苜蓿閱讀 753評論 18贊 15
  • 1 環境搭建 查看php環境信息 2 下載地址 Laravel 中文網 Laravel 利用 Composer（C...
    捔落纏綿閱讀 1,886評論 0贊 0