Różne sposoby odwracania ciągu w Javie

Ciągi znaków w Javie można również przedstawić jako tablicę znaków. Ciągi w Javie służą do przechowywania tekstu/znaków. W języku programowania Java ciągi znaków są uważane za obiekty. W Javie ciągi znaków są obiektami predefiniowanej klasy o nazwie String. Wszystkie zmienne łańcuchowe są instancjami klasy String w Javie. Dlatego możemy zrozumieć, że ciągi znaków w Javie nie są typu pierwotnego, jak int czy char w innych językach programowania. W tym artykule przeczytamy, jak odwrócić ciąg znaków w Javie. Warunkiem tego jest wiedza, jak utworzyć ciąg znaków w Javie , podstawowe pojęcia dotyczące wbudowanych metod łańcuchowych oraz wykonywania operacji za pomocą pętli.

Zakres artykułu

- W tym artykule przeczytamy o różnych sposobach odwracania ciągu znaków w Javie. - Zobaczymy także kilka gotowych metod, dzięki którym możemy odwrócić ciąg znaków w Javie. - Przeczytamy także o złożoności czasowej i przestrzennej każdej metody odwrotnej w Javie. - Istnieje kilka sposobów odwrócenia ciągu znaków w Javie, każdy ma swoje zalety i wady. W tym artykule omówimy niektóre z najczęściej używanych metod odwracania ciągu znaków w Javie.

Wstęp

Ciągi znaków są w Javie obiektami niezmiennymi, w Javie ciągi znaków są po prostu sekwencją znaków. Ciągi pojedynczych linii w Javie są definiowane za pomocą pojedynczych cudzysłowów, podczas gdy ciągi wielu linii w Javie są definiowane za pomocą potrójnych cudzysłowów. W Javie dostępnych jest kilka metod łańcuchowych, ale dzisiaj w tym artykule przeczytamy o różnych sposobach odwracania ciągu w Javie. Język programowania Java jest jednym z najczęściej używanych języków programowania na świecie i jest znany ze swojej prostoty i łatwości użycia. Jedną z najczęstszych operacji wykonywanych przez programistów na ciągach znaków jest ich odwracanie. W tym artykule omówimy różne sposoby odwracania ciągu znaków w Javie. Najpierw przeczytajmy o najpopularniejszym sposobie użycia pętli for w Javie:

Odwróć ciąg w Javie za pomocą pętli for:

Ta technika jest jednym z najprostszych sposobów odwrócenia ciągu znaków w Javie za pomocą pętli for. Możemy iterować po znakach ciągu od końca do początku i dodać je do nowej zmiennej łańcuchowej. Oto przykład odwracania ciągu znaków za pomocą pętli for :

//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);
  }
}

Wyjście

The reversed string of the s1 is:nuf si avaj

W powyższym kodzie najpierw pobraliśmy ciąg o nazwie s1 i utworzyliśmy pusty ciąg s2, a następnie wykonaliśmy pętlę for od ostatniego indeksu, a następnie zapisaliśmy wartość każdego znaku w tym ciągu. Uruchom powyższy kod w swoim edytorze, aby uzyskać lepsze i jasne wyjaśnienie. Złożoność czasowa powyższego kodu wynosi O(N), a ponieważ wykonaliśmy iterację po wszystkich n elementach, złożoność przestrzenna powyższego kodu wynosi O(N). Teraz przeczytajmy o kolejnym procesie, który polega na odwróceniu łańcucha za pomocą konstruktora ciągów, więc teraz przeczytajmy o tym szczegółowo:

Odwracanie ciągu przy użyciu klasy konstruktora ciągów

Możemy również odwrócić ciąg znaków w Javie, używając klasy StringBuilder. Klasa StringBuilder udostępnia metodę Reverse(), której można użyć do odwrócenia ciągu znaków. Metoda Reverse() klasy Java StringBuilder służy do zastąpienia tej sekwencji znaków jej odwrotnością. Klasa StringBuilder w Javie nie ma metody toCharArray(), podczas gdy klasa String ma metodę toCharArray(). Teraz zrozumiemy na przykładzie:

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());
    }
}

