Verschiedene Möglichkeiten, einen String in Java umzukehren

Zeichenfolgen können in Java auch als Array von Zeichen bezeichnet werden. Zeichenfolgen in Java werden zum Speichern von Text/Zeichen verwendet. In der Programmiersprache Java werden die Zeichenfolgen als Objekte betrachtet. In Java sind Strings die Objekte einer vordefinierten Klasse namens String. Alle String-Variablen sind Instanzen der String-Klasse in Java. Daher können wir verstehen, dass die Zeichenfolgen in Java nicht zu den primitiven Typen gehören wie int oder char in anderen Programmiersprachen. In diesem Artikel lesen wir, wie man einen String in Java umkehrt. Voraussetzung dafür ist, dass Sie wissen, wie man einen String in Java erstellt , das Grundkonzept der integrierten String-Methoden kennt und wie man Operationen mit Hilfe von Schleifen ausführt.

Umfang des Artikels

- In diesem Artikel erfahren Sie mehr über die verschiedenen Möglichkeiten, einen String in Java umzukehren. - Wir werden auch einige vorgefertigte Methoden sehen, mit denen wir einen String in Java umkehren können. - Wir werden auch über die zeitliche und räumliche Komplexität jeder Umkehrmethode in Java lesen. - Es gibt mehrere Möglichkeiten, einen String in Java umzukehren, jede mit ihren Vor- und Nachteilen. In diesem Artikel werden wir einige der am häufigsten verwendeten Methoden zum Umkehren einer Zeichenfolge in Java untersuchen.

Einführung

Strings sind in Java unveränderliche Objekte, Strings sind in Java nur eine Folge von Zeichen. Einzeilige Zeichenfolgen werden in Java mit einfachen Anführungszeichen definiert, während mehrzeilige Zeichenfolgen in Java mit dreifachen Anführungszeichen definiert werden. Java verfügt über mehrere Zeichenfolgenmethoden, aber heute werden wir in diesem Artikel über die verschiedenen Möglichkeiten lesen, wie man eine Zeichenfolge in Java umkehrt. Die Programmiersprache Java ist eine der am weitesten verbreiteten Programmiersprachen der Welt und bekannt für ihre Einfachheit und Benutzerfreundlichkeit. Eine der häufigsten Operationen, die Programmierer an Zeichenfolgen durchführen, ist deren Umkehrung. In diesem Artikel besprechen wir verschiedene Möglichkeiten, einen String in Java umzukehren. Lesen wir zunächst, wie die for-Schleife in Java am häufigsten verwendet wird:

Kehren Sie die Zeichenfolge in Java mithilfe der for-Schleife um:

Diese Technik ist eine der einfachsten Möglichkeiten, eine Zeichenfolge in Java mithilfe einer for-Schleife umzukehren. Wir können die Zeichen der Zeichenfolge vom Ende bis zum Anfang durchlaufen und sie einer neuen Zeichenfolgenvariablen hinzufügen. Hier ist ein Beispiel dafür, wie man eine Zeichenfolge mithilfe einer for-Schleife umkehrt :

//in the above code we have reversed the string using a for loop in java
public class reverseofthestring {
  public static void main(String[] args) {

    String s1 = "java is fun";
      // we are creating the second string to store the reversed string and print it while iterating the for loop
    String s2 = "";

    for(int i = s1.length()-1; i>=0; i--)
    {
        // in the above line we have stored the reversed string by iterating the for loop from the last index and stored the value in the second string created s2.
      s2 = s2 + s1.charAt(i);
    }

    System.out.print("The reversed string of the '"+s1+"' is: " );
    System.out.println(s2);
  }
}

Ausgabe

The reversed string of the s1 is:nuf si avaj

Im obigen Code haben wir zunächst die Eingabe einer Zeichenfolge namens s1 übernommen und eine leere Zeichenfolge s2 erstellt, dann die for-Schleife ab dem letzten Index wiederholt und dann den Wert jedes Zeichens in dieser Zeichenfolge gespeichert. Führen Sie den obigen Code in Ihrem Editor aus, um eine bessere und klarere Erklärung zu erhalten. Die zeitliche Komplexität des obigen Codes beträgt O(N), und da wir über alle n Elemente iteriert haben, beträgt die räumliche Komplexität des obigen Codes O(N). Lassen Sie uns nun über den nächsten Prozess lesen, der darin besteht, den String mithilfe des String-Builders umzukehren. Lesen Sie ihn nun im Detail:

