Java >> Java tutorial >  >> Tag >> String

Sådan vender du en streng i Java

String

En streng angiver en sekvens af tegn, der betragtes som et objekt i Java. På dette sprog er der flere operationer, som du kan udføre på String-objektet. En af de mest generelle operationer på et strengobjekt er String Reverse, som vi vil tackle i denne artikel. Tag på rejse med os, mens vi viser dig nogle få metoder til at vende en streng i Java.


Vi ved alle, at strenge er uforanderlige i Java. Hvis du ikke har nogen idé om, hvad et uforanderligt objekt er, forbliver dets indre tilstand konstant efter at være helt skabt, hvilket betyder ingen ændring. Som sådan kan vi ikke vende en streng ved at ændre den. Af den grund er vi nødt til at oprette en anden streng. Som vi tidligere sagde, er en streng omvendt på flere måder. Her er nogle, som vi vil tage dig igennem i denne artikel.

  • Omvendt streng ved hjælp af omvendt iterativ tilgang
  • Omvendt streng ved hjælp af rekursion
  • Vend bogstaverne i strengen om
  • String Reversal ved hjælp af String Buffer/String Builder-tilgang
  • Brug af stak
  • Brug af tegnarray
  • Brug af Character array og swap()
  • Brug af operatoren + (strengsammenkædning)
  • Brug af Unicode højre-til-venstre-tilsidesættelsestegn (RLO)
  • Brug af et byte-array
  • Brug af substring()-metoden

Lad os udforske hver af disse tilgange, begyndende med, hvordan man vender en streng i Java ved hjælp af Reverse Iterative Approach.


Reversere en streng ved hjælp af omvendt iteration

Du vil først konvertere den givne streng til Character Array ved hjælp af CharArray()-funktionen i denne metode eller fremgangsmåde. Derefter gentages det givne array i omvendt rækkefølge som vist nedenfor:

import java.util.List;
import java.util.Collections;
import java.util.ArrayList;
import java.util.ListIterator;
 
class Main
{
// Java's Method for reversing a string
Collections.reverse()
    public static String reverseString(String new_str)
    {
// base case: if string is empty or the string is null
        if (new_str == null || new_str.equals("")) {
            return new_str;
        }
 
// initialize an empty characters list
List new_list = new ArrayList();
 
// loop through the given string and push all characters into the new_list
        for (char new_char: str.toCharArray()) {
            new_list.add(new_char);
        }
 
// using java.util.Collections to reverse a list with //reverse()
        Collections.reverse(new_list);
 
// conversion of ArrayList into string using StringBuilder
        StringBuilder str_builder = new StringBuilder(list.size());
        for (Character new_char: list) {
            str_builder.append(new_cha);
        }
 
        return str_builder.toString();
    }
 
    public static void main(String[] args)
    {
        String new_str = "codeunderscored";
 
        // String is immutable
        new_str = reverse(new_str);
 
        System.out.println("Reversed strings is: " + new_str);
    }
}

Den omvendte streng er:derocsrednuedoc

Vi håber, at du nu kan forstå, hvordan du bruger den omvendte iteration til at nærme dig en streng i dette programmeringssprog med ovenstående eksempel. Lad os med det gå videre og se på den anden tilgang.

Omvendt streng ved hjælp af rekursion

Rekursion er ikke meget end en funktion, der ideelt set kalder sig selv. Vi vil skrive et program, der vender strengen ved at kalde sig selv rekursivt i denne tilgang. Lad os tage et kig på programmet og se, hvordan det virker:

class StringReversal
{
	static int j = 0;

	//  reversing a string using recursive approach in Java using a static variable
	private static void reverseString(char[] new_str, int n)
	{
		// after reaching the end of string
		if (n == new_str.length) {
			return;
		}

		// recur for the next character
		reverse(str, n + 1);

		if (i <= n)
		{
			char temp_val = new_str[k];
			new_str[n] = new_str[i];
			new_str[j++] = temp_val;
		}
	}

	public static String reverseString(String new_str)
	{
		// base case: string is either empty or it is null
		if (new_str == null || str.equals("")) {
			return new_str;
		}

		// convert string into a character array
		char[] A = str.toCharArray();

		// reverse character array
		reverse(A, 0);

		// convert character array into the string
		return String.copyValueOf(A);
	}

