جاوا ۾ اسٽرنگ کي ريورس ڪرڻ جا مختلف طريقا

جاوا ۾ اسٽرنگ کي به چئي سگھجي ٿو اکرن جي صف جي طور تي. جاوا ۾ اسٽرنگ ٽيڪسٽ/ڪردارن کي محفوظ ڪرڻ لاءِ استعمال ٿيندا آهن. جاوا پروگرامنگ ٻولي ۾، تارن کي شيون سمجهيو ويندو آهي. جاوا ۾، strings اڳئين بيان ڪيل شيون آھن جن کي ڪلاس جو نالو String آھي. سڀئي اسٽرنگ متغير جاوا ۾ اسٽرنگ ڪلاس جا مثال آهن. ان ڪري اسان سمجھي سگھون ٿا ته جاوا ۾ اسٽرنگ بنيادي قسم جا نه آھن جيئن ٻين پروگرامنگ ٻولين ۾ int يا char. هن آرٽيڪل ۾، اسان پڙهنداسين ته جاوا ۾ هڪ اسٽرنگ کي ڪيئن ريورس ڪجي، ان لاءِ شرط اها آهي ته توهان کي ڄاڻڻ گهرجي ته جاوا ۾ اسٽرنگ ڪيئن ٺاهيو وڃي ، ۽ ان بلٽ اسٽرنگ طريقن جو بنيادي تصور، ۽ لوپ جي مدد سان آپريشن ڪيئن ڪجي.

مضمون جو دائرو

- هن آرٽيڪل ۾، اسان مختلف طريقن جي باري ۾ پڙهي سگهنداسين ته جاوا ۾ اسٽرنگ کي ڪيئن ريورس ڪجي. - اسان ڪجھ اڳ ۾ ٺهيل طريقا پڻ ڏسندا سين جن جي ذريعي اسان جاوا ۾ ھڪڙي تار کي ريورس ڪري سگھون ٿا. - اسان جاوا ۾ هر ريورس طريقي جي وقت ۽ جڳهه جي پيچيدگي بابت پڻ پڙهي سگهنداسين. - جاوا ۾ اسٽرنگ کي ريورس ڪرڻ جا ڪيترائي طريقا آھن، ھر ھڪ پنھنجي فائدن ۽ نقصانن سان. هن آرٽيڪل ۾، اسان جاوا ۾ هڪ اسٽرنگ کي ريورس ڪرڻ لاء ڪجهه عام طور تي استعمال ٿيل طريقن جي ڳولا ڪنداسين.

تعارف

اسٽرنگ جاوا ۾ ناقابل تبديل شيون آهن، strings صرف جاوا ۾ ڪردارن جو هڪ سلسلو آهي. جاوا ۾ سنگل لائين اسٽرنگز کي سنگل اقتباس سان بيان ڪيو ويندو آھي جڏھن ته جاوا ۾ گھڻن لائنن جي اسٽرنگ کي ٽرپل اقتباس سان بيان ڪيو ويندو آھي، جاوا وٽ ڪيترائي اسٽرنگ طريقا موجود آھن، پر اڄ جي ھن آرٽيڪل ۾ اسين مختلف طريقن بابت پڙھندا سين ته جاوا ۾ اسٽرنگ کي ڪيئن ريورس ڪجي. جاوا پروگرامنگ ٻولي دنيا ۾ سڀ کان وڏي پيماني تي استعمال ٿيندڙ پروگرامنگ ٻولين مان هڪ آهي، ۽ اهو ان جي سادگي ۽ استعمال جي آسانيء لاء مشهور آهي. سڀ کان وڌيڪ عام عملن مان هڪ آهي جيڪو پروگرامر اسٽرنگ تي انجام ڏيندا آهن انهن کي رد ڪري رهيو آهي. هن آرٽيڪل ۾، اسان جاوا ۾ اسٽرنگ کي ريورس ڪرڻ لاء مختلف طريقن تي بحث ڪنداسين. پهرين، اچو ته سڀ کان وڌيڪ عام طريقي جي باري ۾ پڙهون جيڪو استعمال ڪري رهيو آهي جاوا ۾ لوپ لاء:

لوپ استعمال ڪندي جاوا ۾ اسٽرنگ کي ريورس ڪريو:

هي ٽيڪنڪ جاوا ۾ هڪ اسٽرنگ کي ريورس ڪرڻ لاء آسان طريقن مان هڪ آهي لوپ لاء استعمال ڪندي. اسان اسٽرنگ جي اکرن جي ذريعي پڇاڙي کان شروع ڪري سگھون ٿا، ۽ انھن کي نئين اسٽرنگ متغير ۾ شامل ڪري سگھون ٿا. هتي هڪ مثال آهي ته ڪيئن لوپ استعمال ڪندي اسٽرنگ کي ريورس ڪجي :

