Strings sind Zeichenfolgen. Beispiel: "Hallo!" ist ein String, da er aus den Zeichen 'H', 'e', 'l', 'l', 'o' und '!' besteht. In Java sind Strings Objekte, was bedeutet, dass es eine String-Klasse mit Feldern und Methoden gibt. Wir können die Methoden der String-Klasse verwenden, um Strings zu manipulieren.
Schritte
Methode 1 von 5: Erstellen Sie eine Zeichenfolge
Schritt 1. Erstellen Sie einen String mit dem Konstruktor der String-Klasse
String str = new String("Hallo!");
Schritt 2. Erstellen Sie eine Zeichenfolge, indem Sie eine Zeichenfolge direkt zuweisen
Schritt 3. Probieren Sie ein Beispiel aus
Hier ist ein Beispielprogramm, das eine Zeichenfolge auf zwei verschiedene Arten erstellt.
public class StringManipulation { public static void main(String args) { String str1 = new String("String erstellt mit einem Konstruktor!"); String str2 = "String ohne Konstruktor erstellt!"; System.out.println(str1); System.out.println(str2); } }
Methode 2 von 5: Finden Sie die Länge einer Zeichenfolge
Schritt 1. Verstehen Sie, was es bedeutet, die Länge einer Zeichenfolge zu ermitteln
Die Länge einer Zeichenfolge ist die Anzahl der Zeichen, die die Zeichenfolge enthält. Die Länge der Zeichenfolge "Hallo!" ist 6, weil es 6 Zeichen hat.
Schritt 2. Rufen Sie die auf
Länge()
-Methode auf das String-Objekt und speichern Sie das Ergebnis in einer Integer-Variablen.
int strLength = str.length();
Schritt 3. Probieren Sie es aus
Hier ist ein Beispielprogramm, das die Länge einer Zeichenfolge ermittelt.
public class StringManipulation { public static void main(String args) { String str = "Hallo!"; int strLength = str.length(); System.out.println("Die Länge von \"" + str + "\" ist " + strLength + "."); } }
Methode 3 von 5: Umkehren einer Zeichenfolge
Schritt 1. Verstehen Sie, was es bedeutet, eine Zeichenfolge umzukehren
Eine Zeichenfolge umzukehren bedeutet, die Reihenfolge der Zeichen in einer Zeichenfolge zu ändern. Zum Beispiel die Umkehrung der Zeichenfolge "Hello!" ist "!olleH". Es gibt viele Möglichkeiten, einen String in Java umzukehren.
Schritt 2. Verwenden Sie die umgekehrte Methode der StringBuffer-Klasse
Erstellen Sie ein StringBuffer-Objekt, das die Zeichenfolge, die Sie umkehren möchten, als Parameter aufnimmt. Verwenden Sie die reverse()-Methode von StringBuffer und rufen Sie dann die neu umgekehrte Zeichenfolge mithilfe der toString()-Methode ab.
public class StringManipulation { public static void main(String args) { String str = "Hallo!"; StringBuffer-Puffer = new StringBuffer(str); String reversedStr = buffer.reverse().toString(); System.out.println("Die Umkehrung der Zeichenfolge \"" + str + "\" ist \"" + reversedStr + "\"."); } }
Schritt 3. Durchlaufen Sie die Zeichen in einer Zeichenfolge in umgekehrter Reihenfolge und hängen Sie diese Zeichen bei jeder Iteration an einen StringBuffer an
Erstellen Sie ein neues StringBuffer-Objekt, das mit der Länge des Strings initialisiert ist, den Sie als Parameter umkehren möchten. Verwenden Sie dann eine for-Schleife, um die Zeichenfolge zu durchlaufen, beginnend beim letzten Zeichen in der Zeichenfolge und endend beim ersten Zeichen in der Zeichenfolge. Hängen Sie bei jeder Iteration das Zeichen an diesem Index an den StringBuffer an. Rufen Sie die neu umgekehrte Zeichenfolge mithilfe der Methode toString() ab.
public class StringManipulation { public static void main(String args) { String str = "Hallo!"; StringBuffer Puffer = new StringBuffer(str.length()); for (int i = str.length() - 1; i >= 0; i--) { Buffer.append (str.charAt(i)); } String reversedStr = buffer.toString(); System.out.println("Die Umkehrung der Zeichenfolge \"" + str + "\" ist \"" + reversedStr + "\"."); } }
Schritt 4. Schreiben Sie eine rekursive Funktion, um die Zeichenfolge umzukehren
In der rekursiven Funktion ist der Basisfall / die Bedingung, wenn die Zeichenfolge null ist oder wenn die Länge der Zeichenfolge kleiner oder gleich null ist. Andernfalls wird die Methode reverse() erneut mit dem String minus dem ersten Zeichen aufgerufen und das erste Zeichen am Ende angeheftet. Wenn wir also den String "Hello!" übergeben haben, hat der erste reverse()-Aufruf danach den Parameter "ello!".
public class StringManipulation { public static void main(String args) { String str = "Hallo!"; String reversedStr = reverse(str); System.out.println("Die Umkehrung der Zeichenfolge \"" + str + "\" ist \"" + reversedStr + "\"."); } private static String reverse(String str) { if (str == null || str.length() <= 1) return str; Return reverse(str.substring(1)) + str.charAt(0); } }
Schritt 5. Wandeln Sie die Zeichenfolge in ein Array von Zeichen um und tauschen Sie dann den ersten und den letzten, den zweiten und den zweiten mit dem letzten usw. aus
Zeichen. Konvertieren Sie zuerst den String in ein Array von Zeichen, indem Sie die toCharArray()-Methode für den String verwenden. Rufen Sie den Index des letzten Zeichens im Array ab, der der Länge des Arrays minus eins entspricht. Dann iteriere das Array und vertausche das iNS Zeichen und der indexOfLastChar - iNS Zeichen bei jeder Iteration. Konvertieren Sie schließlich das Zeichenarray zurück in eine Zeichenfolge.
public class StringManipulation { public static void main(String args) { String str = "Hallo!"; char charArray = str.toCharArray(); int indexOfLastChar = charArray.length - 1; for (int i = 0; i < charArray.length/2; i++) { char temp = charArray; charArray = charArray[indexOfLastChar - i]; charArray[indexOfLastChar - i] = temp; } String reversedStr = new String(charArray); System.out.println("Die Umkehrung der Zeichenfolge \"" + str + "\" ist \"" + reversedStr + "\"."); } }
Schritt 6. Überprüfen Sie Ihre Ausgabe
Hier ist die Ausgabe, die aus einer dieser Methoden für die Zeichenfolgenumkehr resultiert.
Methode 4 von 5: Leerraum in einer Zeichenfolge kürzen
Schritt 1. Verstehen Sie, was es bedeutet, Leerzeichen in einer Zeichenfolge zu entfernen
Das Trimmen einer Zeichenfolge in Java bedeutet, den führenden und abschließenden Leerraum in der Zeichenfolge zu entfernen. Wenn Sie beispielsweise die Zeichenfolge"
Hallo Welt!
" und Sie möchten "Hallo, Welt!" ohne Leerzeichen am Anfang und am Ende sagen, können Sie den String trimmen. Die String-Klasse stellt eine Methode für trim() bereit, die eine Kopie des Strings mit. zurückgibt führende und nachgestellte Leerzeichen entfernt oder die ursprüngliche Zeichenfolge, wenn sie keine führenden oder nachgestellten Leerzeichen enthält.
Schritt 2. Verwenden Sie die trim()-Methode der String-Klasse für ein String-Objekt, um den Leerraum zu trimmen
Beachten Sie, dass die Methode trim() eine Ausnahme auslöst, wenn der String null ist. Die Methode trim() ändert den Inhalt des ursprünglichen Strings nicht, da Strings in Java unveränderlich sind, was bedeutet, dass der Zustand eines Strings nach seiner Erstellung nicht geändert werden kann. Stattdessen gibt die Methode trim() einen neuen String zurück, dessen Leerraum abgeschnitten ist.
String trimmedStr = str.trim();
Schritt 3. Probieren Sie ein Beispiel aus
Hier ist ein Beispielprogramm, das den Leerraum einer Zeichenfolge kürzt:
public class StringManipulation { public static void main(String args) { String str = "Hallo!"; String trimmedStr = str.trim(); System.out.println("Original-String ist \"" + str + "\"."); System.out.println("Getrimmter String ist \"" + trimmedStr + "\"."); } }
Methode 5 von 5: Teilen Sie eine Zeichenfolge
Schritt 1. Verstehen Sie, was es bedeutet, eine Zeichenfolge zu teilen
Das Aufteilen eines Strings in Java bedeutet, einen String durch ein bestimmtes Trennzeichen in ein Array von Teilstrings aufzuteilen. Wenn ich zum Beispiel die Zeichenfolge "red, blue, green, yellow, pink" mit einem Komma als Trennzeichen auftrenne, würde ich das Array { "red", "blue", "green", "yellow", "pink." erhalten "}. Hier sind drei verschiedene Möglichkeiten, eine Zeichenfolge zu teilen.
Schritt 2. Verwenden Sie
StringTokenizer
um die Zeichenfolge zu tokenisieren.
Importieren
java.util. StringTokenizer
. Erstellen Sie dann eine neue Instanz von a
StringTokenizer
mit der zu tokenisierenden Zeichenfolge und dem Trennzeichen als Parameter. Wenn Sie das Trennzeichen nicht als Parameter eingeben, wird das Trennzeichen automatisch auf Leerzeichen gesetzt. Nachdem Sie die
StringTokenizer
du kannst den … benutzen
nextToken()
-Methode, um jedes Token abzurufen.
java.util. Arrays importieren; import java.util. StringTokenizer; public class StringManipulation { public static void main(String args) { String str = "rot, grün, blau, gelb, pink"; StringTokenizer-Tokenizer = new StringTokenizer(str, ", "); int numberOfTokens = tokenizer.countTokens(); String splitArr = new String[numberOfTokens]; for (int i = 0; i < numberOfTokens; i++) { splitArr = tokenizer.nextToken(); } System.out.println("\nOriginal-String: " + str); System.out.println("Split Array: " + Arrays.toString(splitArr) + "\n"); } }
Vor Java 1.4 war die
StringTokenizer
-Klasse wurde verwendet, um Strings in Java aufzuteilen. Aber jetzt ist die Verwendung von
StringTokenizer
wird abgeraten und die Verwendung der
Teilt()
Methode in der
Zeichenfolge
Klasse oder die Verwendung der
java.util.regex
Schritt 3. Verwenden Sie die
Zeichenfolge
Klasse
Teilt()
Methode.
Die
Teilt()
-Methode nimmt das Trennzeichen als Parameter auf und gibt ein Array von Teilzeichenfolgen zurück, die mit den Token aus dem identisch sind
StringTokenizer
java.util. Arrays importieren; public class StringManipulation { public static void main(String args) { String str = "rot, grün, blau, gelb, pink"; String splitArr = str.split(", "); System.out.println("\nOriginal-String: " + str); System.out.println("Split Array: " + Arrays.toString(splitArr) + "\n"); } }
Schritt 4. Verwenden Sie reguläre Ausdrücke, um die Zeichenfolge zu teilen
Importieren
java.util.regex. Muster
. Verwenden Sie die
kompilieren()
Methode der
Muster
Klasse, um das Trennzeichen zu setzen und dann die
Teilt()
-Methode die Zeichenfolge, die Sie teilen möchten. Die
Muster
gibt ein Array von Teilstrings zurück.
java.util. Arrays importieren; java.util.regex. Pattern importieren; public class StringManipulation { public static void main(String args) { String str = "rot, grün, blau, gelb, pink"; String splitArr = Pattern.compile(", ").split(str); System.out.println("\nOriginal-String: " + str); System.out.println("Split Array: " + Arrays.toString(splitArr) + "\n"); } }
Schritt 5. Überprüfen Sie Ihre Ausgabe
Hier ist die Ausgabe, die sich aus einer dieser Methoden zum Aufteilen von Zeichenfolgen ergibt.