Umkehren des Strings mit der String-Builder-Klasse

Wir können den String auch in Java umkehren, indem wir die StringBuilder-Klasse verwenden. Die StringBuilder-Klasse stellt eine reverse()-Methode bereit, mit der eine Zeichenfolge umgekehrt werden kann. Die Methode reverse() der Java-Klasse StringBuilder wird verwendet, um diese Zeichenfolge durch die Umkehrung der Sequenz zu ersetzen. Die StringBuilder- Klasse in Java verfügt nicht über die Methode toCharArray(), während die String-Klasse über die Methode toCharArray() verfügt. Lassen Sie uns nun anhand eines Beispiels verstehen:

public class reverseusingbuilder {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder("abc");
        System.out.println("The original string1 is  = " + s1);
        StringBuilder s2 = new StringBuilder("cab");
        System.out.println("The original string2 is = " + s2);
         StringBuilder s3 = new StringBuilder("wer");
        System. out.println("The original string3 is = " + s3);
        // reversing of stringbuilder
        System.out.println("The reverse of the string is reverse1 = " + s1.reverse());
        System.out.println("The reverse of the string2 is reverse2 = " + s2.reverse());
         System.out.println("The reverse of the string3 is reverse2 = " + s3.reverse());
    }
}

Ausgabe

The original string1 is  = abc
The original string2 is  =cab
The original string3 is  =wer
The reversed string1 is  = cba
The reversed string2 is  = bac
The reversed string3 is  =rew

In dieser Methode können wir sehen, dass wir mit der integrierten String-Builder-Klasse den String umgekehrt haben. Diese Methode ist sehr effizient, da sie nur einen einzigen Durchlauf durch die Zeichenfolge erfordert. Es erfordert jedoch die Erstellung eines neuen StringBuilder-Objekts, was zu einem gewissen Mehraufwand führen kann. Diese Methode ist relativ einfach und leicht zu verstehen, kann jedoch weniger effizient sein als andere Methoden, da sie mehrere Durchgänge durch die Zeichenfolge und die Erstellung einer neuen Zeichenfolge für jedes Zeichen erfordert. Führen Sie den obigen Code in Ihrem Editor aus, um eine bessere und klarere Erklärung zu erhalten. Sehen wir uns nun eine andere Möglichkeit an, die Zeichenfolge mithilfe der Rekursionstechnik umzukehren:

Kehren Sie die Zeichenfolge mithilfe der Rekursion um

Rekursion ist eine Technik, bei der sich eine Funktion selbst aufruft. Mit der Rekursion können wir einen String umkehren, indem wir ihn in kleinere Teilstrings zerlegen. Rekursion ist in Java ein Prozess, bei dem sich eine Methode kontinuierlich selbst aufruft. Um die Zeichenfolge in Java mithilfe der Rekursion umzukehren, müssen wir zunächst das erste Zeichen aus der Zeichenfolge entfernen und dieses Zeichen dann am Ende der Zeichenfolge anhängen. Anschließend müssen wir den obigen Schritt wiederholen, bis die Eingabezeichenfolge leer ist. Lassen Sie uns dies nun anhand eines Beispiels verstehen:

public class reverse string
{
//in this line we are writing the recursive function to reverse a string
public String reverse string(String s1)
{
//first we will check if the string is empty or not
if(s1.isEmpty())
{
System. out.println("String is empty.")
//if the above condition is true then it returns the same string as if the string is empty itself then we cannot reverse the string
return s1;
}
else
{
return reverseString(s1.substring(1))+s1.charAt(0);
}
}
public static void main(String[] args)
{
reversestring q1 = new reversestring();
String res1 = q1.reverseString("JAVA IS FUN");
String res2 = q1.reverseString("STRINGS OBJECTS JAVA");
String res3 = q1.reverseString("IMMUTABLE CLASS OBJECTS");
System.out.println(res1);
System.out.println(res2);
System.out.println(res3);
}
}