//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 ٺاهيو آهي ۽ پوءِ آخري انڊيڪس مان فار لوپ کي ٻيهر ڪيو آهي ۽ پوءِ اسان ان اسٽرنگ ۾ هر ڪردار جي قيمت محفوظ ڪئي آهي. بهتر ۽ واضح وضاحت لاءِ مٿي ڏنل ڪوڊ کي پنهنجي ايڊيٽر ۾ هلايو. مٿي ڏنل ڪوڊ جي وقت جي پيچيدگي O (N) آهي، ۽ جيئن اسان سڀني n عناصر تي ٻيهر بيان ڪيو آهي، مٿين ڪوڊ جي خلائي پيچيدگي O (N) آهي. ھاڻي اچو ته پڙھون ايندڙ عمل جي باري ۾ جيڪو اسٽرنگ بلڊر استعمال ڪندي اسٽرنگ کي ريورس ڪري رھيو آھي، سو ھاڻي اچو ته ان بابت تفصيل سان پڙھون:

اسٽرنگ بلڊر ڪلاس استعمال ڪندي اسٽرنگ کي ريورس ڪرڻ

اسان StringBuilder ڪلاس استعمال ڪندي جاوا ۾ اسٽرنگ کي به ريورس ڪري سگھون ٿا. StringBuilder ڪلاس هڪ ريورس () طريقو مهيا ڪري ٿو جيڪو اسٽرنگ کي ريورس ڪرڻ لاءِ استعمال ڪري سگهجي ٿو. ريورس () جاوا اسٽرنگ بلڊر ڪلاس جو طريقو استعمال ڪيو ويندو آھي ھن ڪردار جي ترتيب کي ترتيب جي ريورس سان تبديل ڪرڻ لاءِ. جاوا ۾ StringBuilder ڪلاس ۾ toCharArray() طريقو ناهي، جڏهن ته اسٽرنگ ڪلاس ۾ 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

هن طريقي ۾، اسان ڏسي سگهون ٿا ته ان بلٽ اسٽرنگ بلڊر ڪلاس استعمال ڪندي اسان اسٽرنگ کي واپس ڪيو آهي. اهو طريقو تمام ڪارائتو آهي، ڇاڪاڻ ته ان کي صرف اسٽرنگ ذريعي هڪ واحد پاس جي ضرورت آهي. بهرحال، ان کي ضرورت آهي هڪ نئين StringBuilder اعتراض جي تخليق، جيڪو ڪجهه مٿي شامل ڪري سگهي ٿو. اهو طريقو نسبتاً سادو ۽ سمجھڻ ۾ آسان آهي، پر اهو ٻين طريقن جي ڀيٽ ۾ گهٽ ڪارائتو ٿي سگهي ٿو، ڇاڪاڻ ته ان لاءِ اسٽرنگ ذريعي گھڻن پاسن ۽ هر ڪردار لاءِ نئين اسٽرنگ ٺاهڻ جي ضرورت آهي. بهتر ۽ واضح وضاحت لاءِ مٿي ڏنل ڪوڊ کي پنهنجي ايڊيٽر ۾ هلايو. ھاڻي اچو ته ريٽرننگ ٽيڪنڪ استعمال ڪندي اسٽرنگ کي ريورس ڪرڻ جو ٻيو طريقو ڏسو:

recursion استعمال ڪندي اسٽرنگ کي ريورس ڪريو

Recursion هڪ ٽيڪنڪ آهي جنهن ۾ هڪ فنڪشن پاڻ کي سڏيندو آهي. اسان recursion استعمال ڪري سگھون ٿا ھڪڙي اسٽرنگ کي ريورس ڪرڻ لاءِ ان کي ٽوڙڻ سان ننڍين ذيلي اسٽرينگ ۾. جاوا ۾ ورجائي هڪ عمل آهي جنهن ۾ هڪ طريقو پاڻ کي مسلسل سڏيندو آهي. recursion استعمال ڪندي جاوا ۾ اسٽرنگ کي ريورس ڪرڻ لاءِ پهريان اسان کي سٽرنگ مان پھرين ڪيڪرڪٽر کي ختم ڪرڻو پوندو ۽ پوءِ ان اکر کي اسٽرنگ جي آخر ۾ شامل ڪرڻو پوندو ۽ پوءِ اسان کي مٿي ڏنل قدم کي ورجائڻو پوندو جيستائين ان پٽ اسٽرنگ خالي نه ٿئي. هاڻي اچو ته ان کي هڪ مثال جي مدد سان سمجهون:

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

