האם הגדר מקבל ערכים כפולים?

אם ננסה להכניס ערכים כפולים ב”סט “, מה יקרה? האם אנו מקבלים כל שגיאה מתלוננת

כאשר אנו מנסים להכניס ערכים כפולים ב”סט “, זה לא מוסיף את הערכים הכפולים. שיטת “הוסף” של הממשק שנקבע מחזירה ערך בוליאני, ומציינת אם האלמנט הוסיף בהצלחה או לא. אם ננסה להוסיף ערך כפול, השיטה תחזיר שקר. התנהגות זו עקבית בשפות תכנות שונות, כמו Java ו- Swift.

כיצד ליצור סט עם אלמנטים כפולים ב- SWIFT

בסוויפט, סט הוא אוסף של אלמנטים ייחודיים ללא כפילויות. עם זאת, ניתן ליצור סט עם אלמנטים כפולים. כאשר אנו יוצרים סט עם אלמנטים כפולים ב- SWIFT, השפה מכירה בכך שיש להסיר את הכפילויות. מכאן שהוא מסיר אוטומטית את כל האלמנטים הכפולים. תכונה זו הופכת את Swift Sets שימושי להפליא לטיפול באוספים של ערכים ייחודיים.

סקירה כללית

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

תחביר

בואו setName: הגדר&lt;אֵלֵמֶנט&gt; = [DuplaticeElements]

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

פרמטרים

setName: זה שם הסט שאנחנו רוצים ליצור.
משכפל: אלה הם האלמנטים שאנחנו רוצים להוסיף לתפאורה. אלמנטים אלה יכולים להיות כפילויות.
סוג: זהו סוג הסט, כגון int, מחרוזת וכו ‘. זה מציין את סוג האלמנטים שניתן לאחסן בערכה.

ערך החזרה

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

יבוא סוויפט
תן להרצאה: להגדיר&lt;Int&gt; = [023, 023, 055, 034, 065, 065, 134]
תן ל- UserID: להגדיר&lt;חוּט&gt; = ["24SD2", "24SD2", "24SD2", "24SD2"]
תן לשוויון: להגדיר&lt;Int&gt; = [2, 4, 6, 8, 10, 6, 2, 10]
תן ל- iSstudentnice: הגדר&lt;בול&gt; = [שקר, נכון, נכון, שקר, שקר]
תן מחירים: להגדיר&lt;לְהַכפִּיל&gt; = [24.32, 45.32, 40.00, 1.45, 1.45, 24.32]
תן שמות: הגדר&lt;חוּט&gt; = ["תיאודור", "תיאודור", "רות", "צ'יצ'י", "אמקה", "תיאודור"]
הדפס (הרצאה)
הדפס (USERID)
הדפס (Eventnumbers)
הדפס (isstudentnice)
הדפס (מחירים)
הדפס (שמות)

הֶסבֵּר

שורות 4-9: אנו יוצרים קבוצות באמצעות סוג SET ומציין את סוגי האלמנטים שלהם. כל סט מכיל כמה אלמנטים כפולים.
שורות 12-17: אנו מדפיסים את הסטים לקונסולה כדי להתבונן בהתנהגות הסטים עם כפילויות.
אנו מבחינים כי SWIFT מסיר אוטומטית כל אלמנטים כפולים מהסטים.

תוכנית פשוטה להפגנה, מה קורה אם אתה מוסיף אלמנטים כפולים לסט.

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

יבוא ג'אווה.שימוש.Hashset;
יבוא ג'אווה.שימוש.מַעֲרֶכֶת;
כיתה ציבורית canadduplicatevalueinset {
    מיין ריק סטטי ציבורי (מחרוזת [] args) {
        מַעֲרֶכֶת&lt;חוּט&gt; iniquecolours = חדש hashset <> ();
        יחידות יחידות.הוסף ("אדום");
        יחידות יחידות.הוסף ("ירוק");
        יחידות יחידות.הוסף ("כחול");
        יחידות יחידות.הוסף ("כחול"); / * הוספת ערך כפול כאן, אין שגיאת מהדר וקוד עובדת מצוין אך לא מוסיפה ערך כפול */
        עבור (צבע מחרוזת: iniquecolours) {
            מערכת.הַחוּצָה.println (צבע);
        }
    }
}

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

אם אנו מנסים להכניס ערכים כפולים ב “מַעֲרֶכֶת”, מה יקרה? האם אנו מקבלים כל שגיאה מתלוננת

