Förstå delsträng i Java: En grundläggande guide

I den här artikeln hjälper vi dig att förstå delsträngar i Java. Vi kommer inte bara att ge dig en teoretisk förklaring utan också ge dig riktiga kodexempel för att hjälpa dig att visualisera. Vi kommer att lära dig hur du skapar delsträngar och hjälper dig att hitta delsträngar inuti en sträng.

Men innan vi lär oss dem måste vi ha grunderna för delsträngar.

Vad är strängar och delsträngar?

I Java-sammanhang representerar en sträng en sekvens av tecken. Varje sträng i Java är ett objekt. En sträng i Java kan innehålla tecken, symboler och till och med blanksteg. Å andra sidan är en delsträng i Java en del eller en delmängd av en Java-sträng.

Till exempel är ”Geek” en delsträng av ”adminvista.com”. Delsträngar hjälper dig att få en specifik del av en sträng.

Om du har namnet ”John Doe” och du bara vill ha förnamnet ”John”, kan du enkelt få det med understrängar. Dessutom, med tanke på att du har en lista med namn ”John, Jack, Jolly” och du vill ta reda på om ”John” finns i den, kan du också göra det med understrängar. Detta är bara exempel. Vi kan använda delsträngar i olika operationer när vi väl förstår dem.

Eftersom vi nu är medvetna om konceptet med delsträngar i Java, låt oss nu lära oss hur man skapar och arbetar med delsträngar i Java.

#1. Använder metoden ’substring()’

Metoden ’substring()’ låter oss skapa delsträngar mycket enkelt. Den tar upp till två parametrar som indata – startIndex eller både startIndex och endIndex och returnerar den delsträng vi vill ha.

Beroende på antalet parametrar kan vi använda det på två sätt. Låt oss nu lära oss om dem i detalj.

substring(int startIndex)

Till att börja med kan vi använda metoden i formen ’substring(startIndex)’. Här tar denna metod ett heltalsvärde som indata, där ingången är startpositionen för delsträngen. Den returnerar en sträng som börjar från det angivna startindexet till slutet av den ursprungliga strängen.

Som ett exempel, låt oss titta på följande kod:

public class Substrings{    
    public static void main(String args[]){    
    String str="adminvista.com";    
    System.out.println("Given String: " + str);  
    System.out.println("Substring: " +str.substring(4)); //index of strings start from 0
    }  
   }

PRODUKTION:

Given String: adminvista.com
Substring: Flare

Från utgången ser vi att ingångssträngen är ”adminvista.com”, och returvärdet är delsträngen ”Flare”. Den skapar en delsträng från det givna indexet (4), det vill säga från position 5 till slutet av strängen.

substring(int startIndex, int endIndex)

Detta är ett annat sätt att använda delsträngsmetoden för klassen String. Vi kan skicka två heltal till delsträngsmetoden. Ett startindex och ett slutindex. För att använda detta måste vi använda metoden i formatet ’substring(startIndex,endIndex)’.

För att förstå det ytterligare, låt oss titta på några exempelkoder:

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlareFans";    
    System.out.println("Given String: " + str);  
    System.out.println("Substring: " +str.substring(4,9));  //You get a substring starting from index no. 4 to index 8.

    }  
   }

PRODUKTION:

Given String: GeekFlareFans
Substring: Flare

Som vi kan se, med tanke på strängen ”GeekFlareFans”, matar den ut delsträngen ”Flare”. Vi gav startindexet 4 och slutindexet 9. Det börjar från elementet med indexet 4 och slutar före 9. Vi måste notera att det inte skriver ut elementet med slutindexet. Det ger oss en delsträng som inkluderar alla element fram till slutindexet men exkluderar elementet med slutindexet.

#2. Använder metoden ’split()’

’split()’ är en annan metod i klassen String i Java som hjälper oss att skapa en delsträng. Det är användbart när flera delar av information lagras i en sträng med ett gemensamt separatortecken.

Syntaxen nämner termen ”regex” som kan verka lite skrämmande för dig, så låt oss förstå vad regex är innan vi fortsätter. Regex är kortsikten för ”Regular Expressions”. Ett regex är en sekvens av tecken som beskriver ett mönster inuti en sträng eller text. I samband med splitmetoden är regex vår separator.

Metoden ’split()’ kan ta upp till två variabler som indata, de är en regex-sträng och ett limit-heltal. Regexet är separatorn, vilket, när det hittas, resulterar i att den ursprungliga strängen delas i 2 delar – delen före regexet och delen efter regexet.

Anta till exempel att du försöker dela strängen ”abcdef” med ”bcd” som regex. Vi skulle få delsträngarna ”a” och ”ef” som resultat.

Metoden returnerar en array med de separerade strängarna. Vi kan antingen endast ange regex eller både regex och limit. Låt oss lära oss om flera sätt att anropa denna metod en efter en.

