Iba't Ibang Paraan para Baliktarin ang isang String sa Java

Ang mga string sa java ay maaari ding sabihin bilang isang hanay ng mga character. Ang mga string sa java ay ginagamit para sa pag-iimbak ng text/character. Sa java programming language, ang mga string ay itinuturing na mga bagay. Sa Java, ang mga string ay ang mga bagay ng isang paunang natukoy na klase na pinangalanang String. Ang lahat ng mga string variable ay mga pagkakataon ng String class sa java. Kaya naman mauunawaan natin na ang mga string sa java ay hindi sa mga primitive na uri tulad ng int o ang char sa ibang mga programming language. Sa artikulong ito, babasahin natin kung paano i-reverse ang isang string sa java ang kinakailangan para dito ay dapat mong malaman kung paano lumikha ng isang string sa java , at pangunahing konsepto ng mga inbuilt na pamamaraan ng string, at kung paano magsagawa ng mga operasyon sa tulong ng mga loop.

Saklaw ng artikulo

- Sa artikulong ito, babasahin natin ang tungkol sa iba't ibang paraan kung paano i-reverse ang isang string sa java. - Makakakita din tayo ng ilang mga pre-built na pamamaraan kung saan maaari nating baligtarin ang isang string sa java. - Babasahin din natin ang tungkol sa pagiging kumplikado ng oras at espasyo ng bawat reverse method sa java. - Mayroong ilang mga paraan upang baligtarin ang isang string sa Java, bawat isa ay may mga pakinabang at disadvantage nito. Sa artikulong ito, tutuklasin natin ang ilan sa mga pinakakaraniwang ginagamit na pamamaraan para sa pag-reverse ng string sa Java.

Panimula

Ang mga string ay mga hindi nababagong bagay sa java, ang mga string ay isang pagkakasunud-sunod lamang ng mga character sa java. Ang mga solong linya na string sa java ay tinukoy na may mga solong quote habang ang maraming linya ng mga string sa java ay tinukoy gamit ang triple quotes, ang java ay may ilang mga string method na magagamit, ngunit ngayon sa artikulong ito ay mababasa natin ang tungkol sa iba't ibang paraan kung paano i-reverse ang isang string sa java. Ang Java programming language ay isa sa pinakamalawak na ginagamit na programming language sa mundo, at kilala ito sa pagiging simple at kadalian ng paggamit nito. Ang isa sa mga pinakakaraniwang operasyon na ginagawa ng mga programmer sa mga string ay ang pag-reverse sa mga ito. Sa artikulong ito, tatalakayin natin ang iba't ibang paraan upang baligtarin ang isang string sa Java. Una, basahin natin ang tungkol sa pinakakaraniwang paraan ng paggamit ng for loop sa java:

Baliktarin ang string sa java gamit ang para sa loop:

Ang diskarteng ito ay isa sa mga pinakasimpleng paraan upang baligtarin ang isang string sa Java sa pamamagitan ng paggamit ng for loop. Maaari naming ulitin ang mga character ng string mula sa dulo hanggang sa simula, at idagdag ang mga ito sa isang bagong string variable. Narito ang isang halimbawa kung paano i-reverse ang isang string gamit ang isang for loop :

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

Output

The reversed string of the s1 is:nuf si avaj

Sa code sa itaas, kinuha muna namin ang input ng isang string na pinangalanang s1 at lumikha ng isang walang laman na string s2 at pagkatapos ay inulit ang para sa loop mula sa huling index at pagkatapos ay naimbak namin ang halaga ng bawat character sa string na iyon. Patakbuhin ang code sa itaas sa iyong editor para sa isang mas mahusay at malinaw na paliwanag. Ang pagiging kumplikado ng oras ng code sa itaas ay O(N), at habang inulit namin ang lahat ng n elemento ang pagiging kumplikado ng espasyo ng code sa itaas ay O(N). Ngayon basahin natin ang tungkol sa susunod na proseso na binabaligtad ang string gamit ang tagabuo ng string, kaya ngayon ay basahin natin ang tungkol dito nang detalyado:

Pag-reverse ng string gamit ang string builder class