פשוט זה לא’t הוסף כפול ערכים. בוליאני לְהוֹסִיף(E E) – מוסיף את שצוין אֵלֵמֶנט לזה מַעֲרֶכֶת אם הוא כבר לא קיים (פעולה אופציונלית). כפי ש, לְהוֹסִיף() השיטה מחזירה בוליאנית ואילך מוֹסִיף כפילויות זה יחזור שקר. לְהַלָן ג’אווה דוגמת קוד המקור עובדת מצוין ו- JVM (מכונה וירטואלית של Java) לא’לא להתלונן.

כיצד ליצור סט עם אלמנטים כפולים ב- SWIFT

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

קבל מסלול בחינם

סקירה כללית

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

תחביר


בואו setName: set = [duplaticelements]
// על ידי ציון סוג הסט
בואו setName: set = [duplaticelements]

תחביר ליצירת אלמנטים כפולים של סט

פרמטרים

setName: זה שם הסט שאנחנו רוצים ליצור.

משכפל: זה מייצג את האלמנטים של הסטים שהם כפילויות.

סוג: זה סוג הסט. זה יכול להיות אינט, מחרוזת וכן הלאה.

ערך החזרה

הערך שהוחזר לאחר יצירת קבוצה עם אלמנטים כפולים יהיה קבוצה המפטרת את כל הכפילויות.


יבוא סוויפט
 // צור אוספי סט כפולים
תן להרצאה: SET = [023, 023, 055, 034, 065,065, 134]
תן ל- UserID: set = ["24SD2", "24SD2", "24SD2", "24SD2"]
תן לשוויון: סט = [2, 4, 6, 8, 10, 6, 2, 10]
תן ל- iSstudentNice: set = [שקר, נכון, נכון, שקר, שקר]
תן מחירים: להגדיר = [24.32, 45.32, 40.00, 1.45, 1.45, 24.32]
תן שמות: set = ["תיאודור", "תיאודור", "רות", "צ'יצ'י", "אמקה", "תיאודור"]
 // הדפס את הסטים לקונסולה
הדפס (הרצאה)
הדפס (USERID)
הדפס (Eventnumbers)
הדפס (isstudentnice)
הדפס (מחירים)
הדפס (שמות)

יצירת אובייקטים מוגדרים עם אלמנטים כפולים ב- SWIFT

הֶסבֵּר

שורות 4–9: אנו יוצרים כמה קבוצות. כל סט מכיל כמה כפילויות.
שורות 12–17: אנו מדפיסים את הסטים לקונסולה.

אנו מבחינים כי סוויפט משליך כל כפילויות.

אם אנו מנסים להכניס ערכים כפולים ב “מַעֲרֶכֶת”, מה יקרה? האם אנו מקבלים כל שגיאה מתלוננת?

פשוט זה לא’t הוסף כפול ערכים. בוליאני לְהוֹסִיף(E E) – מוסיף את שצוין אֵלֵמֶנט לזה מַעֲרֶכֶת אם הוא כבר לא קיים (פעולה אופציונלית). כפי ש, לְהוֹסִיף() השיטה מחזירה בוליאנית ואילך מוֹסִיף כפילויות זה יחזור שקר. לְהַלָן ג’אווה דוגמת קוד המקור עובדת מצוין ו- JVM (מכונה וירטואלית של Java) לא’לא להתלונן.

אם אנו מכניסים ערכים כפולים לסט, אנו לא’לא לקבל כל זמן קומפילציה או הפעלת שגיאות זמן. זה לא’t הוסף ערכים כפולים בערכה.

להלן שיטת Add () של ממשק הגדרת באוסף Java המחזירה ערך בוליאני נכון או לא נכון כאשר האובייקט כבר קיים בערכה.

[בוליאני הוסף (E E) – מוסיף את האלמנט שצוין למערך זה אם הוא כבר לא קיים . חוזר: ערך בוליאני נכון/שקר.]

תוכנית פשוטה להפגנה, מה קורה אם אתה מוסיף אלמנטים כפולים לסט.

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

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

דוגמה לקוד המקור: כדי לבדוק אם הגדרת Java הוסיפו אותו אלמנט או לא

יבוא ג'אווה.שימוש.Hashset; יבוא ג'אווה.שימוש.מַעֲרֶכֶת; מעמד ציבורי CanadduplicateValueInset < public static void main(String[] args) < Set uniqueColours = new HashSet(); uniqueColours.add("Red"); uniqueColours.add("Green"); uniqueColours.add("Blue"); uniqueColours.add("Blue"); /*Adding duplicate value here, No compiler error and code works fine but doesn't add duplicate value */ System.out.println("Colours available in set are:"); for (String c : uniqueColours)< System.out.println(c); >>>