split(String regex)

Den första metoden tar bara emot regex-strängen i formatet ”split(regex)”. Den har ingen gränsvariabel; returnerar därför alla separerade delsträngar i en array.

Låt oss få en tydlig förståelse med lite kod:

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare";
    String[] substrings=str.split("%");
    System.out.println("Given String: " + str);
    System.out.println("First Substring: " + substrings[0]);
    System.out.println("Second Substring: " + substrings[1]);
     
    }  
}

PRODUKTION:

Given String: Geek%Flare
First Substring: Geek
Second Substring: Flare

Som vi ser från koden har den givna strängen ett separatorregex ”%”. Det behöver inte vara ett enda tecken, det kan vara vilken sträng som helst med valfritt antal tecken. Metoden ’split()’ ignorerar detta regex och ger oss alla strängar som separerades av detta regex. Delsträngarna lagras i en array.

I koden är den givna strängen ”Geek%Flare”. Så vi får en array med två element i den, som är ”Geek” och ”Flare”. Vi fick senare tillgång till dem med deras respektive index, som är 0,1 respektive, och vi skrev ut ”Geek” och ”Flare” till konsolen.

Här bör vi också notera att om inga parametrar skickas till metoden kommer den helt enkelt att ge ett fel. Men om vi ger en tom sträng (“”) som ett regex, kommer vi att få varje enskilt tecken som en delsträng. Låt oss titta på exemplet för att visualisera.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare";
    String[] substrings=str.split("");
    System.out.println(Arrays.toString(substrings));
     
    }  
}

PRODUKTION:

[G, e, e, k, %, F, l, a, r, e]

Från exemplet är det uppenbart eftersom regex-parametern är en tom sträng, den returnerar alla tecken som separata delsträngar, och vi kan tydligt se detta genom att skriva ut utgångsmatrisen för ’split()’-metoden.

split(String regex,int limit)

Med den andra varianten av denna metod får vi mer kontroll över utdata, och vi kan finjustera utdata från metoden ’split()’ ytterligare. Här tar metoden ’split()’ två variabler som indata. I det här fallet ger vi tillsammans med regexet också en limitparameter i det angivna formatet ”split(regex, limit)”.

’Gränsen’ är antalet resulterande strängar som matas ut. Beroende på gränsens värde kan det finnas tre möjligheter:

Fall 1: Om limit>0, skulle den resulterande matrisen innehålla utdata, men den skulle tillämpa splittiden (limit-1) gånger som mest. Här skulle den resulterande arrayen inte innehålla fler element än den angivna gränsen, och all överbliven sträng som inte är delad skulle lagras som den var. Låt oss göra det lättare att förstå med lite kod.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%the%best";
    String[] substrings=str.split("%",2);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

PRODUKTION:

[Geek, Flare%is%the%best]

Se i utgången hur det bara finns två element i resultatmatrisen som är det antal som anges i limitparametern. Lägg också märke till att uppdelningen endast tillämpas en gång, alltså (limit-1) gånger.

Men om det regex finns där två gånger i rad (”%%”), skulle det ha tomma delsträngar. Titta på den här koden för att förstå den bättre.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%%the%best%%%";
    String[] substrings=str.split("%",5);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

PRODUKTION:

[Geek, Flare, is, , the%best%%%]

I grund och botten, om ”%” följs av en annan ”%” eller slutet av strängen, förvandlas den till en tom delsträng.

Fall 2: Om limit<0, skulle den delade åtgärden tillämpas så många gånger det är möjligt utan någon gräns för matrisstorleken, men matrisen skulle innehålla tomma delsträngar om regexet finns där två gånger i rad ("%%").

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%%the%best%%%";
    String[] substrings=str.split("%",-1);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

PRODUKTION:

[Geek, Flare, is, , the, best, , , ]

Från utgången är det uppenbart att uppdelningen tillämpas så många gånger som möjligt, och det finns även tomma delsträngar.

Fall 3: Om limit=0, skulle split-åtgärden också tillämpas så många gånger som möjligt, men här skulle alla tomma delsträngar i slutet av strängen kasseras från arrayen.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%%the%best%%%";
    String[] substrings=str.split("%",0);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

PRODUKTION:

[Geek, Flare, is, , the, best]

Vi kan se att utdata är ganska lika mellan när limit=-1 och när limit=0, men det finns inga efterföljande tomma delsträngar. Med andra ord ignoreras de tomma delsträngarna i slutet av delsträngsmatrisen.

Observera också att om det regex inte finns i strängen, returnerar det hela den ursprungliga strängen som resultat.

Ta reda på om en sträng innehåller en delsträng

Förutom att skapa delsträngar från befintliga strängar kan vi också specificera en delsträng och ta reda på om den delsträngen finns i en sträng. Detta är ett snabbt och enkelt sätt att fråga efter en delsträng, och detta är användbart i många användningsfall. Men hur gör vi det? Olika metoder kan hjälpa oss att uppnå detta. Låt oss gå igenom dem en efter en.

