Cara Berbeza untuk Membalikkan Rentetan dalam Java

Rentetan dalam java juga boleh dikatakan sebagai tatasusunan aksara. Rentetan dalam java digunakan untuk menyimpan teks/aksara. Dalam bahasa pengaturcaraan java, rentetan dianggap sebagai objek. Di Jawa, rentetan ialah objek bagi kelas yang telah ditetapkan iaitu String. Semua pembolehubah rentetan adalah contoh kelas String dalam java. Oleh itu, kita boleh memahami bahawa rentetan dalam java bukanlah jenis primitif seperti int atau char dalam bahasa pengaturcaraan lain. Dalam artikel ini, kita akan membaca cara untuk membalikkan rentetan dalam java prasyarat untuk ini ialah anda harus tahu cara mencipta rentetan dalam java , dan konsep asas kaedah rentetan terbina, dan cara melaksanakan operasi dengan bantuan gelung.

Skop artikel

- Dalam artikel ini, kita akan membaca tentang pelbagai cara bagaimana untuk membalikkan rentetan dalam java. - Kami juga akan melihat beberapa kaedah pra-bina yang melaluinya kami boleh membalikkan rentetan dalam java. - Kami juga akan membaca tentang kerumitan masa dan ruang bagi setiap kaedah terbalik dalam java. - Terdapat beberapa cara untuk membalikkan rentetan dalam Java, masing-masing dengan kelebihan dan kekurangannya. Dalam artikel ini, kami akan meneroka beberapa kaedah yang paling biasa digunakan untuk membalikkan rentetan dalam Java.

pengenalan

Rentetan ialah objek tidak berubah dalam java, rentetan hanyalah urutan aksara dalam java. Rentetan baris tunggal dalam java ditakrifkan dengan petikan tunggal manakala rentetan berbilang baris dalam java ditakrifkan dengan petikan tiga kali ganda, java mempunyai beberapa kaedah rentetan yang tersedia, tetapi hari ini dalam artikel ini kita akan membaca tentang cara yang berbeza bagaimana untuk membalikkan rentetan dalam java. Bahasa pengaturcaraan Java adalah salah satu bahasa pengaturcaraan yang paling banyak digunakan di dunia, dan ia terkenal dengan kesederhanaan dan kemudahan penggunaannya. Salah satu operasi paling biasa yang dilakukan oleh pengaturcara pada rentetan ialah membalikkannya. Dalam artikel ini, kita akan membincangkan cara yang berbeza untuk membalikkan rentetan dalam Java. Mula-mula, mari kita baca tentang cara paling biasa yang menggunakan gelung for dalam java:

Balikkan rentetan dalam java menggunakan gelung for:

Teknik ini adalah salah satu cara paling mudah untuk membalikkan rentetan dalam Java dengan menggunakan gelung for. Kita boleh melelar melalui aksara rentetan dari akhir hingga awal, dan menambahnya pada pembolehubah rentetan baharu. Berikut ialah contoh cara membalikkan rentetan menggunakan gelung 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);
  }
}

Pengeluaran

The reversed string of the s1 is:nuf si avaj

Dalam kod di atas, kami telah mula-mula mengambil input rentetan bernama s1 dan mencipta rentetan kosong s2 dan kemudian mengulangi gelung for daripada indeks terakhir dan kemudian kami telah menyimpan nilai setiap aksara dalam rentetan itu. Jalankan kod di atas dalam editor anda untuk penjelasan yang lebih baik dan jelas. Kerumitan masa kod di atas ialah O(N), dan seperti yang kita telah lelaran ke atas semua elemen n, kerumitan ruang kod di atas ialah O(N). Sekarang mari kita baca tentang proses seterusnya yang membalikkan rentetan menggunakan pembina rentetan, jadi sekarang mari kita membacanya secara terperinci:

Membalikkan rentetan menggunakan kelas pembina rentetan

Kita juga boleh membalikkan rentetan dalam Java dengan menggunakan kelas StringBuilder. Kelas StringBuilder menyediakan kaedah reverse() yang boleh digunakan untuk membalikkan rentetan. Kaedah reverse() kelas Java StringBuilder digunakan untuk menggantikan jujukan aksara ini dengan urutan terbalik. Kelas StringBuilder dalam java tidak mempunyai kaedah toCharArray(), manakala kelas String mempunyai kaedah toCharArray(). Sekarang mari kita fahami dengan bantuan contoh:

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

