Hoe manipuleren strings in Java

Strings zijn reeksen tekens. Bijvoorbeeld: "Hallo!" is een tekenreeks omdat deze bestaat uit de tekens 'H', 'e', ​​'l', 'l', 'o' en '!'. In Java zijn strings objecten, wat betekent dat er een String-klasse is met velden en methoden. We kunnen de methoden van de klasse String gebruiken om strings te manipuleren.

Methode één van de vijf:
Maak een string

1. 1 Maak een string met behulp van de constructor van de klasse String.

    Draad str = nieuwe Draad("Hallo!"); 

2. 2 Maak een string door direct een string toe te wijzen.
3. 3 Probeer een voorbeeld. Hier is een voorbeeldprogramma dat op twee verschillende manieren een string maakt.

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str1 = nieuwe Draad("String gemaakt met een constructor!"); Draad str2 = "String gemaakt zonder een constructor!"; Systeem.uit.println(str1); Systeem.uit.println(str2);   

Methode twee van vijf:
Zoek de lengte van een string

1. 1 Begrijp wat het betekent om de lengte van een string te vinden. De lengte van een tekenreeks is het aantal tekens dat de tekenreeks bevat. Bijvoorbeeld, de lengte van de string "Hallo!" is 6 omdat het 6 tekens heeft.
2. 2 Roep de lengte() methode op het object String en sla het resultaat op in een geheel getal variabele.

    int strLength = str.lengte(); 

3. 3 Geef het een kans. Hier is een voorbeeldprogramma dat de lengte van een string vindt.

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Hallo!"; int strLength = str.lengte(); Systeem.uit.println("De lengte van \"" + str + "\" is " + strLength + ".");   

Methode drie van vijf:
Keer een reeks om

1. 1 Begrijp wat het betekent om een ​​string om te keren. Een reeks omkeren betekent dat de volgorde van de tekens in een tekenreeks moet worden veranderd. Bijvoorbeeld, het omgekeerde van de string "Hallo!" is "! olleH". Er zijn veel manieren om een ​​tekenreeks in Java om te keren.
2. 2 Gebruik de omgekeerde methode van de klasse StringBuffer. Maak een StringBuffer-object dat de reeks meeneemt die u als parameter wilt omkeren. Gebruik de methode reverse () van StringBuffer en haal de zojuist omgekeerde tekenreeks op met de methode toString ().

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Hallo!"; StringBuffer buffer = nieuwe StringBuffer(str); Draad reversedStr = buffer.omgekeerde().toString(); Systeem.uit.println("Het omgekeerde van de string \"" + str + "\" is \"" + reversedStr + "\".");   

3. 3 Herhaal de tekens in een string in omgekeerde volgorde en voeg deze tekens toe aan een StringBuffer bij elke iteratie. Maak een nieuw StringBuffer-object dat is geïnitialiseerd met de lengte van de reeks die u als parameter wilt omkeren. Gebruik vervolgens een for-lus om de tekenreeks door te voeren, beginnend bij het laatste teken in de tekenreeks en eindigend bij het eerste teken in de tekenreeks. Voeg bij elke iteratie het teken bij die index toe aan de StringBuffer. Haal de nieuw omgekeerde string op met behulp van de methode toString ().

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Hallo!"; StringBuffer buffer = nieuwe StringBuffer(str.lengte()); voor (int ik = str.lengte() - 1; ik >= 0; ik--)  buffer.toevoegen(str.charAt(ik));  Draad reversedStr = buffer.toString(); Systeem.uit.println("Het omgekeerde van de string \"" + str + "\" is \"" + reversedStr + "\".");   

4. 4 Schrijf een recursieve functie om de string om te keren. In de recursieve functie is de basisgeval / voorwaarde dat de tekenreeks nul is of dat de lengte van de tekenreeks kleiner dan of gelijk aan nul is. Anders wordt de methode reverse () opnieuw aangeroepen met de tekenreeks minus het eerste teken en wordt aan het einde het eerste teken opgeplakt. Dus als we de reeks "Hallo!" Hebben doorgegeven, zal de eerste keer achteraan () oproep daarna de parameter "ello!" Hebben.

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Hallo!"; Draad reversedStr = omgekeerde(str); Systeem.uit.println("Het omgekeerde van de string \"" + str + "\" is \"" + reversedStr + "\".");  privaat statisch Draad omgekeerde(Draad str)  als (str == nul || str.lengte() <= 1) terugkeer str; terugkeer omgekeerde(str.substring(1)) + str.charAt(0);   

5. 5 Converteer de tekenreeks naar een reeks tekens en wissel vervolgens de eerste en laatste, tweede en de voorlaatste keer, enzovoort. karakters. Converteer eerst de reeks naar een reeks tekens met behulp van de methode toCharArray () op de tekenreeks. Haal de index op van het laatste teken in de array, wat gelijk is aan de lengte van de array min één. Herhaal dan door de array en wissel de i^th karakter en de indexOfLastChar - i^th teken bij elke iteratie. Converteer de tekenarray ten slotte terug naar een tekenreeks.

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Hallo!"; verkolen[] charArray = str.toCharArray(); int indexOfLastChar = charArray.lengte - 1; voor (int ik = 0; ik < charArray.lengte/2; ik++)  verkolen temp = charArray[ik]; charArray[ik] = charArray[indexOfLastChar - ik]; charArray[indexOfLastChar - ik] = temp;  Draad reversedStr = nieuwe Draad(charArray); Systeem.uit.println("Het omgekeerde van de string \"" + str + "\" is \"" + reversedStr + "\".");   

