דרכים שונות להפוך מחרוזת ב-Java

מחרוזות בג'אווה יכולות להיאמר גם כמערך של תווים. מחרוזות ב-java משמשות לאחסון טקסט/תווים. בשפת התכנות java, המחרוזות נחשבות לאובייקטים. ב-Java, מחרוזות הן האובייקטים של מחלקה מוגדרת מראש בשם String. כל משתני המחרוזת הם מופעים של המחלקה String ב-java. מכאן שאנו יכולים להבין שהמחרוזות ב-java אינן מהסוגים הפרימיטיביים כמו int או char בשפות תכנות אחרות. במאמר זה, נקרא כיצד להפוך מחרוזת ב-java. התנאי המוקדם לכך הוא שידעו כיצד ליצור מחרוזת ב- java , ותפיסה בסיסית של שיטות מחרוזות מובנות, וכיצד לבצע פעולות בעזרת לולאות.

היקף המאמר

- במאמר זה, נקרא על הדרכים השונות כיצד להפוך מחרוזת ב-java. - נראה גם כמה שיטות מובנות מראש שבאמצעותן נוכל להפוך מחרוזת ב-java. - נקרא גם על מורכבות הזמן והמרחב של כל שיטה הפוכה ב-java. - ישנן מספר דרכים להפוך מחרוזת ב-Java, כל אחת עם היתרונות והחסרונות שלה. במאמר זה, נחקור כמה מהשיטות הנפוצות ביותר להיפוך מחרוזת ב-Java.

מבוא

מחרוזות הן אובייקטים בלתי ניתנים לשינוי ב-Java, מחרוזות הן רק רצף של תווים ב-Java. מחרוזות של שורות בודדות ב-java מוגדרות עם מרכאות בודדות ואילו מחרוזות של שורות מרובות ב-java מוגדרות עם מרכאות משולשות, ל-java יש מספר שיטות מחרוזות זמינות, אך היום במאמר זה נקרא על הדרכים השונות כיצד להפוך מחרוזת ב-java. שפת התכנות ג'אווה היא אחת משפות התכנות הנפוצות ביותר בעולם, והיא ידועה בפשטות ובנוחות השימוש שלה. אחת הפעולות הנפוצות ביותר שמתכנתים מבצעים על מחרוזות היא הפיכתן. במאמר זה, נדון בדרכים שונות להפוך מחרוזת ב-Java. ראשית, הבה נקרא על הדרך הנפוצה ביותר באמצעות לולאת for ב-Java:

הפוך את המחרוזת ב-java באמצעות לולאת for:

טכניקה זו היא אחת הדרכים הפשוטות ביותר להפוך מחרוזת ב-Java באמצעות לולאת for. אנחנו יכולים לחזור על תווי המחרוזת מהסוף להתחלה, ולהוסיף אותם למשתנה מחרוזת חדש. להלן דוגמה כיצד להפוך מחרוזת באמצעות לולאת 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);
  }
}

תְפוּקָה

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

בשיטה זו, אנו יכולים לראות שבאמצעות מחלקת בניית המחרוזות המובנית הפכנו את המחרוזת. שיטה זו יעילה מאוד, מכיוון שהיא דורשת רק מעבר בודד דרך המיתר. עם זאת, זה דורש יצירה של אובייקט 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

בשיטה זו עלינו להפוך את המחרוזת למערך תווים שאנו מכירים אז קודם כל נבדוק אם המחרוזת ריקה או לא ונחזור אם המחרוזת ריק או ריק אם היא שווה לריק אז פשוט נדפיס את המחרוזת ו break else נמצא את אורך המחרוזת ואז עלינו ליצור מערך תווים בגודל זהה לזה של מחרוזת כדי לאחסן את הערך לאחר היפוך ועל ידי איטרציה של הלולאה לאחור עלינו למלא את מערך התווים אחורה בתווים במחרוזת ובשלב האחרון לאחר היפוך עלינו להמיר את מערך התווים למחרוזת ולהחזיר אותו. הפעל את הקוד לעיל בעורך שלך לקבלת הסבר טוב יותר וברור. כעת תנו לנו לקרוא על השלב הבא שאנו יכולים גם להפוך את המחרוזת ב-java באמצעות ה- Stream API. אז עכשיו בואו נקרא עליהם בפירוט בעזרת כמה דוגמאות:

הפוך מחרוזת ב-java באמצעות ה-API של Stream:

Java 8 הציגה את ה- Stream API שניתן להשתמש בו לביצוע פעולות בסגנון פונקציונלי על אוספים. אנו יכולים להשתמש ב-Stream API כדי להפוך מחרוזת על ידי המרתה לזרם של תווים, היפוך של הזרם, ולאחר מכן המרה חזרה למחרוזת. אנו יכולים להפוך מחרוזת ב-Java באמצעות זרמים ואספנים שונים, ראשית עלינו להזין מחרוזת ולאחר מכן להשתמש במפה על ה-String כולו לתוך אובייקט StringBuilder ובמקביל להפוך אותו באמצעות שיטת reverse() של המחלקה StringBuilder ו ואז לבסוף, איסוף המחרוזת ההפוכה באמצעות הזרם. שיטת collect() ו-Collectors. שיטת 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, שבה אנו ממירים את המחרוזת המקורית למערך char וחוזרים דרך המערך בסדר הפוך, מקצה את התווים המתאימים למערך char חדש, ולבסוף יוצרים מחרוזת חדשה באמצעות אותו מערך char. השיטה השלישית היא שימוש ברקורסיה, שבה אנו קוראים לפונקציה רקורסיבית ופותרים את הבעיה על ידי שרשור התו הראשון של המחרוזת עם המחרוזת המשנה הפוכה של שאר התווים. השיטה הרביעית היא באמצעות מערך כדי להפוך מחרוזת ב-Java. בשיטה החמישית, השתמשנו ב-stream API ובאספן Java כדי להפוך את המחרוזת, ובשיטה האחרונה השתמשנו בערימה כדי להפוך את המחרוזת ב-java. לכל אחת מהשיטות הללו יש את היתרונות והחסרונות שלה, ובחירת השיטה תלויה בדרישות הספציפיות של הבעיה ובהעדפת המתכנת. בסך הכל, שיטות אלה מדגימות את הגמישות והרבגוניות של Java במניפולציה של מחרוזות.