Java String split()-metoden med exempel

Vad är split()-strängen i Java?

Ocuco-landskapet split() metoden låter dig bryta en sträng baserat på en specifik Java strängavgränsare. Oftast är avgränsaren ett mellanslag eller ett kommatecken (,) där du vill bryta strängen.

split() funktionssyntax

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

⚠️ Observera om returtypen: split() returnerar en String[] array, inte en enda StringTilldela resultatet till en slätt String Variabeln misslyckas med att kompilera med ett felmeddelande av typen incompatible-types, vilket är det vanligaste misstaget som nybörjare gör med den här metoden.

Parameter

• Regex: det reguljära uttryck som tillämpas på texten eller strängen.
• Begränsa: det maximala antalet värden i den resulterande arrayen. Om det utelämnas eller är noll returneras varje delsträng som matchar regexen.

Hur man delar upp en sträng Java med avgränsare

Exemplet nedan visar hur man delar upp en sträng i Java med en avgränsare.

Anta att vi har en strängvariabel som heter strMain bildad av några få ord — Alfa, Beta, Gamma, Delta, Sigma — alla separerade med kommatecken (,).

Här om vi vill ha alla individuella strängar, skulle det bästa möjliga mönstret vara att dela upp det baserat på kommatecken. Så vi kommer att få fem separata strängar enligt följande:

• alfa
• beta
• Gamma
• Delta
• Sigma

Använd strängen delas metod i Java mot strängen som behöver delas och ange separatorn som ett argument.

I detta Java dela sträng med skiftläge, avgränsare är ett kommatecken (,) och resultatet av Java dela sträng med komma-operation kommer att ge dig en array-delning.

class StrSplit{
  public static void main(String []args){
   String strMain = "Alpha, Beta, Delta, Gamma, Sigma";
    String[] arrSplit = strMain.split(", ");
    for (int i=0; i < arrSplit.length; i++)
    {
      System.out.println(arrSplit[i]);
    }
  }
}

Slingan i koden skrivs bara ut var och en Java dela strängen från arrayen efter dela-funktionen i Java, enligt nedanstående.

Förväntad produktion:

Alpha
Beta
Delta
Gamma
Sigma

Exempel: Java String split()-metod med regex och längd

Tänk dig en situation där du bara behöver de första 'n' elementen efter delningsfunktionen i Java, men vill att resten av strängen ska förbli som den är. En utdata som liknar detta:

1. alfa
2. beta
3. Delta, Gamma, Sigma

Detta kan uppnås genom att skicka ett annat argument tillsammans med split()-operationen i Java, och det kommer att vara gränsen för antalet strängar som krävs.

Betrakta följande kod för split-metoden i Java:

class StrSplit2{
  public static void main(String []args){
   String strMain = "Alpha, Beta, Delta, Gamma, Sigma";
    String[] arrSplit_2 = strMain.split(", ", 3);
    for (int i=0; i < arrSplit_2.length; i++){
      System.out.println(arrSplit_2[i]);
    }
  }
}

Förväntad produktion:

Alpha
Beta
Delta, Gamma, Sigma

Observera att en gräns på 3 producerar exakt tre element: de två första separatorerna används, och allt efter den andra separatorn hålls ihop som det tredje elementet.

Hur man delar upp en sträng Java av Space

Tänk dig en situation där du vill dela en sträng med mellanslag. Här har vi en delad sträng Java variabel som heter strMain bildad av några få ord: Välkommen till Guru99.

public class StrSplit3{
public static void main(String args[]){
String strMain = "Welcome to Guru99";
String[] arrSplit_3 = strMain.split("\\s");
    for (int i=0; i < arrSplit_3.length; i++){
      System.out.println(arrSplit_3[i]);
    }
  }
}

Förväntad produktion:

Welcome
to
Guru99

Mönstret \\s matchar ett enda blanksteg. Använd \\s+ istället när ord kan separeras med mer än ett mellanslag, annars producerar varje extra mellanslag ett tomt element.

Hur man behåller tomma strängar vid indelning Java

Ett beteende hos split() överraskar nästan alla första gången de möter det: efterföljande tomma strängar kastas tyst bort. "a,b,," på ett kommatecken returnerar två element, inte fyra, eftersom standardgränsen på noll ignorerar alla tomma fält i slutet av arrayen.

Detta är viktigt när data är positionsbaserade – till exempel en CSV-rad där ett saknat värde i slutet fortfarande upptar en kolumn. Om dessa tomrum förloras ändras varje nedströms index.

Passerar a negativ gränsen håller dem:

String row = "Alpha,Beta,,";

// Default: trailing empty fields removed -> length 2
String[] a = row.split(",");
System.out.println(a.length);        // prints 2

// Negative limit: every field preserved -> length 4
String[] b = row.split(",", -1);
System.out.println(b.length);        // prints 4

Tre regler täcker varje fall. En gräns på noll-, vilket är standardinställningen, tillämpar mönstret så många gånger som möjligt och släpper sedan efterföljande tomma strängar. positiv limit tillämpar mönstret högst limit minus en gånger, så det sista elementet håller den orörda resten, precis som det tidigare exemplet med en gräns på 3 visade. negativ limit tillämpar mönstret så många gånger som möjligt och behåller alla tomma fält, inklusive de efterföljande.

Inledande tomma strängar beter sig annorlunda igen: delning ",a,b" ger alltid ett tomt första element oavsett gränsvärde, eftersom mönstret matchar vid position noll. Skydda dig mot detta genom att trimma inmatningen eller genom att filtrera det resulterande elementet. array innan användning.

split() vs StringTokenizer vs Pattern.split(): Vilken ska användas

Java erbjuder tre sätt att dela upp en sträng i bitar. De skiljer sig åt i vilken typ av avgränsare varje sträng accepterar, i vad de returnerar och i huruvida mönstret kompileras en gång eller omkompileras vid varje anrop, vilket spelar roll när delningen sker inuti en loop.

Använda String.split() för vanligt engångsarbete, eftersom det är kortast att skriva och läser tydligt. Förkompilera med Pattern.compile(",").split(text) vid delning inuti en loop, eftersom det reguljära uttrycket då kompileras en gång snarare än vid varje iteration. Undvik StringTokenizer i ny kod; den finns bara kvar för bakåtkompatibilitet.

Gemensam Java split()-fel och hur man åtgärdar dem

Nästan alla problem med split() tracgår tillbaka till en av två orsaker: argumentet är ett reguljärt uttryck snarare än en literal sträng, eller så ignorerar gränsreglerna som beskrivs ovan fält oväntat. Varje fel nedan anger sitt symptom och sin åtgärd.

• Dela på en punkt returnerar en tom array: "1.2.3".split(".") matchar alla tecken, eftersom punkten är ett jokertecken i regex. Använd en escape-tecken split("\\.").
• Att klyva ett rör beter sig konstigt: pipen betyder alternation i regex. Escape det som split("\\|").
• Fel: Inkompatibla typer: resultatet tilldelades en StringDeklarera variabeln som String[].
• Oväntat tomt första element: Avgränsaren visas i början av inmatningen. Trimma strängen först.
• Saknade värden i slutet: efterföljande tomma fält har kasserats av standardgränsen. Godkänd -1 som det andra argumentet.
• NullPointerException: split() anropades på en null-referens. Kontrollera om det finns null innan delning, eftersom metoden inte kan hantera det.

Vanliga frågor