Maaari rin nating baligtarin ang string sa Java sa pamamagitan ng paggamit ng klase ng StringBuilder. Ang StringBuilder class ay nagbibigay ng reverse() na paraan na maaaring magamit upang baligtarin ang isang string. Ang reverse() method ng Java StringBuilder class ay ginagamit para palitan ang character sequence na ito ng reverse ng sequence. Ang StringBuilder class sa java ay walang toCharArray() method, habang ang String class ay may toCharArray() method. Ngayon ay unawain natin sa tulong ng isang halimbawa:

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

Output

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

Sa pamamaraang ito, makikita natin na gamit ang inbuilt na string builder class ay binaligtad natin ang string. Ang pamamaraang ito ay napakahusay, dahil nangangailangan lamang ito ng isang solong pagpasa sa string. Gayunpaman, ito ay nangangailangan ng paglikha ng isang bagong StringBuilder object, na maaaring magdagdag ng ilang overhead. Ang pamamaraang ito ay medyo simple at madaling maunawaan, ngunit maaari itong maging hindi gaanong mahusay kaysa sa iba pang mga pamamaraan, dahil nangangailangan ito ng maraming pagpasa sa string at ang paglikha ng isang bagong string para sa bawat karakter. Patakbuhin ang code sa itaas sa iyong editor para sa isang mas mahusay at malinaw na paliwanag. Ngayon tingnan natin ang isa pang paraan upang baligtarin ang string gamit ang recursion technique:

Baligtarin ang string gamit ang recursion

Ang recursion ay isang pamamaraan kung saan tinatawag ng isang function ang sarili nito. Maaari tayong gumamit ng recursion upang baligtarin ang isang string sa pamamagitan ng paghahati-hati nito sa mas maliliit na substring. Ang recursion sa java ay isang proseso kung saan ang isang pamamaraan ay patuloy na tinatawag ang sarili nito. Upang baligtarin ang string sa java gamit ang recursion, kailangan muna nating alisin ang unang character mula sa string at pagkatapos ay idagdag ang character na iyon sa dulo ng string at pagkatapos ay kailangan nating ulitin ang hakbang sa itaas hanggang sa maging walang laman ang input string. Ngayon ay unawain natin ito sa tulong ng isang halimbawa:

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

Output

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Kaya't makikita natin na sa itaas na gamit ang recursion ay binaligtad natin ang string na una nating nasuri kung ang string ay walang laman o wala kung ang string ay walang laman pagkatapos ay walang mga character na maaaring baligtarin. Ang pamamaraang ito ay maaaring maging mas mahusay kaysa sa para-loop na pamamaraan, dahil nangangailangan lamang ito ng isang solong pagpasa sa string. Gayunpaman, maaari rin itong maging mas kumplikado at mas mahirap maunawaan, dahil kinabibilangan ito ng paggamit ng recursion . Patakbuhin ang code sa itaas sa iyong editor para sa isang mas mahusay at malinaw na paliwanag. Tingnan natin ang isa pang halimbawa kung paano i-reverse ang isang string gamit ang recursion sa 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));
}

Ngayon basahin natin ang tungkol sa isa pang paraan upang baligtarin ang isang string sa java na gumagamit ng array:

Baliktarin ang isang string sa java gamit ang isang array

Maaari rin nating baligtarin ang isang string sa pamamagitan ng pag-convert nito sa isang array ng character, pagpapalit ng array, at pagkatapos ay i-convert ito pabalik sa isang string. Una, kailangan nating lumikha ng isang walang laman na array ng character na may parehong laki tulad ng sa ibinigay na string pagkatapos ay kailangan nating punan ang array ng character pabalik ng mga character ng ibinigay na string, at pagkatapos ay kailangan nating i-convert ang character array sa string gamit ang ang paraan ng pagkopya at ibalik ito. Ngayon ay unawain natin ito sa tulong ng isang halimbawa:

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

Output

NUF SI AVA