ان ڪري اسان ڏسي سگھون ٿا ته مٿي ڏنل ۾ ريٽرن استعمال ڪندي اسان سٽرنگ کي ريورس ڪيو آهي اسان پهريان چيڪ ڪيو آهي ته سٽرنگ خالي آهي يا نه جيڪڏهن اسٽرنگ خالي هوندي ته پوءِ ڪو به اکر نه هوندو جنهن کي ريورس ڪري سگهجي. اهو طريقو لوپ جي طريقي جي ڀيٽ ۾ وڌيڪ ڪارائتو ٿي سگهي ٿو، ڇاڪاڻ ته اهو صرف اسٽرنگ ذريعي هڪ واحد پاس جي ضرورت آهي. بهرحال، اهو پڻ وڌيڪ پيچيده ۽ سمجھڻ ڏکيو ٿي سگهي ٿو، ڇاڪاڻ ته ان ۾ شامل آهي recursion جو استعمال . بهتر ۽ واضح وضاحت لاءِ مٿي ڏنل ڪوڊ کي پنهنجي ايڊيٽر ۾ هلايو. اچو ته هڪ ٻيو مثال ڏسون ته جاوا ۾ ريڪرشن استعمال ڪندي اسٽرنگ کي ڪيئن ريورس ڪجي:

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

ھاڻي اچو ته پڙھون جاوا ۾ ھڪڙي اسٽرنگ کي ريورس ڪرڻ لاءِ ٻئي طريقي جي باري ۾ جيڪا ايري استعمال ڪري رھي آھي:

جاوا ۾ هڪ اسٽرنگ کي ريورس ڪريو هڪ صف استعمال ڪندي

اسان به هڪ اسٽرنگ کي ريورس ڪري سگھون ٿا ان کي ڪيڪٽر ايري ۾ تبديل ڪري، صف کي تبديل ڪري، ۽ پوءِ ان کي واپس اسٽرنگ ۾ تبديل ڪري. سڀ کان پهريان، اسان کي ڏنل اسٽرنگ جي ساڳي سائيز جي هڪ خالي ڪيڪچر اري ٺاهڻو آهي، پوءِ اسان کي ڏنل اسٽرنگ جي ڪردارن سان پٺتي پيل ڪيڪٽر اري کي ڀرڻو پوندو، ۽ پوءِ آخر ۾ اسان کي ڪيڪٽر ايري کي اسٽرنگ ۾ تبديل ڪرڻو پوندو. ڪاپي جو طريقو ۽ ان کي واپس. هاڻي اچو ته ان کي هڪ مثال جي مدد سان سمجهون:

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

هن طريقي ۾ اسان کي اسٽرنگ کي ريورس ڪرڻو پوندو هڪ ڪردار جي صف ۾ جيڪو اسان ڄاڻون ٿا ان ڪري سڀ کان پهريان اسان چيڪ ڪنداسين ته ڇا سٽرنگ خالي آهي يا نه ۽ واپسي جيڪڏهن اسٽرنگ null يا خالي آهي جيڪڏهن اهو خالي جي برابر آهي ته اسان صرف اسٽرنگ کي پرنٽ ڪنداسين ۽ بريڪ ٻي صورت ۾ اسان اسٽرنگ جي ڊگھائي ڳولينداسين ۽ پوءِ ريورس ڪرڻ کان پوءِ قيمت کي ذخيرو ڪرڻ لاءِ اسان کي سٽرنگ جي ساڳي سائيز جي ڪيڪر ايري ٺاهڻي پوندي ۽ لوپ کي پوئتي موٽڻ سان اسان کي اسٽرنگ ۾ ڪيڪرڪٽر ارري کي پٺتي پيل اکرن سان ڀرڻو پوندو. ۽ ريورس ڪرڻ کان پوءِ آخري مرحلي ۾ اسان کي ڪردار جي صف کي اسٽرنگ ۾ تبديل ڪرڻو پوندو ۽ ان کي واپس ڪرڻو پوندو. بهتر ۽ واضح وضاحت لاءِ مٿي ڏنل ڪوڊ کي پنهنجي ايڊيٽر ۾ هلايو. ھاڻي اچو ته پڙھون ايندڙ قدم جي باري ۾ اسان به ڪري سگھون ٿا اسٽرنگ کي جاوا ۾ اسٽريم API استعمال ڪندي. سو هاڻي اچو ته انهن بابت ڪجهه مثالن جي مدد سان تفصيل سان پڙهون:

اسٽريم API استعمال ڪندي جاوا ۾ اسٽرنگ کي ريورس ڪريو:

جاوا 8 متعارف ڪرايو اسٽريم API جيڪو مجموعن تي فنڪشنل طرز جي عملن کي انجام ڏيڻ لاءِ استعمال ٿي سگهي ٿو. اسان اسٽرنگ کي ريورس ڪرڻ لاءِ اسٽريم API استعمال ڪري سگھون ٿا ان کي اکرن جي اسٽريم ۾ تبديل ڪندي، اسٽريم کي ريورس ڪري، ۽ پوءِ ان کي واپس اسٽرنگ ۾ تبديل ڪري. اسان مختلف اسٽريمز ۽ ڪليڪٽرن کي استعمال ڪندي جاوا ۾ هڪ اسٽرنگ کي ريورس ڪري سگهون ٿا، پهريان اسان کي هڪ اسٽرنگ داخل ڪرڻي پوندي ۽ پوءِ پوري اسٽرنگ تي هڪ نقشو استعمال ڪندي هڪ StringBuilder اعتراض ۾ ۽ ساڳئي وقت ان کي ريورس () طريقي سان StringBuilder ڪلاس ۽ پوءِ آخرڪار، اسٽريم کي استعمال ڪندي ريورس ٿيل اسٽرنگ گڏ ڪرڻ. گڏ () طريقو ۽ جمع ڪندڙ. joining() طريقو اسان ٻنهي اصل/مٽڻ واري اسٽرنگ کي انهن جي ڊيگهه سان گڏ پرنٽ ڪنداسين. هاڻي اچو ته ان کي هڪ مثال جي مدد سان سمجهون:

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

هن مثال ۾، اسان جاوا اسٽريمز ۽ جمع ڪندڙ استعمال ڪندي جاوا ۾ اسٽرنگ کي رد ڪيو آهي. بهتر ۽ واضح وضاحت لاءِ مٿي ڏنل ڪوڊ کي پنهنجي ايڊيٽر ۾ هلايو. ھاڻي اچو ته ڏسون ته اسٽيڪ استعمال ڪندي اسٽرنگ کي ڪيئن ريورس ڪري سگھون ٿا. هاڻي اچو ته ان بابت تفصيل سان هڪ مثال جي مدد سان پڙهون:

اسٽيڪ استعمال ڪندي اسٽرنگ کي ريورس ڪريو

جاوا ۾ هڪ اسٽرنگ کي ريورس ڪرڻ جو هڪ ٻيو طريقو آهي جيڪو اسٽيڪ استعمال ڪندي آهي. خيال اهو آهي ته ان پٽ اسٽرنگ جي هر ڪردار کي اسٽيڪ ڏانهن ڌڪيو وڃي ۽ پوءِ اسٽيڪ مان ڪردارن کي پاپ ڪيو وڃي ته جيئن ريورس ٿيل اسٽرنگ حاصل ڪجي. هاڻي اچو ته ان بابت وڌيڪ تفصيل سان هڪ مثال جي مدد سان پڙهون:

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 ڪلاس، جنهن ۾ هڪ تعمير ٿيل ريورس () طريقو آهي جيڪو هڪ نئين اسٽرنگ کي واپس ڏئي ٿو جيڪو اصل اسٽرنگ جي ريورس آهي. ٻيو طريقو لوپ لاءِ استعمال ڪري رهيو آهي، جتي اسان اصل اسٽرنگ کي چار ايري ۾ تبديل ڪريون ٿا ۽ ريورس آرڊر ۾ آري ذريعي ٻيهر ترتيب ڏيون ٿا، لاڳاپيل ڪردارن کي نئين چار ايري کي تفويض ڪريون ٿا، ۽ آخرڪار ان چار ايري کي استعمال ڪندي هڪ نئين اسٽرنگ ٺاهي رهيا آهيون. ٽيون طريقو recursion استعمال ڪري رهيو آهي، جتي اسان هڪ recursive فنڪشن کي سڏيندا آهيون ۽ سٽرنگ جي پهرين اکر کي باقي اکرن جي reversed substring سان ڳنڍي مسئلو حل ڪندا آهيون. چوٿون طريقو جاوا ۾ اسٽرنگ کي ريورس ڪرڻ لاءِ هڪ صف استعمال ڪندي آهي. پنجين طريقي ۾، اسان اسٽرنگ کي ريورس ڪرڻ لاءِ اسٽريم API ۽ جاوا ڪليڪٽر استعمال ڪيو ۽، آخري طريقي ۾ اسان اسٽيڪ کي استعمال ڪيو اسٽرنگ کي جاوا ۾ ريورس ڪرڻ لاءِ. انهن طريقن مان هر هڪ جا پنهنجا فائدا ۽ نقصان آهن، ۽ طريقي جي چونڊ جو دارومدار مسئلي جي مخصوص ضرورتن ۽ پروگرامر جي ترجيحن تي آهي. مجموعي طور تي، اهي طريقا جاوا جي لچڪدار ۽ استحڪام کي ظاهر ڪن ٿا اسٽرنگ مينپوليشن ۾.