Diversi modi per invertire una stringa in Java

Le stringhe in Java possono anche essere dette come un array di caratteri. Le stringhe in Java vengono utilizzate per memorizzare testo/caratteri. Nel linguaggio di programmazione Java le stringhe sono considerate oggetti. In Java, le stringhe sono gli oggetti di una classe predefinita denominata String. Tutte le variabili stringa sono istanze della classe String in Java. Quindi possiamo capire che le stringhe in Java non sono dei tipi primitivi come int o char in altri linguaggi di programmazione. In questo articolo, leggeremo come invertire una stringa in Java, il prerequisito per questo è che tu sappia come creare una stringa in Java , il concetto di base dei metodi di stringa integrati e come eseguire operazioni con l'aiuto dei loop.

Scopo dell'articolo

- In questo articolo leggeremo i vari modi per invertire una stringa in Java. - Vedremo anche alcuni metodi predefiniti attraverso i quali possiamo invertire una stringa in Java. - Leggeremo anche la complessità temporale e spaziale di ciascun metodo inverso in Java. - Esistono diversi modi per invertire una stringa in Java, ognuno con i suoi vantaggi e svantaggi. In questo articolo esploreremo alcuni dei metodi più comunemente utilizzati per invertire una stringa in Java.

introduzione

Le stringhe sono oggetti immutabili in Java, le stringhe sono solo una sequenza di caratteri in Java. Le stringhe a riga singola in Java sono definite con virgolette singole mentre le stringhe a righe multiple in Java sono definite con virgolette triple, Java ha diversi metodi di stringa disponibili, ma oggi in questo articolo leggeremo i diversi modi su come invertire una stringa in Java. Il linguaggio di programmazione Java è uno dei linguaggi di programmazione più utilizzati al mondo ed è noto per la sua semplicità e facilità d'uso. Una delle operazioni più comuni che i programmatori eseguono sulle stringhe è l'inversione delle stesse. In questo articolo discuteremo diversi modi per invertire una stringa in Java. Per prima cosa, leggiamo il modo più comune di utilizzare il ciclo for in Java:

Invertire la stringa in Java utilizzando il ciclo for:

Questa tecnica è uno dei modi più semplici per invertire una stringa in Java utilizzando un ciclo for. Possiamo scorrere i caratteri della stringa dalla fine all'inizio e aggiungerli a una nuova variabile stringa. Ecco un esempio di come invertire una stringa utilizzando un ciclo 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);
  }
}

Produzione

The reversed string of the s1 is:nuf si avaj

Nel codice sopra, abbiamo prima preso l'input di una stringa denominata s1 e creato una stringa vuota s2, quindi abbiamo ripetuto il ciclo for dall'ultimo indice e quindi abbiamo memorizzato il valore di ciascun carattere in quella stringa. Esegui il codice sopra nel tuo editor per una spiegazione migliore e chiara. La complessità temporale del codice precedente è O(N) e poiché abbiamo ripetuto tutti gli n elementi, la complessità spaziale del codice precedente è O(N). Ora leggiamo il prossimo processo che sta invertendo la stringa utilizzando il generatore di stringhe, quindi ora leggiamolo in dettaglio:

Invertire la stringa utilizzando la classe di creazione stringhe

Possiamo anche invertire la stringa in Java utilizzando la classe StringBuilder. La classe StringBuilder fornisce un metodo reverse() che può essere utilizzato per invertire una stringa. Il metodo reverse() della classe Java StringBuilder viene utilizzato per sostituire questa sequenza di caratteri con il contrario della sequenza. La classe StringBuilder in Java non ha il metodo toCharArray(), mentre la classe String ha il metodo toCharArray(). Cerchiamo ora di capire con l'aiuto di un esempio:

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

Produzione

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 questo metodo, possiamo vedere che utilizzando la classe di creazione stringhe incorporata abbiamo invertito la stringa. Questo metodo è molto efficiente poiché richiede solo un singolo passaggio attraverso la stringa. Tuttavia, richiede la creazione di un nuovo oggetto StringBuilder, che può aggiungere un certo sovraccarico. Questo metodo è relativamente semplice e facile da comprendere, ma può essere meno efficiente di altri metodi, poiché richiede più passaggi attraverso la stringa e la creazione di una nuova stringa per ciascun carattere. Esegui il codice sopra nel tuo editor per una spiegazione migliore e chiara. Vediamo ora un altro modo per invertire la stringa utilizzando la tecnica della ricorsione:

Invertire la stringa utilizzando la ricorsione

La ricorsione è una tecnica in cui una funzione richiama se stessa. Possiamo usare la ricorsione per invertire una stringa suddividendola in sottostringhe più piccole. La ricorsione in Java è un processo in cui un metodo richiama se stesso continuamente. Per invertire la stringa in Java utilizzando la ricorsione dobbiamo prima rimuovere il primo carattere dalla stringa e quindi aggiungere quel carattere alla fine della stringa e quindi dobbiamo ripetere il passaggio precedente finché la stringa di input non diventa vuota. Ora capiamolo con l'aiuto di un esempio:

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