תְפוּקָה:
הצבעים הזמינים בסט הם:
כְּחוֹל
אָדוֹם
ירוק

שאלות כיבוד מהירות ותשובות על הגדרת Java הוסף כפול.

ש) יכול ל- hashset יש ערכים כפולים?

א) לא, ל- hashset לא יכול להיות ערכים כפולים.

א) ערך בוליאני מוחזר על ידי שיטת ADD () IT.ה. נכון באובייקט אינו קיים ושגוי אם כבר קיים בערכה.

א) התוכנית לא תציג שום שגיאת מהדר או שגיאת זמן והיא לא תאפשר כפילויות.

אם אנו מנסים להכניס ערכים כפולים ב “מַעֲרֶכֶת”, מה יקרה? האם אנו מקבלים כל שגיאה מתלוננת?

להלן 4 דרכים להדפיס אלמנטים של ArrayList ב- Java

מהו תור עדיפות של Java עם דוגמה ליישום בזמן אמת?

מה דומה ומשווה ב- Java?

הסבירו וקטור, מורכבות זמן וכיצד וקטור גדל ב- Java

אוספי Java אוספי שאלות נפוצות עם תשובות עם תשובות – אמיתי

נושאים מקובצים

שאלות ראיון של ג’אווה

שאלות ליבה של ג’אווה
שאלות אוספי Java
שאלות רב -ריבוי של Java
הדרכות Java
תרגילי ג’אווה

שאלות ראיון C/C ++

C תכנות
C ++ שאלות בסיסיות
C ++ שאלות מקדמות
שאלות תכנות C ++
דוגמאות תכנות C ++

C# שאלות ראיון

C# שאלות בסיסיות
C# שאלות מקדמות
C# שאלות מרובות ריבוי
C# שאלות תכנות
תרגילי תכנות C
C# דוגמאות קידוד
C# הדרכות

שאלות אמריקאיות

סדרת פיבונאצ’י ב- Java באמצעות רקורסיה ולא רקורסיה
סדרת Fibonacci ב- Java באמצעות לולאה – היגיון ברור
מדוע להשתמש בדפוסי עיצוב – הסיבות הטובות ביותר
סיפור אמיתי: איך כל מטרי ה- CSE קיבלו את זה בעבודה בעוד 5 חודשים
50 Java McQs מסובכים – בדוק אם אתה יכול לענות

ג
C דוגמאות לתכנות
C# מתקדם
C# בסיסי
C# ריבוי הברגה
תרגילי תוכנית C
C# תכנות
C# דוגמאות לתכנות
C# הדרכות
C ++ מתקדם
C ++ בסיסי
תכנות C ++
דוגמאות תכנות C ++
סִמוּל
ליבה ג’אווה
תבניות עיצוב
דפוסי עיצוב ועקרונות
DS & Algo
מחבר אלקטרוני
ראיונות HR
ראיון סיפור הצלחה
קידוד ג’אווה
אוספי ג’אווה
דוגמאות לאוספי Java
תרגילי ג’אווה
Java Multithreading
הערות ג’אווה
הדרכה של Java
חידות מתמטיות
MCQ-C++
MCQ-Java
MCQ-SQL
אלגוריתמים של MCQS ומבנה נתונים
כללי רשת
Oracle PL SQL
אחרים
עבודות תוכנה
SQL
מסד נתונים של SQL
מורכבות זמן
תרשים UML
לא מסווג

Java: מדוע סט יכול להכיל אלמנטים כפולים

הצטרף לקהילת Dzone וקבל את חווית החבר המלאה.

ביישומים נמוכים לאחצן, יצירת אובייקטים מיותרים נמנעת לרוב על ידי שימוש חוזר באובייקטים הניתנים להשתנות כדי להפחית את לחץ הזיכרון ובכך העומס על אספן האשפה. זה גורם לאפליקציה להפעיל הרבה יותר דטרמיניסטית ועם הרבה פחות ריצוד. עם זאת, יש להקפיד על אופן השימוש באובייקטים שנעשה בו שימוש חוזר, או אחרת תוצאות בלתי צפויות עשויות להתבטא, למשל בצורה של קבוצה המכילה אלמנטים כפולים כמו [B, B].

