วิธีต่างๆ ในการย้อนกลับสตริงใน Java

สตริงใน Java สามารถพูดได้ว่าเป็นอาร์เรย์ของอักขระ สตริงใน Java ใช้สำหรับจัดเก็บข้อความ/อักขระ ในภาษาการเขียนโปรแกรมจาวา สตริงถือเป็นอ็อบเจ็กต์ ใน Java สตริงเป็นอ็อบเจ็กต์ของคลาสที่กำหนดไว้ล่วงหน้าซึ่งมีชื่อว่า String ตัวแปรสตริงทั้งหมดเป็นอินสแตนซ์ของคลาส String ใน java ดังนั้นเราจึงเข้าใจได้ว่าสตริงใน java ไม่ใช่ประเภทดั้งเดิมเช่น int หรือ char ในภาษาการเขียนโปรแกรมอื่น ในบทความนี้ เราจะอ่านวิธีการย้อนกลับสตริงใน java สิ่งที่จำเป็นต้องมีคือคุณควรรู้วิธีสร้างสตริงในjava และแนวคิดพื้นฐานของวิธีสตริงแบบ inbuilt และวิธีการดำเนินการด้วยความช่วยเหลือของลูป

ขอบเขตของบทความ

- ในบทความนี้ เราจะอ่านเกี่ยวกับวิธีการต่างๆ ในการย้อนกลับสตริงใน java - นอกจากนี้เรายังจะเห็นวิธีการที่สร้างไว้ล่วงหน้าซึ่งเราสามารถย้อนกลับสตริงใน java ได้ - เราจะอ่านเกี่ยวกับความซับซ้อนของเวลาและพื้นที่ของวิธีการย้อนกลับแต่ละวิธีใน Java - มีหลายวิธีในการย้อนกลับสตริงใน Java แต่ละวิธีมีข้อดีและข้อเสีย ในบทความนี้ เราจะสำรวจวิธีการที่ใช้บ่อยที่สุดในการย้อนกลับสตริงใน Java

การแนะนำ

สตริงเป็นวัตถุที่ไม่เปลี่ยนรูปใน java สตริงเป็นเพียงลำดับของอักขระใน java สตริงบรรทัดเดี่ยวใน java ถูกกำหนดด้วยเครื่องหมายคำพูดเดี่ยว ในขณะที่สตริงหลายบรรทัดใน java ถูกกำหนดด้วยเครื่องหมายคำพูดสามบรรทัด java มีวิธีสตริงหลายวิธี แต่วันนี้ในบทความนี้ เราจะอ่านเกี่ยวกับวิธีการต่างๆ ในการย้อนกลับสตริงใน java ภาษาการเขียนโปรแกรม Java เป็นหนึ่งในภาษาโปรแกรมที่ใช้กันอย่างแพร่หลายที่สุดในโลก และเป็นที่รู้จักในด้านความเรียบง่ายและใช้งานง่าย หนึ่งในการดำเนินการทั่วไปที่โปรแกรมเมอร์ทำกับสตริงคือการย้อนกลับ ในบทความนี้ เราจะพูดถึงวิธีต่างๆ ในการกลับสตริงใน Java ก่อนอื่น ให้เราอ่านเกี่ยวกับวิธีการทั่วไปที่ใช้ for loop ใน java:

ย้อนกลับสตริงใน java โดยใช้ for loop:

เทคนิคนี้เป็นหนึ่งในวิธีที่ง่ายที่สุดในการย้อนกลับสตริงใน Java โดยใช้ for loop เราสามารถวนซ้ำอักขระของสตริงตั้งแต่ต้นจนจบ และเพิ่มลงในตัวแปรสตริงใหม่ นี่คือตัวอย่างวิธีการย้อนกลับสตริงโดยใช้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);
  }
}

เอาท์พุต

The reversed string of the s1 is:nuf si avaj