Ausgabe

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Daher können wir oben sehen, dass wir mithilfe der Rekursion die Zeichenfolge umgekehrt haben. Zuerst haben wir überprüft, ob die Zeichenfolge leer ist oder nicht. Wenn die Zeichenfolge leer ist, gibt es keine Zeichen, die umgekehrt werden können. Diese Methode kann effizienter sein als die for-Loop-Methode, da sie nur einen einzigen Durchlauf durch die Zeichenfolge erfordert. Es kann jedoch auch komplexer und schwerer zu verstehen sein, da es die Verwendung von Rekursion erfordert . Führen Sie den obigen Code in Ihrem Editor aus, um eine bessere und klarere Erklärung zu erhalten. Sehen wir uns ein weiteres Beispiel an, wie man eine Zeichenfolge mithilfe der Rekursion in Java umkehrt:

public static String reverseusingrecursion(String s1) {
    if (s1.length() == 1) {
        return s1;
    }
    //We have applied recursion in this line
    return s1.charAt(s1.length() - 1) + reverseUsingRecursion(s1.substring(0, s1.length() - 1));
}

Lassen Sie uns nun über eine andere Möglichkeit lesen, einen String in Java umzukehren, der das Array verwendet:

Kehren Sie eine Zeichenfolge in Java mithilfe eines Arrays um

Wir können einen String auch umkehren, indem wir ihn in ein Zeichenarray konvertieren, das Array ändern und ihn dann wieder in einen String umwandeln. Zuerst müssen wir ein leeres Zeichenarray mit der gleichen Größe wie die angegebene Zeichenfolge erstellen, dann müssen wir das Zeichenarray rückwärts mit Zeichen der angegebenen Zeichenfolge füllen und schließlich müssen wir das Zeichenarray mit in die Zeichenfolge konvertieren die Kopiermethode und geben Sie sie zurück. Lassen Sie uns dies nun anhand eines Beispiels verstehen:

public class Main
{
    // In this Method of conversion we have to reverse a string in Java using a character array
    public static String reverse(String s1)
    {
        // we have to check if the string is empty or not and return if the string is null or empty
        if (s1 == null || s1.equals("")) {
            return s1;
        }
 // if it is equal to empty then we will simply print the string and break it.
        // else we will find the string length
        int len = str.length();

        // and then we have to create a character array of the same size as that of the string to store the value after reversing
        char[] new_arr = new char[n];

        // and by iterating the loop backward we have to fill the character array backward with characters in the string
        for (int i = 0; i < len; i++) {
            new_arr[len - i - 1] = str.charAt(i);
        }

        // and in the final step after reversing we have to convert the character array to string and return it
        to return String.copy value of(new_arr);
    }

    public static void main(String[] args)
    {
        // taking a string input for reverse
        String s1 = "JAVA IS FUN";

        // In this line we are calling the reverse function and reversing the string
        str = reverse(str);

        System.out.println("The reversed string is " + s1);
    }
}

Ausgabe

NUF SI AVA

Bei dieser Methode müssen wir die Zeichenfolge in ein uns bekanntes Zeichenarray umkehren. Daher prüfen wir zunächst, ob die Zeichenfolge leer ist oder nicht, und geben zurück, wenn die Zeichenfolge null oder leer ist. Wenn sie gleich leer ist, drucken wir die Zeichenfolge einfach aus und break, sonst finden wir die Länge der Zeichenfolge und müssen dann ein Zeichenarray mit der gleichen Größe wie die Zeichenfolge erstellen, um den Wert nach der Umkehrung zu speichern. Durch Rückwärtsiterieren der Schleife müssen wir das Zeichenarray rückwärts mit Zeichen in der Zeichenfolge füllen und im letzten Schritt nach der Umkehrung müssen wir das Zeichenarray in einen String konvertieren und zurückgeben. Führen Sie den obigen Code in Ihrem Editor aus, um eine bessere und klarere Erklärung zu erhalten. Lesen wir nun den nächsten Schritt: Wir können die Zeichenfolge auch in Java mithilfe der Stream-API umkehren. Lassen Sie uns diese nun anhand einiger Beispiele im Detail nachlesen:

Kehren Sie eine Zeichenfolge in Java mithilfe der Stream-API um:

Mit Java 8 wurde die Stream-API eingeführt, mit der funktionale Vorgänge für Sammlungen ausgeführt werden können. Mit der Stream-API können wir einen String umkehren, indem wir ihn in einen Zeichenstrom umwandeln, den Strom umkehren und ihn dann wieder in einen String umwandeln. Wir können einen String in Java mit verschiedenen Streams und Kollektoren umkehren. Zuerst müssen wir einen String eingeben und dann eine Map für den gesamten String in ein StringBuilder-Objekt verwenden und ihn gleichzeitig mit der Methode reverse() der StringBuilder-Klasse umkehren dann schließlich das Sammeln des umgekehrten Strings mithilfe des Streams. Collect()-Methode und Collectors. Mit der Methode „joining()“ drucken wir beide ursprünglichen/umgekehrten Strings zusammen mit ihrer Länge. Lassen Sie uns dies nun anhand eines Beispiels verstehen:

public static String reverseUsingStream(String str) {
    return str. chars()
              .mapToObj(c -> (char) c)
              .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
              .reverse()
              .toString();
}

In diesem Beispiel haben wir die Zeichenfolge in Java mithilfe der Java-Streams und -Collectors umgekehrt. Führen Sie den obigen Code in Ihrem Editor aus, um eine bessere und klarere Erklärung zu erhalten. Sehen wir uns nun an, wie wir die Zeichenfolge mithilfe des Stapels umkehren können. Lassen Sie uns dies nun anhand eines Beispiels im Detail nachlesen:

Kehren Sie die Zeichenfolge mithilfe des Stapels um

Es gibt eine andere Möglichkeit, einen String in Java umzukehren, nämlich die Verwendung eines Stacks. Die Idee besteht darin, jedes Zeichen der Eingabezeichenfolge auf den Stapel zu verschieben und dann Zeichen vom Stapel zu entfernen, um die umgekehrte Zeichenfolge zu erhalten. Lassen Sie uns nun anhand eines Beispiels mehr darüber im Detail lesen:

public static String reverse string(String input) {
    Stack<character> stack = new Stack<>();
    for (int i = 0; i < input.length(); i++) {
        stack.push(input.charAt(i));
    }
    StringBuilder sb = new StringBuilder();
    while (!stack.isEmpty()) {
        sb.append(stack.pop());
    }
    return sb.toString();
}

</character>

Im obigen Beispiel haben wir zunächst einen leeren Stapel erstellt, dann die Zeichenfolge umgekehrt und die Elemente in den Stapel eingefügt. Diese Methode ist einfach, leicht verständlich und effizient. Führen Sie den obigen Code in Ihrem Editor aus, um eine bessere und klarere Erklärung zu erhalten.

Abschluss

Die erste Methode ist die Verwendung der StringBuilder-Klasse, die über eine integrierte reverse()-Methode verfügt, die eine neue Zeichenfolge zurückgibt, die die Umkehrung der ursprünglichen Zeichenfolge ist. Die zweite Methode ist die Verwendung einer for-Schleife, bei der wir die ursprüngliche Zeichenfolge in ein char-Array konvertieren und das Array in umgekehrter Reihenfolge durchlaufen, die entsprechenden Zeichen einem neuen char-Array zuweisen und schließlich mit diesem char-Array eine neue Zeichenfolge erstellen. Die dritte Methode ist die Verwendung der Rekursion, bei der wir eine rekursive Funktion aufrufen und das Problem lösen, indem wir das erste Zeichen der Zeichenfolge mit der umgekehrten Teilzeichenfolge der verbleibenden Zeichen verketten. Die vierte Methode besteht darin, ein Array zum Umkehren einer Zeichenfolge in Java zu verwenden. Bei der fünften Methode haben wir die Stream-API und den Java-Collector verwendet, um den String umzukehren, und bei der letzten Methode haben wir den Stack verwendet, um den String in Java umzukehren. Jede dieser Methoden hat ihre Vor- und Nachteile, und die Wahl der Methode hängt von den spezifischen Anforderungen des Problems und den Vorlieben des Programmierers ab. Insgesamt demonstrieren diese Methoden die Flexibilität und Vielseitigkeit von Java bei der String-Manipulation.