Hashcode ושווים

ג’אווה’S ByteBuffer מובנה מספק גישה ישירה לערמה וזיכרון מקורי באמצעות כתובת 32 סיביות. Chronicle Bytes הוא 64 סיביות המתייחס להחלפת ירידה של קוד פתוח ומאפשר לטפל בקטעי זיכרון גדולים בהרבה. שני הסוגים הללו מספקים שיטה hashcode () ושיטה שווה () התלויה בתכולת הבייט של האובייקטים’ קטע זיכרון בסיסי. אמנם זה יכול להיות שימושי במצבים רבים, אך אין להשתמש בחפצים משתנים כמו אלה ברוב ה- Java’S סוגי סט מובנים ולא כמפתח ברוב סוגי המפות המובנים.

הערה: במציאות, רק 31 ו -63 ביטים עשויים לשמש כקיזוז כתובת אפקטיבי (ה.ז. באמצעות פרמטרים של קיזוז int וארוך)

מפתחות משתנים

להלן מוצגת דוגמא לקוד קטן הממחישה את הבעיה עם אובייקטים הניתנים לשינוי חוזר. הקוד מציג שימוש בבתים אך אותה בעיה קיימת עבור ByteBuffer.

Set set = חדש hashset <> (); בתים בתים = בתים.מ"); מַעֲרֶכֶת.הוסף (בתים); // שימוש חוזר בתים.כתיבה (0); // זה משתנה את האובייקט הקיים כבר // בתים שנקבעו.לכתוב ("B"); // מוסיף שוב את אותו אובייקט Bytes אך כעת תחת // SET HashCode אחר ().הוסף (בתים); מערכת.הַחוּצָה.println (&ldquo;SET = &ldquo; + מַעֲרֶכֶת);

הקוד שלמעלה יוסיף תחילה אובייקט עם “א” כתוכן כלומר שהסט מכיל [א]. ואז התוכן של אותו אובייקט קיים ישתנה ל “ב”, שיש לו את תופעת הלוואי של שינוי הסט להכיל [B] אך ישאיר את ערך קוד החשיש הישן ואת דלי החשיש המתאים ללא שינוי (למעשה הופך להיות מעופש). לבסוף, האובייקט שהשתנה מתווסף שוב לסט אך כעת תחת קוד חשיש אחר המוביל לכניסה הקודמת לאותו אובייקט ממש יישאר!

כתוצאה מכך, ולא הצפוי אולי [A, B], זה יפיק את התפוקה הבאה:

טקסט רגיל

set = [b, b]

Bytebuffer ובתים חפצים כמפתחות במפות

בעת שימוש ב- Java’S bytebuffer אובייקטים או חפצי בתים כמפתחות במפות או כאלמנטים בקבוצות, פיתרון אחד הוא באמצעות IdentityHashmap או אוספים.NewsetFrommap (IdentityHashMap <> ()) להגנה מפני ייחודיות האובייקטים הניתנים להשתנות שתוארו לעיל. זה הופך את החשיפה של האובייקטים אגנוסטיים לתוכן בתים בפועל ובמקום זאת ישתמשו במערכת.IdentityHashCode () שלעולם לא משתנה במהלך חיי האובייקט.

אלטרנטיבה נוספת היא להשתמש בגרסה לקריאה בלבד של האובייקטים (למשל על ידי קריאת bytebuffer.asreadonlybuffer ()) להימנע מלהחזיק כל התייחסות לאובייקט המקורי הניתן להשתנה שיכול לספק דלת אחורית לשינוי האובייקט לכאורה לקריאה בלבד’S תוכן.

מפת כרוניקה ותור כרוניקה

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

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

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

מסקנות

זה מסוכן להשתמש באובייקטים הניתנים להשתנות, כגון בתים ו- ByteBuffer שבהם ה- hashcode () תלוי בתוכן האובייקט, במפה מסוימת וביישומים קביעים.

IdentityHashMap מגן מפני השחיתות של מפות ומערכות עקב מוטציה של אובייקט אך הופך מבנים אלה לאגנוסטיים לתכולת הבייט בפועל.

גרסאות לקריאה בלבד של אובייקטים של קטע זיכרון ששונו בעבר עשויות לספק פיתרון חלופי.

תור מפת כרוניקה ותור כרוניקה מאפשרים שימוש בלתי מוגבל באובייקטים משתנים, פותחים את הנתיב לפעולות דטרמיניסטיות נמוכות.