Pengeluaran

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

Dalam kaedah ini, kita dapat melihat bahawa menggunakan kelas pembina rentetan terbina kita telah membalikkan rentetan itu. Kaedah ini sangat cekap, kerana ia hanya memerlukan satu laluan melalui rentetan. Walau bagaimanapun, ia memerlukan penciptaan objek StringBuilder baharu, yang boleh menambah beberapa overhed. Kaedah ini agak mudah dan mudah difahami, tetapi ia mungkin kurang cekap berbanding kaedah lain, kerana ia memerlukan berbilang laluan melalui rentetan dan penciptaan rentetan baharu untuk setiap aksara. Jalankan kod di atas dalam editor anda untuk penjelasan yang lebih baik dan jelas. Sekarang mari kita lihat cara lain untuk membalikkan rentetan menggunakan teknik rekursi:

Balikkan rentetan menggunakan rekursi

Rekursi ialah teknik di mana fungsi memanggil dirinya sendiri. Kita boleh menggunakan rekursi untuk membalikkan rentetan dengan memecahkannya kepada subrentetan yang lebih kecil. Rekursi dalam java ialah proses di mana kaedah memanggil dirinya secara berterusan. Untuk membalikkan rentetan dalam java menggunakan rekursi terlebih dahulu kita perlu mengeluarkan aksara pertama daripada rentetan dan kemudian menambah aksara itu pada penghujung rentetan dan kemudian kita perlu mengulangi langkah di atas sehingga rentetan input menjadi kosong. Sekarang mari kita fahami ini dengan bantuan contoh:

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

Pengeluaran

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Oleh itu, kita dapat melihat bahawa dalam perkara di atas bahawa menggunakan rekursi kita telah membalikkan rentetan kita telah terlebih dahulu menyemak sama ada rentetan itu kosong atau tidak jika rentetan itu akan kosong maka tidak akan ada aksara yang boleh diterbalikkan. Kaedah ini boleh menjadi lebih cekap daripada kaedah gelung untuk, kerana ia hanya memerlukan satu laluan melalui rentetan. Walau bagaimanapun, ia juga boleh menjadi lebih kompleks dan lebih sukar untuk difahami, kerana ia melibatkan penggunaan rekursi . Jalankan kod di atas dalam editor anda untuk penjelasan yang lebih baik dan jelas. Mari kita lihat satu lagi contoh bagaimana untuk membalikkan rentetan menggunakan rekursi dalam 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));
}

Sekarang mari kita baca tentang cara lain untuk membalikkan rentetan dalam java yang menggunakan tatasusunan:

Balikkan rentetan dalam java menggunakan tatasusunan

Kita juga boleh membalikkan rentetan dengan menukarnya kepada tatasusunan aksara, menukar tatasusunan dan kemudian menukarnya kembali kepada rentetan. Mula-mula, kita perlu mencipta tatasusunan aksara kosong dengan saiz yang sama seperti rentetan yang diberikan kemudian kita perlu mengisi tatasusunan aksara ke belakang dengan aksara rentetan yang diberikan, dan kemudian akhirnya kita perlu menukar tatasusunan aksara kepada rentetan menggunakan kaedah salin dan kembalikannya. Sekarang mari kita fahami ini dengan bantuan contoh:

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

Pengeluaran

NUF SI AVA

Dalam kaedah ini kita perlu membalikkan rentetan kepada tatasusunan aksara yang kita tahu jadi pertama sekali kita akan menyemak sama ada rentetan itu kosong atau tidak dan kembali jika rentetan itu batal atau kosong jika ia sama dengan kosong maka kita hanya akan mencetak rentetan itu dan jika tidak, kita akan mencari panjang rentetan dan kemudian kita perlu mencipta tatasusunan aksara yang sama saiznya dengan rentetan untuk menyimpan nilai selepas membalikkan dan dengan mengulangi gelung ke belakang kita perlu mengisi tatasusunan aksara ke belakang dengan aksara dalam rentetan dan dalam langkah terakhir selepas membalikkan kita perlu menukar tatasusunan aksara kepada rentetan dan mengembalikannya. Jalankan kod di atas dalam editor anda untuk penjelasan yang lebih baik dan jelas. Sekarang mari kita baca tentang langkah seterusnya kita juga boleh membalikkan rentetan dalam java menggunakan API Strim. Jadi sekarang mari kita baca tentang mereka secara terperinci dengan bantuan beberapa contoh:

Balikkan rentetan dalam java menggunakan API Strim:

Java 8 memperkenalkan API Strim yang boleh digunakan untuk melaksanakan operasi gaya fungsian pada koleksi. Kita boleh menggunakan API Strim untuk membalikkan rentetan dengan menukarnya kepada aliran aksara, membalikkan strim dan kemudian menukarnya semula kepada rentetan. Kita boleh membalikkan rentetan dalam java menggunakan pelbagai aliran dan pengumpul terlebih dahulu kita perlu memasukkan rentetan dan kemudian menggunakan Peta pada keseluruhan String ke dalam objek StringBuilder dan pada masa yang sama membalikkannya menggunakan kaedah reverse() kelas StringBuilder dan kemudian Akhir sekali, kumpulkan Rentetan terbalik menggunakan Strim. kaedah collect() dan Pengumpul. kaedah joining() kami akan mencetak kedua-dua Rentetan asal/terbalik bersama dengan panjangnya. Sekarang mari kita fahami ini dengan bantuan contoh:

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

Dalam contoh ini, kami telah membalikkan rentetan dalam java menggunakan aliran java dan pengumpul. Jalankan kod di atas dalam editor anda untuk penjelasan yang lebih baik dan jelas. Sekarang mari kita lihat bagaimana kita boleh membalikkan rentetan menggunakan timbunan. Sekarang mari kita baca tentangnya secara terperinci dengan bantuan contoh:

Balikkan rentetan menggunakan timbunan

Terdapat satu lagi cara untuk membalikkan rentetan dalam Java iaitu dengan menggunakan timbunan. Ideanya adalah untuk menolak setiap aksara rentetan input ke tindanan dan kemudian pop aksara dari tindanan untuk mendapatkan rentetan terbalik. Sekarang mari kita membaca lebih lanjut mengenainya secara terperinci dengan bantuan contoh:

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>

Dalam contoh di atas, kami mula-mula mencipta tindanan kosong dan kemudian membalikkan rentetan dan memasukkan unsur-unsur di dalam tindanan. Kaedah ini mudah, mudah difahami dan berkesan. Jalankan kod di atas dalam editor anda untuk penjelasan yang lebih baik dan jelas.

Kesimpulan

Kaedah pertama ialah dengan menggunakan kelas StringBuilder, yang mempunyai kaedah reverse() terbina dalam yang mengembalikan rentetan baharu yang merupakan kebalikan rentetan asal. Kaedah kedua menggunakan gelung for, di mana kita menukar rentetan asal kepada tatasusunan char dan lelaran melalui tatasusunan dalam susunan terbalik, memberikan aksara yang sepadan kepada tatasusunan aksara baharu, dan akhirnya mencipta rentetan baharu menggunakan tatasusunan aksara itu. Kaedah ketiga adalah menggunakan rekursi, di mana kita memanggil fungsi rekursif dan menyelesaikan masalah dengan menggabungkan aksara pertama rentetan dengan subrentetan terbalik bagi aksara yang tinggal. Kaedah keempat adalah dengan menggunakan tatasusunan untuk membalikkan rentetan dalam java. Dalam kaedah kelima, kami menggunakan API aliran dan pengumpul java untuk membalikkan rentetan dan, Dalam kaedah terakhir kami menggunakan tindanan untuk membalikkan rentetan dalam java. Setiap kaedah ini mempunyai kelebihan dan kekurangannya, dan pilihan kaedah bergantung pada keperluan khusus masalah dan keutamaan pengaturcara. Secara keseluruhan, kaedah ini menunjukkan fleksibiliti dan serba boleh Java dalam manipulasi rentetan.