Produzione

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Quindi possiamo vedere che da quanto sopra usando la ricorsione abbiamo invertito la stringa, abbiamo prima verificato se la stringa è vuota o meno, se la stringa sarà vuota allora non ci saranno caratteri che possono essere invertiti. Questo metodo può essere più efficiente del metodo for-loop, poiché richiede solo un singolo passaggio attraverso la stringa. Tuttavia, può anche essere più complesso e difficile da comprendere, poiché implica l'uso della ricorsione . Esegui il codice sopra nel tuo editor per una spiegazione migliore e chiara. Vediamo un altro esempio di come invertire una stringa usando la ricorsione in Java:

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

Ora leggiamo un altro modo per invertire una stringa in Java che utilizza l'array:

Invertire una stringa in Java utilizzando un array

Possiamo anche invertire una stringa convertendola in un array di caratteri, modificando l'array e quindi riconvertendolo in una stringa. Per prima cosa dobbiamo creare un array di caratteri vuoto della stessa dimensione di quello della stringa data, quindi dobbiamo riempire l'array di caratteri all'indietro con i caratteri della stringa data, e infine dobbiamo convertire l'array di caratteri nella stringa usando il metodo copy e restituirlo. Ora capiamolo con l'aiuto di un esempio:

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

Produzione

NUF SI AVA

In questo metodo dobbiamo invertire la stringa in un array di caratteri che conosciamo, quindi per prima cosa controlleremo se la stringa è vuota o meno e restituiremo se la stringa è nulla o vuota se è uguale a vuoto quindi stamperemo semplicemente la stringa e break altrimenti troveremo la lunghezza della stringa e poi dovremo creare un array di caratteri della stessa dimensione di quello di string per memorizzare il valore dopo l'inversione e iterando il ciclo all'indietro dobbiamo riempire l'array di caratteri all'indietro con i caratteri nella stringa e nel passaggio finale dopo l'inversione dobbiamo convertire l'array di caratteri in stringa e restituirlo. Esegui il codice sopra nel tuo editor per una spiegazione migliore e chiara. Ora leggiamo il passaggio successivo: possiamo anche invertire la stringa in Java utilizzando l'API Stream. Vediamoli ora nel dettaglio con l’aiuto di alcuni esempi:

Invertire una stringa in Java utilizzando l'API Stream:

Java 8 ha introdotto l'API Stream che può essere utilizzata per eseguire operazioni di stile funzionale sulle raccolte. Possiamo utilizzare l'API Stream per invertire una stringa convertendola in un flusso di caratteri, invertendo il flusso e quindi riconvertendola in una stringa. Possiamo invertire una stringa in Java utilizzando vari flussi e raccoglitori: prima dobbiamo inserire una stringa e quindi utilizzare una mappa sull'intera stringa in un oggetto StringBuilder e allo stesso tempo invertirla utilizzando il metodo reverse() della classe StringBuilder e quindi infine, raccogliendo la stringa invertita utilizzando Stream. metodo Collect() e collezionisti. join() stamperemo entrambe le stringhe originali/invertite insieme alla loro lunghezza. Ora capiamolo con l'aiuto di un esempio:

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

In questo esempio, abbiamo invertito la stringa in Java utilizzando i flussi e i raccoglitori Java. Esegui il codice sopra nel tuo editor per una spiegazione migliore e chiara. Ora vediamo come possiamo invertire la stringa utilizzando lo stack. Ora leggiamolo nel dettaglio con l’aiuto di un esempio:

Invertire la stringa utilizzando lo stack

Esiste un altro modo per invertire una stringa in Java che utilizza uno stack. L'idea è di inserire ogni carattere della stringa di input nello stack e quindi estrarre i caratteri dallo stack per ottenere la stringa invertita. Vediamo ora di approfondire l’argomento con l’aiuto di un esempio:

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>

Nell'esempio sopra, abbiamo prima creato uno stack vuoto, quindi abbiamo invertito la stringa e inserito gli elementi all'interno dello stack. Questo metodo è semplice, facile da capire ed efficiente. Esegui il codice sopra nel tuo editor per una spiegazione migliore e chiara.

Conclusione

Il primo metodo consiste nell'utilizzare la classe StringBuilder, che dispone di un metodo reverse() integrato che restituisce una nuova stringa che è il contrario della stringa originale. Il secondo metodo utilizza un ciclo for, in cui convertiamo la stringa originale in un array di caratteri e iteriamo attraverso l'array in ordine inverso, assegnando i caratteri corrispondenti a un nuovo array di caratteri e infine creando una nuova stringa utilizzando quell'array di caratteri. Il terzo metodo utilizza la ricorsione, in cui chiamiamo una funzione ricorsiva e risolviamo il problema concatenando il primo carattere della stringa con la sottostringa invertita dei caratteri rimanenti. Il quarto metodo consiste nell'utilizzare un array per invertire una stringa in Java. Nel quinto metodo, abbiamo utilizzato l'API stream e il raccoglitore Java per invertire la stringa e, nell'ultimo metodo, abbiamo utilizzato lo stack per invertire la stringa in Java. Ciascuno di questi metodi presenta vantaggi e svantaggi e la scelta del metodo dipende dai requisiti specifici del problema e dalle preferenze del programmatore. Nel complesso, questi metodi dimostrano la flessibilità e la versatilità di Java nella manipolazione delle stringhe.