Teilen einer Zeichenfolge in eine Zeichenfolge [] einer bestimmten Größe

Question

Angenommen, mein Trennzeichen ist ',' (Komma), ich bin auf der Suche nach einer Funktion split, die garantiert, dass das zurückgegebene Array String [] eine bestimmte Größe (Nr mehr, nicht weniger):

String[] split(String str, int limit); 

split("hello", 2);    => ["hello", ""] 
split("hello,", 2);    => ["hello", ""] 
split(",hello", 2);    => ["", "hello"] 
split("hello,world", 2);   => ["hello", "world"] 
split("hello,world,goodbye", 2); => ["hello", "world,goodbye"] 

Sehen Sie, wie die Array-Größe immer 2 ist? Ich kann etwas von diesem Verhalten mit Pattern.split bekommen, aber nicht für jeden Fall ... Wie kann ich das tun?

Answer 1

StringUtils.split(string, separator, max) ist sehr nah an dem, was Sie brauchen.

Dann können Sie ArrayUtils.addAll(result, emptyArray) verwenden, wobei emptyArray ein Array der Größe max - result.length ist.

Die Funktionalität, die Sie wollen, ist zu spezifisch, also bezweifle ich, dass es etwas bereit zu verwenden geben wird.

Answer 2

Ich erinnere mich nicht die ganze Syntax von Herzen, aber Ihre Suche auf etwas wie folgt aus:

Pattern p = new Pattern("[^,]+"); 
String[] strings = new String[limit]; 
int offset = 0; 
int i = 0; 
for (; i < limit; i++) { 
    Match m = str.match(p, offset); 
    if (m == null) break; 
    offset += m.string.length + 1; 
    strings[i] = m.string; 
} 
for (; i < limit; i++) { 
    strings[i] = ""; 
} 

Auch dies ist nicht gültig Java

Answer 3

Es scheint, dass es wäre leicht genug, um ein neues Array mit leeren Strings auszupacken. Hier ist eine Hilfsmethode, die Sie verwenden könnten, um diese Aufteilung durchzuführen.

public static String[] split(Pattern pattern, CharSequence input, int limit) { 
    // perform the split 
    tokens = pattern.split(input, limit); 

    int tokenCount = tokens.length(); 
    if (tokenCount == limit) { 
     // if no padding is necessary, return the result of pattern.split 
     return tokens; 
    } else { 
     // create a new array, copy tokens into array, pad with empty string 
     String[] padded = Arrays.copyOf(tokens, limit); 
     for (int i = tokenCount; i < limit; i++) { 
      padded[i] = ""; 
     } 
     return padded; 
    } 
} 

Edit: Aktualisiert stehlen schamlos [Arrays.copyOf] [1] von unholysampler's answer.

[1]: http://download.oracle.com/javase/6/docs/api/java/util/Arrays.html#copyOf(T[], int)

Answer 4

Nun, wenn ich Sie richtig verstanden Sie wollen einfach nur Aufspaltung zu stoppen, sobald Sie die Zählung ein erreicht haben über Argument zur Verfügung gestellt und die verbleibenden Bit vollständig in den letzten bewegen Feld, oder? Zusätzlich sollte der Limit-Parameter immer die Feldanzahl sicherstellen?

Umschließen Sie eine Methode um die Pattern.split() -Methode, die nur Felder hinzufügt, bis Ihr Limit/Schwellenwert/Minimum erreicht ist.

for(i=0;i<limit;++i){ 
//add empty fields to array until limit is reached 
} 

Answer 5

Sie es mit einer Schleife tun könnten, die die Zeichenfolge für den Begrenzer Suche durchsucht, dann verdränge nicht vor dem Trennzeichen in dem Array ist, dann ist es wieder tun, bis er trifft die Spitze Array-Größe, dass wie es gerade, was auch immer als der letzten Eintrag in der Anordnung war vor Rückkehr:

public string[] mySplit(String Split, char Delimiter, int Top) 
{ 
    string[] returned = new string[Top]; 
    for(int i = 0; i < Top; i++){ 
    if(i==Top) 
    { 
    returned[i] = Split; return; 
    } 
    else 
    { 
    int compPlace = 0; 
    char comp = Split.toCharArray()[compPlace]; 
    while(comp != Delimiter) 
    { 
     compPlace++; 
     comp = Split.toCharArray()[compPlace]; 
     } 
    returned[i] = Split.SubString(0,compPlace); 
    Split = Split.SubString(compPlace); 
    } 
    } 
    return returned; 
} 

ich bin sicher, ich werde dies zwicken, wie ich schon jetzt ein wenig Kopfschmerzen :)

Answer 6

Sie können Arrays.copyOf() verwenden, um zurückzukehren ein gepolstertes Array. Die Auffüllung wird jedoch null statt einer leeren Zeichenfolge sein.

String[] parts = Arrays.copyOf("hello,".split(",", 2), 2); 
String[] parts1 = Arrays.copyOf(",hello".split(",", 2), 2); 
String[] parts2 = Arrays.copyOf("hello,world".split(",", 2), 2); 
String[] parts3 = Arrays.copyOf("hello,world,goodbye".split(",", 2), 2); 
String[] parts4 = Arrays.copyOf("hello,".split(",", 2), 4); //null padding 

Answer 7

einfach die Position des Trennzeichen bekommen und Substrings Sie es ziemlich leicht mit bekommt:

public static String[] split(String str, int limit){ 

      String[] arr = new String[limit]; 

      for(int i = 0; i < limit-1; i++){ 
       int position = str.indexOf(','); 
       int length = str.length(); 

       if(position == -1){ 
        arr[i]= str.substring(0,length); 
        str = str.substring(length, length); 
       } 
       else{ 
        arr[i] = str.substring(0, position); 
        str = str.substring(position+1, length); 
       } 
      } 

      arr[limit-1] = str; 

      return arr; 
     }