	public static void main(String[] args)
	{
		String str = "codeunderscored";

		// string is immutable
		str = reverseString(str);

		System.out.println("Reversed string is: " + str);
	}
}


Den omvendte streng er:derocsrednuedoc

Du skal bemærke, at vi i ovenstående program oprettede objektet til klassen StringRecursion r. Derefter læste vi den indtastede String ved hjælp af sc.nextLine()-kommandoen og gemte den i String-variablen str. Til sidst kaldte vi den omvendte metode som r.reverseString(str). Med dette i tankerne kan vi skubbe artiklen videre og se på følgende metode til at vende strenge.

String Reversal ved hjælp af String Buffer/String Builder-tilgang

StringBuffer og StringBuilder omfatter en indbygget metode reverse(), der bruges til at vende tegnene i StringBuffer. Denne metode erstatter tegnsekvensen i omvendt rækkefølge. Tag et kig på eksemplet nedenfor, der viser, hvordan man vender en streng ved hjælp af en indbygget metode i StringBuffer-klassen.

class StringReversalUsingStringBuilder
{
	// Reversing a string using `StringBuilder` in Java
	public static String reverseString(String new_str) {
		return new StringBuilder(new_str).reverse().toString();
	}

	public static void main(String[] args)
	{
		String str = "I love codeunderscored";

		// Note that string is immutable in Java
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er derocsrednuedoc evol I

Det er alt, hvad der er på StringBuilder-tilgangsklassen. Vi kan alternativt tage dig igennem ved at bruge en StringBuffer klasse reverse() metode ligesom StringBuilder. Lad os komme i gang.

Tag først et kig på programmet skrevet nedenfor:

class usingStringBuilder
{
	// Reversing a string in Java using `StringBuffer`
	public static String reverseString(String new_str) {
		return new StringBuffer(new_str).reverse().toString();
	}

	public static void main(String[] args)
	{
		String str = "I love codeunderscored";

		// Note that string is immutable in Java
		str = reverseString(str);

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er derocsrednuedoc evol I

Bemærk, at du bør modtage det samme output som det fra StringBuilder-klassen, når du kører programmet. Et andet punkt at huske er, at du enten kan vende som String ved hjælp af StringBuffer reverseString() som vist i ovenstående kode, eller på den anden side af mønten kan du bruge kodelogikken som vist nedenfor:

StringBuffer sb =new StringBuffer("Javacodeunderscored ");
System.out.println(sb.reverse());

Ideelt set indeholder både StringBuilder og StringBuffer en look-alike-tilgang eller vending af en streng i Java. StringBuilder foretrækkes dog på trods af lighederne, da den ikke er synkroniseret og er hurtigere end StringBuffer.

Brug af stak

Denne sektion kan bruge stakdatastrukturen til at hjælpe med at vende en streng i Java. Her er trinene til at opnå dette

Trin 1: Opret en tom stak af tegn.

Trin 2: Konverter den givne streng til et tegnarray ved hjælp af String.toCharArray()-metoden og skub hvert tegn for at passe ind i stakken.

Trin 3: Fjern derefter tegn fra stakken, indtil den er tom. Tildel dem derefter tilbage til karakterarrayet. Da stakken følger FILO-betydningen (først ind, sidst ud) rækkefølge, indsættes tegn i omvendt rækkefølge.

Trin 4: Brug kommandoen String.copyValueOf(char[]) til at konvertere tegnarrayet til en streng og returnere den oprettede streng.

Tag et kig på eksemplet vist nedenfor:

import java.util.Stack;

class usingCopyValueOf
{
	// Method to reverse a string in Java using a stack and character array
	public static String reverseString(String new_str)
	{
		// base case: the string is either empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// creation of an empty stack of characters
		Stack<Character> stack_char = new Stack<Character>();

		// pushing every character of the given string into the tack
		char[] new_ch = new_str.toCharArray();
		for (int i = 0; i < new_str.length(); i++) {
			stack_char.push(new_ch[i]);
		}

		// index starts from 0
		int n = 0;

		// popping stack characters' till it's empty
		while (!stack_char.isEmpty())
		{
			// assigning every popped character back to the character array
			new_ch[n++] = stack_char.pop();
		}

		// converting the character array into a string and return it
		return String.copyValueOf(new_ch);
	}

	public static void main(String[] args)
	{
		String str = "codeunderscored";

		str = reverse(str);		// string is immutable

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er:derocsrednuedoc

Lad os med det tage et kig på den næste metode Brug af tegnarray

Brug af tegnarray

Som vi tidligere sagde, kan du ikke foretage nogen ændring i strengobjektet, da en streng i Java er uforanderlig. Ikke desto mindre kan vi bruge en let modificerbar karakterarray. Nedenfor er trinene for at opnå dette:

Trin 1: Generer et tomt tegnarray med samme kardinalitet som den givne streng.
Trin 2: Fyld tegnarrayet bagud med tegn i den givne streng
Trin 3: Til sidst skal du konvertere tegnarrayet til en streng ved hjælp af denne String.copyValueOf(char[]) kommando og returnere det.

Nedenfor er en demonstration af de ovenfor givne trin:

class convertUsingCopyValueOf
{
    // reversing a string in Java  with the help of a character array
    public static String reverseString(String new_str)
    {
        // return if the string is either empty or it is is null
        if (new_str == null || new_str.equals("")) {
            return new_str;
        }
 
        // string's length
        int n = new_str.length();
 
        // create a character array of equivalent size to that of the string
        char[] temp_char = new char[n];
 
        // filling character array backward with string's characters
        for (int i = 0; i < n; i++) {
            temp_char[n - i - 1] = new_str.charAt(i);
        }
 
        // converting character array to string and returning it
        return String.copyValueOf(temp_char);
    }
 
    public static void main(String[] args)
    {
        String str = "codeunderscored";
 
        // Strings are immutable in Java
        new_str = reverseString(new_str);
 
        System.out.println("Reversed sring is: " + str);
    }
}


Brug af tegnarray og swap()-metoden

Her er en anden dygtig metode til at vende en streng i Java ved hjælp af tegnarray:

Trin 1: Opret et tegnarray og modificer det med et sæt tegn i en given streng ved hjælp af String.toCharArray().
Trin 2: Begynd fra den givne strengs to endepunkter, l og h. Udfør derefter løkken, indtil de to nævnte punkter skærer hinanden (l <=h). I hver loop-iteration præsenterer swap-værdier indeks l og h og øger l og formindsker h.
Trin 3 :I slutningen skal du konvertere tegnarrayet til streng ved hjælp af String.copyValueOf(char[]) og returnere.


Nedenfor er en demonstration af ovenstående forklaring:

class convertCharacterArrayIntoString
{
	// reversing a string in Java using a character array
	public static String reverseString(String new_str)
	{
		// returns if the string's return either is null or empty
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// creating a character array and initializing it with the specified string
		char[] new_char = new_str.toCharArray();

		for (int l = 0, h = new_str.length() - 1; l < h; l++, h--)
		{
			// swap values at `l` and `h`
			char temp_val = new_char[l];
			new_char[l] = new_char[h];
			new_char[h] = temp_val;
		}

		// convert character array to string and return
		return String.copyValueOf(c);
	}

	public static void main(String[] args)
	{
		String str = "programming with codeunderscored";

		// String is immutable
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er:derocsrednuedoc htiw gnimmargorp

Brug af operatoren + (strengsammenkædning)

Vi kan bruge strengsammenkædningsoperatoren + til at vende en streng i Java ved at læse tegn fra den anden ende og forbinde dem i starten af ​​en ny streng. Bemærk, at en Java-kompiler kan bruge klassen "StringBuffer" eller look-alike-formler for at øge ydeevnen af ​​gentagen strengsammenkædning til at reducere det samlede antal mellemliggende strengobjekter, der genereres ved evaluering af udtryk:

class Main
{
	// Reversing a string in Java using the string concatenation operator
	public static String reverseString(String new_str)
	{
		// return if the string is either empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// variable storing the reversed string
		String rev_str = "";

		// use string concatenation operator to build a reversed string by
		// read the characters from the end of the original string
		for (int i = new_str.length() - 1; i >=0 ; i--) {
			rev_str += new_str.charAt(i);
		}

		return rev_str;
	}

	public static void main(String[] args)
	{
		String str = "coding made better with codeunderscored";

		str = reverse(str);		// string is immutable

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er:derocsrednuedoc htiw retteb edam gnidoc

Brug af Unicode højre-til-venstre-tilsidesættelsestegn (RLO)

I dette tilfælde kan vi bruge Unicodes højre-til-venstre-tilsidesættelsestilgang til at konvertere en streng til dens omvendte. For at præsentere dette, tag et kig på eksemplet nedenfor:

class usingUnicode
{
	// reversing a string in Java by Unicode
	// Right-to-left Override (RLO) character
	public static String reverseString(String new_str) {
		return "\u202E" + new_str;
	}

	public static void main(String[] args)
	{
		String str_val = "codeunderscored";

		// string is immutable
		str_val = reverse(str_val);

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

Det modsatte af den givne streng er:kodeunderstreget

Brug af et byte-array

I dette afsnit er ideen ret ligetil. Bare konverter de givne strenge til bytes, og omarranger derefter byte-arrayet på stedet som vist i denne fremgangsmåde. Til sidst vil vi konvertere byte-arrayet tilbage til en streng. Tag et kig på eksemplet nedenfor:

import java.util.Arrays;

class usingByteArray
{
	// reversing a string in Java using a byte array
	public static String reverseString(String new_str)
	{
		// return if the specified string is either empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// converting strings into bytes
		byte[] n_bytes = str.getBytes();

		// starting from the two endpoints `l` and `h` of the given string
		// and increment `l` and decrement `h` at each iteration of the loop
		// until two endpoints intersect (l >= h)
		for (int l = 0, h = new_str.length() - 1; l < h; l++, h--)
		{
			// swap values at `l` and `h`
			byte temp_val = n_bytes[l];
			n_bytes[l] = n_bytes[h];
			n_bytes[h] = temp;
		}

		// convert byte array back into a string
		return new String(bytes);
	}

	public static void main(String[] args)
	{
		String str = "reverse codeunderscored";

		// String is immutable
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er:derocsrednuedoc esrever

Brug af Substring()-metoden

Vi kan også bruge String.substring(int, int) tilgang til at opnå en revers på en streng i Java. Den efterfølgende kode bruger String.charAt(int)-metoden til at adskille det første eller sidste tegn i og gentages for den resterende streng ved hjælp af substring()

Metode 1: 

class reverseUsingRecursion
{
	//  reversing a string in Java through recursion
	private static String reverseString(String new_str)
	{
		// base case: returns if given string is empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// last character + recur for the remaining string
		return new_str.charAt(new_str.length() - 1) +
				reverseString(new_str.substring(0, new_str.length() - 1));
	}

	public static void main(String[] args)
	{
		String str = "codeunderscored solves";

		// string is immutable
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

Den omvendte streng er:sevlos derocsrednuedoc


Metode 2: 

class reverseUsingRecursion
{
	// reversing a string in Java using recursion
	public static String reverseString(String new_str)
	{
		// base case:  check if the string is null or empty
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// isolate the first character and recur for the remaining string
		return reverseString(new_str.substring(1)) + new_str.charAt(0);
	}

	public static void main(String[] args)
	{
		String str = "Reverse codeunderscored";

		// string is immutable
		new_str = reverseString(new_str);

		System.out.println("Reversed string is: " + new_str);
	}
}

Den omvendte streng er:derocsrednuedoc esreveR

Det er alt, hvad der er ved at vende bogstaverne i en given streng.

Konklusion

Intet føles fantastisk som at have fleksibiliteten til at gøre noget med din kode, og det er præcis, hvad vi har givet dig i denne artikel. Vi har set på de forskellige tilgange til at vende en streng i Java. Vi udforskede flere eksempler med en smule forklaring for at komme i gang. Vi håber, at de metoder, der er beskrevet her, har besvaret nogle retoriske spørgsmål om strengvending i Java.


Java tag