Använder metoden ’contains()’:

Vi kan mycket enkelt hitta förekomsten av en delsträng med metoden ’contains()’. Denna metod för String Class tar en sträng som indata, vilket är vår delsträng, och returnerar ett booleskt värde som kontrollerar om delsträngen är inuti strängen eller inte. Den här metoden kan användas i if-else-block, unära operatorer och olika andra ställen för att implementera komplex logik.

Låt oss lära känna denna metod lite mer.

public class Substrings{    
    public static void main(String args[]){    
    String str="adminvista.com";    
    System.out.println("Does it contain Flare? n"+ str.contains("Flare"));  
    }  
}

PRODUKTION:

Does it contain Flare? 
true

Koden kontrollerar strängen ”adminvista.com” för ordet ”Flare”, och när den hittas framgångsrikt returnerar den ett booleskt ”true”, vilket bekräftar existensen av delsträngen.

public class Substrings{    
    public static void main(String args[]){    
    String str="adminvista.com";    
    System.out.println("Does it contain Flare? n"+ str.contains("Flare1"));  
    }  
}

PRODUKTION:

Does it contain Flare? 
false

Från exemplet förstår vi att om delsträngen inte är inuti strängen kommer metoden att returnera false för att indikera att den inte finns. Så vi kan lätt vara säkra på om delsträngen finns.

Hitta positionen för en delsträng

#1. Använder ’indexOf()’:

Metoden ’indexOf()’ kan användas för att hitta förekomsten av en delsträng och även hitta dess index. Metoden tar som indata en sträng eller ett tecken och ger oss positionen för dess första förekomst. Men den kan bara ge oss indexet för den första förekomsten och kan inte bekräfta om andra förekomster av detta finns. En annan sak att notera här, om delsträngen inte finns, returnerar metoden -1.

Så låt oss utforska den här metoden lite mer.

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlareGeekFlare";    
    System.out.println("Index of Flare: "+ str.indexOf("Flare"));  
    }  
}

PRODUKTION:

Index of Flare: 4

Här i exemplet börjar den första förekomsten av delsträngen ”Flare” från index 4 i strängen ”GeekFlareGeekFlare”. Så, som förväntat, returnerade funktionen indexet.

#2. Med ’lastIndexOf()’:

’lastIndexOf()’ är mycket lik ’indexOf()’. Båda dessa metoder tar delsträngen som indata och returnerar indexet för dess position. Den har till och med samma returvärde när den inte kan hitta delsträngen i den angivna strängen. Båda dessa metoder returnerar -1 för ett misslyckat fynd.

Men medan ’indexOf()’ returnerar indexet för den första förekomsten av delsträngen, returnerar ’lastIndexOf()’ den sista förekomsten.

Låt oss se det i aktion genom kod:

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlareGeekFlare";    
    System.out.println("Last index of Flare: "+ str.lastIndexOf("Flare"));  
    }  
}

PRODUKTION:

Last index of Flare:13

När vi observerar denna utdata förstår vi att metoden ’lastIndexOf()’ beter sig som förväntat och vi får indexet för den senaste förekomsten av delsträngen ”Flare” i strängen ”GeekFlareGeekFlare”.

Vanliga frågor

Hur använder man metoden ’split()’ för att skapa icke-tomma delsträngar?

Om det finns flera regex-instanser av regex-strängen i huvudsträngen efter varandra (”Hello%%Hi”, där regex är ”%”), betraktar ’split()’-metoden den första instansen som ett break-tecken, och resten ger utdata från en tom sträng. För att mildra detta kan vi specificera limit-parametern som 0. Därför ger den endast icke-tomma strängar som utdata.

Returnerar ’indexOf()’ index för alla instanser av en delsträng?

Nej, ’indexOf()’ returnerar inte index för alla instanser av en delsträng. Med ’indexOf()’ får vi ett heltalsreturvärde som innehåller indexet för den första förekomsten av delsträngen. Men om den inte kan hitta delsträngen kommer metoden att returnera -1.

Vad returnerar metoden ’substring()’ om de givna indexen inte finns i strängen?

Om det givna startindexet och slutindexet inte finns i strängen, kommer kompilatorn att ge ett fel. Felet ska ha ”java.lang.StringIndexOutOfBoundsException: ” och det kommer helt enkelt inte att köras.

Slutsats

I den här artikeln diskuterade vi olika metoder och väsentligheter för att komma igång med delsträngar. Vi diskuterade att skapa en delsträng och kontrollera förekomsten av en delsträng i en sträng. Detta kommer att ge dig en bättre förståelse för hur du arbetar med delsträngar. Följ exemplen och öva mer för att få en grundlig förståelse av delsträngar.

Därefter kan du kolla vår lista med Java-intervjufrågor.