ในโค้ดข้างต้น ขั้นแรกเราได้นำอินพุตของสตริงชื่อ s1 และสร้างสตริงว่าง s2 จากนั้นวนซ้ำ for จากดัชนีสุดท้าย จากนั้นจึงเก็บค่าของอักขระแต่ละตัวในสตริงนั้น เรียกใช้โค้ดด้านบนในโปรแกรมแก้ไขของคุณเพื่อรับคำอธิบายที่ดีขึ้นและชัดเจน ความซับซ้อนของเวลาของโค้ดด้านบนคือ O(N) และเมื่อเราวนซ้ำองค์ประกอบ n ทั้งหมดแล้ว ความซับซ้อนของช่องว่างของโค้ดด้านบนคือ O(N) ตอนนี้ให้เราอ่านเกี่ยวกับกระบวนการถัดไปซึ่งจะกลับสตริงโดยใช้ตัวสร้างสตริง ดังนั้นตอนนี้ให้เราอ่านรายละเอียดเกี่ยวกับมัน:

การย้อนกลับสตริงโดยใช้คลาสตัวสร้างสตริง

นอกจากนี้เรายังสามารถย้อนกลับสตริงใน Java ได้โดยใช้คลาส StringBuilder คลาส StringBuilder มีเมธอด Reverse() ที่สามารถใช้เพื่อกลับสตริง เมธอด Reverse() ของคลาส Java StringBuilder ใช้เพื่อแทนที่ลำดับอักขระนี้ด้วยการย้อนกลับของลำดับ คลาส StringBuilder ใน java ไม่มีเมธอด toCharArray() ในขณะที่คลาส String ไม่มีเมธอด toCharArray() ตอนนี้ให้เราเข้าใจด้วยความช่วยเหลือของตัวอย่าง:

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

เอาท์พุต

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

ในวิธีนี้ เราจะเห็นได้ว่าการใช้คลาสตัวสร้างสตริง inbuilt เราได้ย้อนกลับสตริง วิธีนี้มีประสิทธิภาพมาก เนื่องจากต้องใช้การส่งผ่านสตริงเพียงครั้งเดียวเท่านั้น อย่างไรก็ตาม จำเป็นต้องมีการสร้างออบเจ็กต์ StringBuilder ใหม่ ซึ่งสามารถเพิ่มโอเวอร์เฮดได้ วิธีนี้ค่อนข้างง่ายและเข้าใจง่าย แต่อาจมีประสิทธิภาพน้อยกว่าวิธีอื่นๆ เนื่องจากต้องใช้การส่งผ่านสตริงหลายครั้งและสร้างสตริงใหม่สำหรับอักขระแต่ละตัว เรียกใช้โค้ดด้านบนในโปรแกรมแก้ไขของคุณเพื่อรับคำอธิบายที่ดีขึ้นและชัดเจน ตอนนี้เรามาดูวิธีอื่นในการย้อนกลับสตริงโดยใช้เทคนิคการเรียกซ้ำ:

ย้อนกลับสตริงโดยใช้การเรียกซ้ำ

การเรียกซ้ำเป็นเทคนิคที่ฟังก์ชันเรียกตัวเอง เราสามารถใช้การเรียกซ้ำเพื่อย้อนกลับสตริงโดยแบ่งสตริงย่อยออกเป็นสตริงย่อยที่มีขนาดเล็กลง การเรียกซ้ำใน Java เป็นกระบวนการที่เมธอดเรียกตัวเองอย่างต่อเนื่อง หากต้องการกลับสตริงใน java โดยใช้การเรียกซ้ำ ขั้นแรกเราต้องลบอักขระตัวแรกออกจากสตริง จากนั้นจึงเพิ่มอักขระนั้นต่อท้ายสตริง จากนั้นเราต้องทำซ้ำขั้นตอนข้างต้นจนกว่าสตริงอินพุตจะว่างเปล่า ตอนนี้ให้เราเข้าใจสิ่งนี้ด้วยความช่วยเหลือของตัวอย่าง:

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

เอาท์พุต

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