Sa pamamaraang ito kailangan nating baligtarin ang string sa isang character array na alam natin kaya't susuriin muna natin kung ang string ay walang laman o hindi at ibabalik kung ang string ay null o walang laman kung ito ay katumbas ng walang laman pagkatapos ay i-print lamang natin ang string at break else mahahanap natin ang haba ng string at pagkatapos ay kailangan nating gumawa ng character array na kapareho ng laki ng string para maimbak ang value pagkatapos baligtarin at sa pamamagitan ng pag-ulit ng loop paatras kailangan nating punan ang character array pabalik ng mga character sa string at sa huling hakbang pagkatapos ng pag-reverse kailangan nating i-convert ang character array sa string at ibalik ito. Patakbuhin ang code sa itaas sa iyong editor para sa isang mas mahusay at malinaw na paliwanag. Ngayon ay basahin natin ang tungkol sa susunod na hakbang na maaari rin nating baligtarin ang string sa java gamit ang Stream API. Kaya ngayon basahin natin ang tungkol sa mga ito nang detalyado sa tulong ng ilang mga halimbawa:

Baliktarin ang isang string sa java gamit ang Stream API:

Ipinakilala ng Java 8 ang Stream API na maaaring magamit upang magsagawa ng mga functional-style na operasyon sa mga koleksyon. Magagamit natin ang Stream API upang baligtarin ang isang string sa pamamagitan ng pag-convert nito sa isang stream ng mga character, pag-reverse ng stream, at pagkatapos ay pag-convert nito pabalik sa isang string. Maaari nating baligtarin ang isang string sa java gamit ang iba't ibang mga stream at collectors, kailangan muna nating mag-input ng isang string at pagkatapos ay gumamit ng isang Map sa buong String sa isang StringBuilder object at sa parehong oras ay baligtarin ito gamit ang reverse() na pamamaraan ng StringBuilder class at pagkatapos Panghuli, pagkolekta ng reverse String gamit ang Stream. collect() method at Collectors. joining() method ay ipi-print namin ang parehong orihinal/reversed Strings kasama ang haba ng mga ito. Ngayon ay unawain natin ito sa tulong ng isang halimbawa:

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

Sa halimbawang ito, binaligtad namin ang string sa java gamit ang mga java stream at collectors. Patakbuhin ang code sa itaas sa iyong editor para sa isang mas mahusay at malinaw na paliwanag. Ngayon tingnan natin kung paano natin mababaligtad ang string gamit ang stack. Ngayon basahin natin ang tungkol dito sa mga detalye sa tulong ng isang halimbawa:

Baliktarin ang string gamit ang stack

May isa pang paraan upang baligtarin ang isang string sa Java na sa pamamagitan ng paggamit ng isang stack. Ang ideya ay itulak ang bawat character ng input string sa stack at pagkatapos ay i-pop ang mga character mula sa stack upang makuha ang reversed string. Ngayon ay basahin natin ang higit pa tungkol dito nang detalyado sa tulong ng isang halimbawa:

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>

Sa halimbawa sa itaas, lumikha muna kami ng isang walang laman na stack at pagkatapos ay binaligtad ang string at ipinasok ang mga elemento sa loob ng stack. Ang pamamaraang ito ay simple, madaling maunawaan, at mahusay. Patakbuhin ang code sa itaas sa iyong editor para sa isang mas mahusay at malinaw na paliwanag.

Konklusyon

Ang unang paraan ay sa pamamagitan ng paggamit ng StringBuilder class, na mayroong built-in na reverse() na pamamaraan na nagbabalik ng bagong string na reverse ng orihinal na string. Ang pangalawang paraan ay gumagamit ng for loop, kung saan iko-convert natin ang orihinal na string sa isang char array at inuulit ang array sa reverse order, itinatalaga ang mga kaukulang character sa isang bagong char array, at sa wakas ay gumagawa ng bagong string gamit ang char array na iyon. Ang pangatlong paraan ay gumagamit ng recursion, kung saan tinatawag nating recursive function at lutasin ang problema sa pamamagitan ng pagsasama-sama ng unang character ng string sa reversed substring ng natitirang mga character. Ang ikaapat na paraan ay sa pamamagitan ng paggamit ng isang array upang baligtarin ang isang string sa java. Sa ikalimang paraan, ginamit namin ang stream API at ang java collector upang baligtarin ang string at, Sa huling paraan ginamit namin ang stack upang baligtarin ang string sa java. Ang bawat isa sa mga pamamaraang ito ay may mga pakinabang at disadvantages nito, at ang pagpili ng paraan ay nakasalalay sa mga partikular na pangangailangan ng problema at kagustuhan ng programmer. Sa pangkalahatan, ang mga pamamaraang ito ay nagpapakita ng flexibility at versatility ng Java sa pagmamanipula ng string.