6. 6 Controleer uw uitvoer. Hier is de uitvoer die resulteert uit een van deze methoden voor het omkeren van een tekenreeks.

Methode vier van vijf:
Trim de witte ruimte in een string

1. 1 Begrijp wat het betekent om witte ruimte in een string in te korten. Trimmen van een tekenreeks in Java betekent het verwijderen van de voorloop- en volgspaties in de reeks. Bijvoorbeeld, als u de string hebt "
   Hallo Wereld!
   en je wilt het laten zeggen "Hallo, wereld!" zonder de witte ruimte in het begin en aan het einde kun je de string inkorten. De klasse String biedt een methode om te trimmen () die een kopie van de tekenreeks retourneert met leidende en volgde witte spaties verwijderd of de originele snaar als deze geen voorlopende of achterliggende witruimte heeft.
2. 2 Gebruik de methode trim () van de klasse String op een object String om de witruimte bij te snijden. Houd er rekening mee dat de trim () -methode een uitzondering oplevert als de tekenreeks null is. De trim () -methode zal de inhoud van de originele tekenreeks niet wijzigen, omdat tekenreeksen in Java onveranderbaar zijn, wat betekent dat de status van een tekenreeks niet kan worden gewijzigd nadat deze is gemaakt. In plaats daarvan retourneert de methode trim () een nieuwe tekenreeks waarvan de witruimte is weggesneden.

    Draad trimmedStr = str.trimmen(); 

3. 3 Probeer een voorbeeld. Hier is een voorbeeldprogramma dat de witte ruimte van een string afsnijdt:

    openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = " Hallo! "; Draad trimmedStr = str.trimmen(); Systeem.uit.println("Original String is \"" + str + "\"."); Systeem.uit.println("Trimmed String is \"" + trimmedStr + "\".");   

Methode vijf van vijf:
Een string splitsen

1. 1 Begrijp wat het betekent om een ​​string te splitsen. Het splitsen van een tekenreeks in Java betekent dat een tekenreeks wordt gesplitst door een bepaald scheidingsteken in een reeks subtekenreeksen. Als ik bijvoorbeeld de tekenreeks "rood, blauw, groen, geel, roze" met een komma als scheidingsteken opsplits, zou ik de matrix "rood", "blauw", "groen", "geel", "roze" krijgen ". Hier zijn drie verschillende manieren om een ​​string te splitsen.
2. 2 Gebruik StringTokenizer tokenize de string. Importeren java.util.StringTokenizer. Maak vervolgens een nieuw exemplaar van a StringTokenizer met de string tokenize en het scheidingsteken als parameters. Als u het scheidingsteken niet als parameter invoert, wordt het scheidingsteken automatisch ingesteld op witruimte. Nadat u de StringTokenizer, je kunt de gebruiken nextToken () methode om elk token te krijgen.

   •  importeren java.util.Arrays; importeren java.util.StringTokenizer; openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Rood, groen, blauw, geel, roze"; StringTokenizer tokenizer = nieuwe StringTokenizer(str, ","); int numberOfTokens = tokenizer.countTokens(); Draad[] splitArr = nieuwe Draad[numberOfTokens]; voor (int ik = 0; ik < numberOfTokens; ik++)  splitArr[ik] = tokenizer.nextToken();  Systeem.uit.println("\ nOriginele tekenreeks: " + str); Systeem.uit.println("Split Array:" + arrays.toString(splitArr) + "\ n");   

   • Vóór Java 1.4, de StringTokenizer class is gebruikt om strings in Java te splitsen. Maar nu, het gebruik van StringTokenizer is ontmoedigd en het gebruik van de split () methode in de Draad klasse of het gebruik van de java.util.regex pakket wordt aangemoedigd.
3. 3 Gebruik de Draad klasse split () methode. De split () methode neemt het scheidingsteken op als een param en retourneert een array van subtekenreeksen die gelijk zijn aan de tokens van de StringTokenizer.

    importeren java.util.Arrays; openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Rood, groen, blauw, geel, roze"; Draad[] splitArr = str.spleet(","); Systeem.uit.println("\ nOriginele tekenreeks: " + str); Systeem.uit.println("Split Array:" + arrays.toString(splitArr) + "\ n");   

4. 4 Gebruik reguliere expressies om de string te splitsen. Importeren java.util.regex.Pattern. Gebruik de compileren() methode van de Patroon class om het scheidingsteken in te stellen en geef dan de split () methode de reeks die u wilt splitsen. De Patroon retourneert een reeks subtekenreeksen.

    importeren java.util.Arrays; importeren java.util.regex.Pattern; openbaar klasse StringManipulation  openbaar statisch leegte hoofd(Draad[] args)  Draad str = "Rood, groen, blauw, geel, roze"; Draad[] splitArr = Patroon.compileren(",").spleet(str); Systeem.uit.println("\ nOriginele tekenreeks: " + str); Systeem.uit.println("Split Array:" + arrays.toString(splitArr) + "\ n");   

5. 5 Controleer uw uitvoer. Hier is de uitvoer die resulteert uit een van deze methoden voor het splitsen van reeksen.