ดังนั้นเราจะเห็นได้ว่าข้างต้นนั้น การใช้การเรียกซ้ำ เราได้ย้อนกลับสตริง เราได้ตรวจสอบก่อนว่าสตริงว่างเปล่าหรือไม่ ถ้าสตริงว่างเปล่า จะไม่มีอักขระที่สามารถย้อนกลับได้ วิธีนี้สามารถมีประสิทธิภาพมากกว่าวิธี for-loop เนื่องจากต้องใช้การส่งผ่านสตริงเพียงครั้งเดียวเท่านั้น อย่างไรก็ตาม อาจมีความซับซ้อนและเข้าใจยากกว่า เนื่องจากเกี่ยวข้องกับการใช้การเรียกซ้ำ เรียกใช้โค้ดด้านบนในโปรแกรมแก้ไขของคุณเพื่อรับคำอธิบายที่ดีขึ้นและชัดเจน ให้เราดูอีกตัวอย่างหนึ่งของวิธีการย้อนกลับสตริงโดยใช้การเรียกซ้ำใน 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));
}

ตอนนี้ให้เราอ่านเกี่ยวกับวิธีอื่นในการย้อนกลับสตริงใน java ที่ใช้อาร์เรย์:

ย้อนกลับสตริงใน Java โดยใช้อาร์เรย์

นอกจากนี้เรายังสามารถย้อนกลับสตริงโดยแปลงเป็นอาร์เรย์อักขระ เปลี่ยนอาร์เรย์ แล้วแปลงกลับเป็นสตริง ขั้นแรก เราต้องสร้างอาร์เรย์อักขระว่างที่มีขนาดเท่ากับสตริงที่กำหนด จากนั้นเราจะต้องเติมอาร์เรย์อักขระไปข้างหลังด้วยอักขระของสตริงที่กำหนด จากนั้นสุดท้ายเราต้องแปลงอาร์เรย์อักขระให้เป็นสตริงโดยใช้ วิธีการคัดลอกแล้วส่งคืน ตอนนี้ให้เราเข้าใจสิ่งนี้ด้วยความช่วยเหลือของตัวอย่าง:

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

เอาท์พุต

NUF SI AVA

ในวิธีนี้ เราต้องย้อนกลับสตริงเป็นอาร์เรย์อักขระที่เราทราบ ดังนั้นก่อนอื่นเราจะตรวจสอบว่าสตริงว่างเปล่าหรือไม่ และส่งคืนหากสตริงเป็นโมฆะหรือว่างเปล่า ถ้ามันเท่ากับว่างเปล่า จากนั้นเราจะพิมพ์สตริงและ หากไม่เป็นเช่นนั้น เราจะหาความยาวของสตริง จากนั้นเราต้องสร้างอาร์เรย์อักขระที่มีขนาดเท่ากับสตริงเพื่อเก็บค่าหลังจากการย้อนกลับ และโดยการวนซ้ำลูปไปข้างหลัง เราจะต้องเติมอาร์เรย์อักขระไปข้างหลังด้วยอักขระในสตริง และในขั้นตอนสุดท้ายหลังจากการย้อนกลับ เราต้องแปลงอาร์เรย์อักขระเป็นสตริงแล้วส่งคืน เรียกใช้โค้ดด้านบนในโปรแกรมแก้ไขของคุณเพื่อรับคำอธิบายที่ดีขึ้นและชัดเจน ตอนนี้ให้เราอ่านเกี่ยวกับขั้นตอนถัดไปที่เรายังสามารถย้อนกลับสตริงใน java โดยใช้ Stream API ตอนนี้ให้เราอ่านรายละเอียดเกี่ยวกับพวกเขาโดยใช้ตัวอย่างบางส่วน:

ย้อนกลับสตริงใน java โดยใช้ Stream API:

Java 8 เปิดตัว Stream API ที่สามารถใช้เพื่อดำเนินการรูปแบบการใช้งานกับคอลเลกชัน เราสามารถใช้ Stream API เพื่อย้อนกลับสตริงโดยแปลงเป็นสตรีมของอักขระ ย้อนกลับสตรีม จากนั้นแปลงกลับเป็นสตริง เราสามารถย้อนกลับสตริงใน java โดยใช้สตรีมและตัวสะสมต่างๆ อันดับแรกเราต้องป้อนสตริงแล้วใช้ Map บน String ทั้งหมดลงในวัตถุ StringBuilder และในขณะเดียวกันก็ย้อนกลับโดยใช้วิธี Reverse() ของคลาส StringBuilder และ จากนั้นจึงรวบรวม String ที่กลับรายการโดยใช้ Stream วิธีการรวบรวม () และนักสะสม joining() วิธีการเราจะพิมพ์ทั้งสตริงดั้งเดิม / กลับด้านพร้อมกับความยาว ตอนนี้ให้เราเข้าใจสิ่งนี้ด้วยความช่วยเหลือของตัวอย่าง:

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

ในตัวอย่างนี้ เราได้ย้อนกลับสตริงใน Java โดยใช้สตรีม Java และตัวรวบรวม เรียกใช้โค้ดด้านบนในโปรแกรมแก้ไขของคุณเพื่อรับคำอธิบายที่ดีขึ้นและชัดเจน ตอนนี้เรามาดูกันว่าเราจะย้อนกลับสตริงโดยใช้สแต็กได้อย่างไร ตอนนี้ให้เราอ่านรายละเอียดโดยใช้ตัวอย่าง:

ย้อนกลับสตริงโดยใช้สแต็ก

มีอีกวิธีหนึ่งในการย้อนกลับสตริงใน Java ซึ่งก็คือการใช้สแต็ก แนวคิดคือการดันอักขระแต่ละตัวของสตริงอินพุตไปที่สแต็ก จากนั้นจึงป๊อปอักขระจากสแต็กเพื่อรับสตริงที่กลับรายการ ตอนนี้ให้เราอ่านรายละเอียดเพิ่มเติมโดยใช้ตัวอย่าง:

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>

ในตัวอย่างข้างต้น เราสร้างสแต็กว่างก่อน จากนั้นกลับสตริงและแทรกองค์ประกอบภายในสแต็ก วิธีนี้ง่าย เข้าใจง่าย และมีประสิทธิภาพ เรียกใช้โค้ดด้านบนในโปรแกรมแก้ไขของคุณเพื่อรับคำอธิบายที่ดีขึ้นและชัดเจน

บทสรุป

วิธีแรกคือโดยใช้คลาส StringBuilder ซึ่งมีเมธอด Reverse() ในตัวที่ส่งกลับสตริงใหม่ที่เป็นการย้อนกลับของสตริงต้นฉบับ วิธีที่สองคือการใช้ for loop โดยเราจะแปลงสตริงต้นฉบับเป็นอาร์เรย์ถ่านและวนซ้ำอาร์เรย์ในลำดับย้อนกลับ โดยกำหนดอักขระที่เกี่ยวข้องให้กับอาร์เรย์อักขระใหม่และสุดท้ายสร้างสตริงใหม่โดยใช้อาร์เรย์อักขระนั้น วิธีที่สามใช้การเรียกซ้ำ โดยที่เราเรียกใช้ฟังก์ชันเรียกซ้ำและแก้ไขปัญหาโดยการเชื่อมอักขระตัวแรกของสตริงเข้ากับสตริงย่อยที่กลับด้านของอักขระที่เหลือ วิธีที่สี่คือการใช้อาร์เรย์เพื่อกลับสตริงในจาวา ในวิธีที่ห้า เราใช้ stream API และตัวรวบรวม java เพื่อกลับสตริง และในวิธีสุดท้าย เราใช้ stack เพื่อกลับสตริงใน java แต่ละวิธีมีข้อดีและข้อเสีย และการเลือกวิธีการขึ้นอยู่กับข้อกำหนดเฉพาะของปัญหาและความชอบของโปรแกรมเมอร์ โดยรวมแล้ว วิธีการเหล่านี้แสดงให้เห็นถึงความยืดหยุ่นและความอเนกประสงค์ของ Java ในการจัดการกับสตริง