Wyjście

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

W tej metodzie możemy zobaczyć, że używając wbudowanej klasy konstruktora ciągów, odwróciliśmy ciąg znaków. Ta metoda jest bardzo wydajna, ponieważ wymaga tylko jednego przejścia przez ciąg znaków. Wymaga to jednak utworzenia nowego obiektu StringBuilder, co może spowodować pewne obciążenie. Ta metoda jest stosunkowo prosta i łatwa do zrozumienia, ale może być mniej wydajna niż inne metody, ponieważ wymaga wielokrotnych przejść przez ciąg i utworzenia nowego ciągu dla każdego znaku. Uruchom powyższy kod w swoim edytorze, aby uzyskać lepsze i jasne wyjaśnienie. Zobaczmy teraz inny sposób na odwrócenie łańcucha przy użyciu techniki rekurencji:

Odwróć ciąg za pomocą rekurencji

Rekurencja to technika, w której funkcja wywołuje samą siebie. Możemy użyć rekurencji, aby odwrócić ciąg znaków, dzieląc go na mniejsze podciągi. Rekurencja w Javie to proces, w którym metoda wywołuje się w sposób ciągły. Aby odwrócić ciąg znaków w Javie za pomocą rekurencji, najpierw musimy usunąć pierwszy znak z ciągu, a następnie dodać ten znak na końcu ciągu, a następnie musimy powtarzać powyższy krok, aż ciąg wejściowy stanie się pusty. Teraz zrozumiemy to na przykładzie:

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);
}
}

Wyjście

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Stąd widzimy, że w powyższym przykładzie za pomocą rekurencji odwróciliśmy ciąg znaków. Najpierw sprawdziliśmy, czy ciąg znaków jest pusty, czy nie. Jeśli ciąg będzie pusty, nie będzie żadnych znaków, które można odwrócić. Ta metoda może być bardziej wydajna niż metoda pętli for, ponieważ wymaga tylko jednego przejścia przez ciąg znaków. Jednak może być również bardziej złożony i trudniejszy do zrozumienia, ponieważ wymaga użycia rekurencji . Uruchom powyższy kod w swoim edytorze, aby uzyskać lepsze i jasne wyjaśnienie. Zobaczmy inny przykład odwracania ciągu znaków za pomocą rekurencji w Javie:

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));
}

Teraz przeczytajmy o innym sposobie odwrócenia ciągu znaków w Javie, który wykorzystuje tablicę:

Odwróć ciąg w Javie za pomocą tablicy

Możemy także odwrócić ciąg znaków, konwertując go na tablicę znaków, zmieniając tablicę, a następnie konwertując go z powrotem na ciąg znaków. Najpierw musimy utworzyć pustą tablicę znaków o tym samym rozmiarze co dany ciąg znaków, następnie wypełnić tablicę znaków wstecz znakami danego ciągu, a na koniec musimy przekonwertować tablicę znaków na ciąg znaków za pomocą metodę kopiowania i zwróć ją. Teraz zrozumiemy to na przykładzie:

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);
    }
}

Wyjście

NUF SI AVA

W tej metodzie musimy odwrócić ciąg znaków do znanej nam tablicy znaków, więc najpierw sprawdzimy, czy ciąg jest pusty, czy nie i zwrócimy, jeśli ciąg ma wartość null lub jest pusty, jeśli jest równy pusty, po prostu wypiszemy ciąg i break w przeciwnym razie znajdziemy długość łańcucha, a następnie musimy utworzyć tablicę znaków o tym samym rozmiarze co ciąg znaków, aby zapisać wartość po odwróceniu, a iterując pętlę wstecz, musimy wypełnić tablicę znaków od tyłu znakami w ciągu a w ostatnim kroku po odwróceniu musimy przekonwertować tablicę znaków na ciąg znaków i zwrócić ją. Uruchom powyższy kod w swoim edytorze, aby uzyskać lepsze i jasne wyjaśnienie. Teraz przeczytajmy o kolejnym kroku, w którym możemy odwrócić ciąg znaków w Javie za pomocą Stream API. A teraz przeczytajmy o nich szczegółowo na kilku przykładach:

Odwróć ciąg w Javie za pomocą Stream API:

W Javie 8 wprowadzono Stream API, którego można używać do wykonywania operacji w stylu funkcjonalnym na kolekcjach. Możemy użyć interfejsu Stream API, aby odwrócić ciąg znaków, konwertując go na strumień znaków, odwracając strumień, a następnie konwertując go z powrotem na ciąg znaków. Możemy odwrócić ciąg znaków w Javie za pomocą różnych strumieni i kolektorów. Najpierw musimy wprowadzić ciąg, a następnie użyć mapy na całym ciągu do obiektu StringBuilder i jednocześnie odwrócić go za pomocą metody Reverse() klasy StringBuilder i następnie Na koniec zbierz odwrócony ciąg znaków za pomocą strumienia. metoda Collect() i Kolekcje. Joining() wypiszemy oba oryginalne/odwrócone ciągi znaków wraz z ich długością. Teraz zrozumiemy to na przykładzie:

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

W tym przykładzie odwróciliśmy ciąg znaków w Javie, używając strumieni i kolektorów Java. Uruchom powyższy kod w swoim edytorze, aby uzyskać lepsze i jasne wyjaśnienie. Zobaczmy teraz, jak możemy odwrócić ciąg znaków za pomocą stosu. A teraz przeczytajmy o tym szczegółowo na przykładzie:

Odwróć ciąg za pomocą stosu

Istnieje inny sposób na odwrócenie ciągu znaków w Javie, polegający na użyciu stosu. Pomysł polega na tym, aby każdy znak ciągu wejściowego był umieszczany na stosie, a następnie usuwany ze stosu, aby uzyskać odwrócony ciąg znaków. A teraz przeczytajmy o tym bardziej szczegółowo na przykładzie:

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>

W powyższym przykładzie najpierw utworzyliśmy pusty stos, a następnie odwróciliśmy ciąg znaków i wstawiliśmy elementy do stosu. Metoda ta jest prosta, łatwa do zrozumienia i skuteczna. Uruchom powyższy kod w swoim edytorze, aby uzyskać lepsze i jasne wyjaśnienie.

Wniosek

Pierwsza metoda polega na użyciu klasy StringBuilder, która ma wbudowaną metodę Reverse() zwracającą nowy ciąg znaków będący odwrotnością ciągu oryginalnego. Druga metoda wykorzystuje pętlę for, podczas której konwertujemy oryginalny ciąg znaków na tablicę znaków i wykonujemy iterację po tablicy w odwrotnej kolejności, przypisując odpowiednie znaki do nowej tablicy znaków i na koniec tworząc nowy ciąg znaków przy użyciu tej tablicy znaków. Trzecia metoda wykorzystuje rekurencję, gdzie wywołujemy funkcję rekurencyjną i rozwiązujemy problem poprzez połączenie pierwszego znaku ciągu z odwróconym podciągiem pozostałych znaków. Czwarta metoda polega na użyciu tablicy do odwrócenia ciągu znaków w Javie. W piątej metodzie użyliśmy interfejsu API strumienia i modułu zbierającego Java do odwrócenia ciągu znaków, a w ostatniej metodzie użyliśmy stosu do odwrócenia ciągu znaków w Javie. Każda z tych metod ma swoje zalety i wady, a wybór metody zależy od konkretnych wymagań problemu i preferencji programisty. Ogólnie rzecz biorąc, metody te demonstrują elastyczność i wszechstronność języka Java w manipulacji ciągami znaków.