Wie macht man Reverse String in Java?

Ein String ist eine Zeichenfolge und wird in Java als Objekt behandelt. Es ist ein Objekt in Java, das die Daten in einem Zeichenarray speichert. Eine umgekehrte Zeichenfolge wird als umgekehrte Zeichenfolge bezeichnet. Beispielsweise ist die Umkehrung der Zeichenfolge „Programm“ „MargorP“.

Die Logik hinter der Stringumkehr in Java:

Es gibt verschiedene Möglichkeiten, eine Zeichenfolge umzukehren, wobei jede separate Funktionen verwendet. Obwohl die verwendeten Methoden unterschiedlich sind, ist der grundlegende Prozess hinter der Umkehrung der Zeichenfolge nahezu derselbe. Die typische verwendete Logik ist:

• Geben Sie eine Zeichenfolge mithilfe der Benutzereingabe oder im Code ein.
• Nehmen Sie die Zeichen der Zeichenfolge, beginnend an der letzten Position, und speichern Sie sie in einer beliebigen Variablen.
• Ausgabe anzeigen.

Lernen Sie Softwareentwicklungskurse online von den besten Universitäten der Welt. Verdienen Sie Executive PG-Programme, Advanced Certificate-Programme oder Master-Programme, um Ihre Karriere zu beschleunigen.

Verschiedene Methoden, um den String in Java umzukehren:

1. Verwenden von StringBuffer oder StringBuilder
2. Rückwärtsiteration verwenden
3. Verwenden der charAt()-Methode
4. Verwenden des ArrayList-Objekts
5. Rekursion verwenden
6. String in Bytes umwandeln
7. Stapel verwenden

Lassen Sie uns jede dieser Methoden im Detail durchgehen.

Beliebte Kurse und Artikel zum Thema Softwareentwicklung

1. Durch StringBuilder / StringBuffer

Die Klasse StringBuffer oder StringBuilder hat eine eingebaute Methode reverse(), die die Zeichen in der Zeichenfolge umkehrt. Es ersetzt die Reihenfolge der Zeichen in umgekehrter Reihenfolge. Diese Methode ist die statische Methode, die die Logik zum Umkehren von Zeichenfolgen in Java implementiert .

StringBuffer und StringBuilder sind zwei Dienstprogrammklassen in Java, die die Ressourcenzuweisung von String-Manipulationen verwalten.

Verwenden von StringBuffer:

Java-Programm, das einen String mit StringBuffer umkehrt:

öffentliche Klasse ExampleofReverseString{

public static void main(String[] args) {

Zeichenfolge str1 = „Apfel“;

//speichert die umgekehrte Zeichenfolgenreihenfolge in der rev-Variablen

String rev = neuer StringBuffer(str1).reverse().toString();

// gibt den String vor dem Reverse aus

System.out.println(“\Der String vor der Umkehrung ist: “+str1);

// gibt die Zeichenfolge nach dem Umkehren aus

System.out.println(“Der String nach der Umkehrung ist: “+rev);

}

}

Ausgabe:

Die Zeichenfolge vor der Umkehrung lautet: Apple

Der String nach der Umkehrung ist: elppA

Im obigen Beispiel würde die als Eingabe bereitgestellte Zeichenfolge mithilfe von StringBuffer gepuffert. Es würde dann mit der Methode reverse() umgekehrt werden. Nachdem der Puffer umgekehrt wurde, würde er mit der Methode toString() in einen String konvertiert.

Verwenden von StringBuilder:

Die StringBuilder-Klasse wird im Vergleich zur StringBuffer-Klasse stark bevorzugt. Es ist schneller und nicht synchronisiert.

Java-Programm, das einen String mit StringBuilder umkehrt:

öffentliche Klasse ExampleofReverseString{

public static void main(String[] args) {

Zeichenfolge str1 = „Schule“;

//speichert den umgekehrten String in der rev-Variablen

String rev = neuer StringBuilder(str1).reverse().toString();

// gibt den String vor dem Reverse aus

System.out.println(“\nString vor dem Umkehren: “+str1);

// gibt die Zeichenfolge nach dem Umkehren aus

System.out.println(“String nach Umkehrung: “+rev);

}

}

Ausgabe:

Schnur vor dem Umkehren: Schule

String vor dem Umkehren: loohcS

Im obigen Code wird das Objekt für die StringBuilder-Klasse verwendet. Die entsprechenden StringBuilder-Objekte sind speichereffizient, veränderlich und schnell in der Ausführung. Das Objekt ruft die eingebaute Methode reverse() auf, um die gewünschte Ausgabe bereitzustellen.

2. Durch umgekehrte Iteration

Java-Programm, das einen String mit Reverse Iteration umkehrt:

öffentliche Klasse StringReversal {

öffentlicher statischer String reverseString(String st){

char ch[]=st.toCharArray();

Zeichenfolge rev="";

for(int i=ch.length-1;i>=0;i–)

{

rev+=ch[i];

}

Rücklaufdrehzahl;

}

}

öffentliche Klasse TestStringReversal {

public static void main(String[] args) {

System.out.println(StringReversal.reverseString(“Ich bin Lehrerin“));

System.out.println(StringReversal.reverseString(“Ich unterrichte Englisch als Fach”));

}

}

Ausgabe:

Ich bin rehcaet

Ich hcaet hsilgnE tcejbus

Im obigen Programm für den umgekehrten String in Java werden die Zeichen des Eingabestrings in der Variable rev+ gespeichert, beginnend mit der letzten Position, indem die for-Schleife verwendet wird. Die umgekehrte Zeichenfolge wird in der Ausgabe angezeigt, nachdem alle Zeichen gespeichert wurden.

Sie können die While-Schleife für die umgekehrte Iteration verwenden, und der Code lautet wie folgt:

öffentliche Klasse StringReversal {

public static void main(String[] args)

{

String stringInput = „Dieser String“;

int StrLength=stringInput.length();

while(StrLength >0)

{

System.out.print (stringInput.charAt (StrLength -1));

StrLength–;

}

}

}

Ausgabe:

gnirtS sihT

3. Verwendung der charAt()-Methode

Sein Java-Programm ist wie folgt:

öffentliche Klasse ExampleofReverseString {

public static void main(String[] args) {

Zeichenfolge str = „Java lernen“;

//speichert den umgekehrten String in der revv-Variablen

Zeichenfolge revv = „“;

//Länge des Strings wird in len gespeichert

int len=str.length();

for(int i=len-1;i>=0;i–)

revv = revv + str.charAt(i);

// gibt den String vor dem Reverse aus

System.out.println(“\nString vor Umkehroperation: “+str);

// gibt die Zeichenfolge nach dem Umkehren aus

System.out.println(“String nach Umkehrung: “+ revv);

}

}

Ausgabe:

String vor Umkehroperation: Lerne Java

String vor Umkehroperation: avaJ nraeL

In diesem Java-Programm zum Umkehren einer Zeichenfolge werden die Zeichen der Eingabezeichenfolge in der revv-Variablen gespeichert, beginnend mit der letzten Position unter Verwendung der for-Schleife. Nachdem alle Zeichen gespeichert sind, wird die umgekehrte Zeichenfolge in der Ausgabe wiedergegeben.

4. Verwendung des ArrayList-Objekts

Sein Java-Programm ist wie folgt:

java.util.ArrayList importieren;

java.util.Collections importieren;

java.util.List importieren;

import java.util.ListIterator;

öffentliche Klasse ExampleofReverseString {

public static void main(String[] args) {

String str = „Viel Spaß beim Codieren“;

//wandelt den Eingabestring in ein Zeichenarray um

char ch[]=str.toCharArray();

// fügt dem Objekt der ArrayList ein Zeichenarray hinzu

List<Zeichen> obj = new ArrayList<>();

für (char c: ch)

obj.add(c);

//übergibt das Objekt von ArrayList an Sammlungen

Collections.reverse(obj);

//erzeugt ein Listeniterator-Objekt, das in der Liste wiederholt wird

ListIterator objnew = obj.listIterator();

// gibt den String vor der Umkehrung aus

System.out.println(“\nString vor Umkehroperation: “+ str);

// gibt den String nach der Umkehrung aus

System.out.println(“\nString nach Umkehroperation: “);

while (objnew.hasNext())

System.out.print (objnew.next());

}

}

Ausgabe:

String vor Umkehroperation: Viel Spaß beim Codieren

Zeichenfolge nach Umkehroperation: gnidoc yojnE

Dieses Java-Programm zum Umkehren einer Zeichenfolge speichert die Zeichen der Eingabezeichenfolge im ArrayList-Objekt. Es wird mit der Methode reverse () in den Sammlungen umgekehrt. Der Iterator iteriert über die Liste und gibt die umgekehrte Zeichenfolge aus, nachdem sie umgekehrt wurde.

5. Rekursion verwenden

Sein Java-Programm ist wie folgt:

öffentliche Klasse ExampleofReverseString {

// Definiert Umkehrfunktion

Saitenumdrehungen (String str) {

// gibt null zurück, wenn die Länge des Strings null ist

if(str.länge() == 0)

{

Rückkehr " ";

}

//ansonsten gibt das Ergebnis der folgenden Methode zurück

return str.charAt(str.length()-1) + revs(str.substring(0,str.length()-1));

}

public static void main(String[ ] args)

{

// erstellt ein Objekt der Klasse

ExampleofReverseString r = new ExampleofReverseString ();

// gibt Zeichenfolge ein

String str = „Master in Java“;

// gibt den String vor der Umkehrung aus

System.out.println(“\nString vor Umkehroperation: “+ str);

// gibt den String nach der Umkehrung aus

System.out.println(“\nString nach Umkehroperation: ” + r.revs(str));

}

Ausgabe:

String vor Umkehroperation: Master in Java

String nach Umkehroperation: avaJ ni retsaM

In diesem Java-Programm wird eine rekursive Funktion generiert. Es prüft die Länge der Saite und zehn Umkehrungen. Es funktioniert genauso wie die Reverse-Funktion in Java .

6. Durch Umwandlung eines Strings in Bytes

Es verwendet die Methode getBytes(), die die Eingabezeichenfolge in Bytes umwandelt oder aufteilt. In diesem Moment entspricht die Länge des Byte-Arrays der Länge der Eingabezeichenfolge. Das Programm holt sich dann die Bytes in umgekehrter Reihenfolge und speichert sie in einem neuen Byte-Array.

Im folgenden Code wird vorübergehend ein Bytearray generiert. Zwei-Byte-Arrays werden erstellt – eines zum Speichern der konvertierten Bytes und ein weiteres zum Speichern des Ergebnisses in umgekehrter Reihenfolge.

Sein Java-Programm ist wie folgt:

public static void main(String[] arg) {

String Eingabewert = „Computer“;

byte[] strByteArray = inputvalue.getBytes();

byte[] result = new byte[strByteArray.length];

// Speichert das Ergebnis in umgekehrter Reihenfolge im Ergebnisbyte[]

for (int i = 0; i <strByteArray.length; i++)

result[i] = strByteArray [strByteArray.length – i – 1];

System.out.println( „String nach Umkehroperation ist:“ +neuer String(Ergebnis));

}

Ausgabe:

String nach der umgekehrten Operation ist: retupmoC

7) Stack verwenden

Diese Methode umfasst die folgenden Schritte, um einen Java-String mithilfe der Stack-Datenstruktur umzukehren.

1. Erstellen Sie einen Stapel ohne Zeichen.
2. Wandeln Sie eine Eingabezeichenfolge mithilfe der Methode String.toCharArray() in ein Zeichenarray um. Anschließend fügt es jedes Zeichen dem Stapel hinzu.

iii. Rufen Sie Zeichen aus dem Stapel ab, bis dieser leer ist, und weisen Sie die Zeichen dann erneut einem Zeichenarray zu. Also, jetzt kommen die Charaktere in umgekehrter Reihenfolge an.

1. Das Zeichenarray wird mit String.copyValueOf(char[]) in einen String umgewandelt und gibt schließlich den neuen String zurück.

Sein Java-Programm ist wie folgt:

java.util.Stack importieren;

Klasse Haupt

{

öffentlicher statischer String reverse(String str)

{

// Prüft, ob der String leer oder null ist

if (str == null || str.equals(“”)) {

Rückgabestr;

}

// erzeugt einen leeren Zeichenstapel

Stack<Zeichen> stack = new Stack<Zeichen>();

// fügt alle Zeichen des Eingabestrings in den Stack ein

char[] ch = str.toCharArray();

for (int i = 0; i < str.length(); i++) {

stack.push(ch[i]);

}

// beginnt bei Index 0

intm = 0;

// ruft Zeichen vom Stack ab, bis er leer wird

while (!stack.isEmpty())

{

// Weist jedes abgerufene Zeichen wieder dem Zeichenarray zu

ch[m++] = stack.pop();

}

// wandelt das Zeichenarray in einen String um und gibt ihn zurück

Rückgabe String.copyValueOf(ch);

}

public static void main(String[] args)

{

Zeichenfolge str = „Technologieinnovation“;

str = rückwärts (str);

System.out.println(“Die Umkehrung der Eingabezeichenfolge: ” + str);

}

}

Ausgabe

Die Umkehrung der Eingabezeichenfolge: ygolonhceT noitavonnI

Beginnen Sie Ihre Java-Reise mit UpGrad

Wenn Sie Java lernen möchten, müssen Sie die Konzepte von Core Java verstehen. Dafür können Sie den Master of Science in Informatik von UpGrad absolvieren . Es behandelt Themen wie Core Java, OOPS-Konzepte, Objekte und Klassen in Java, Methoden in Java, Java Virtual Machine, Polymorphismus, Vererbung, Abstraktion, Kapselung usw. Sie erhalten Anleitungen von Branchenexperten. Diese Experten führen interaktive Live-Sitzungen durch, die den Lehrplan und fortgeschrittene Themen abdecken.