מאמר זה מדגים את ההליך להסרה וגישה לרכיבי ConcurrentHashMap ב-Java.
כיצד להסיר רכיבי ConcurrentHashMap ב- Java?
ניתן להסיר את האלמנטים הספציפיים מה-' ConcurrentHashMap ' אלמנטים דרך ' לְהַסִיר() ' שיטה. כדי להסיר את כל הרכיבים בבת אחת, ה-' ברור() שיטה היא האפשרות הטובה ביותר לבחור.
קיימות גם שתי וריאציות של שיטת 'הסר()':
- ה ' להסיר (מפתח) ' מוחק את הישות שיש לה את ' מַפְתֵחַ ' מתוך 'ConcurrentHashMap'.
- ה ' להסיר (מפתח, ערך) ' מוחק את הישות שציינה ' מַפְתֵחַ ' לאורך ' המקביל ' ערך ' מתוך 'ConcurrentHashMap'.
בקר בגוש הקוד שלהלן לקבלת הסבר טוב יותר:
יְבוּא java.util.concurrent.ConcurrentHashMap ;
מעמד שורש
{
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) //יצירת שיטת main()
{ // הצהרת ConcurrentHashMap
צוות ConcurrentHashMap = חָדָשׁ ConcurrentHashMap ( ) ;
קְבוּצָה. לָשִׂים ( 'ת'ור' , 2 ) ;
קְבוּצָה. לָשִׂים ( 'מוּזָר' , 4 ) ;
קְבוּצָה. לָשִׂים ( 'הוקי' , 6 ) ;
מערכת . הַחוּצָה . println ( 'ConcurrentHashMap: ' + קְבוּצָה ) ;
int ערך = קְבוּצָה. לְהַסִיר ( 'מוּזָר' ) ;
מערכת . הַחוּצָה . println ( 'הערך ' + ערך + ' הוסר' ) ;
מערכת . הַחוּצָה . println ( 'ConcurrentHashMap: ' + קְבוּצָה ) ;
בוליאני תוֹצָאָה = קְבוּצָה. לְהַסִיר ( 'הוקי' , 6 ) ;
מערכת . הַחוּצָה . println ( 'האם הערך {Hawkeye = 6} הוסר?' + תוֹצָאָה ) ;
מערכת . הַחוּצָה . println ( 'ConcurrentHashMap מעודכן: ' + קְבוּצָה ) ;
קְבוּצָה. ברור ( ) ;
מערכת . הַחוּצָה . println ( 'ConcurrentHashMap מעודכן: ' + קְבוּצָה ) ;
}
}
תיאור של בלוק הקוד לעיל:
- ראשית, 'ConcurrentHashMap' בשם ' קְבוּצָה ' נוצר, ואז מוכנסים בתוכו נתוני דמה באמצעות ' לָשִׂים ' שיטה.
- לאחר מכן, ה' לְהַסִיר() נעשה שימוש בשיטת ' והמפתח של ' מוּזָר ” מועבר אליו. שיטה זו מסירה את הישות מהמפה עם מפתח 'מוזר'.
- בנוסף, הצג את שאר הרכיבים של המפה באמצעות 'ConcurrentHashMap'.
- עכשיו, העבר את ' מַפְתֵחַ ' ומתאים ' ערך ' אל ה ' לְהַסִיר() ' שיטה למחיקת ישות מ-'ConcurrentHashMap' שיש לה מפתח וערך ספציפיים.
- לאחר מכן, הצג את 'ConcurrentHashMap' כדי לראות חזותית את ההבדל.
- בסופו של דבר, השתמש ב' ברור() ' שיטה למחיקת כל הרכיבים השוכנים בתוך 'ConcurrentHashMap'. כמו כן, הצג את 'ConcurrentHashMap' במסוף בסוף.
לאחר סיום שלב ההידור:
תמונת המצב מציגה את האלמנטים שהוסרו מ-ConcurrentHashMap.
כיצד לגשת לרכיבי ConcurrentHashMap ב- Java?
המרכיבים של ' ConcurrentHashMap ניתן לגשת באמצעות מספר קבוצות של שיטות. הקבוצה הראשונה כוללת ' entrySet() ', ' סט מפתחות() ' ו' ערכים() ' שיטות. הם משמשים כדי לאחזר את כל האלמנטים בבת אחת. על ידי שימוש בשיטות לעיל, המתכנת יכול לבחור לאחזר את כל ' מפתחות ', ' ערכים ' או שניהם ' ערך מפתח ' מיפוי של המפה.
בקר בקוד שלהלן כדי להבין את היישום המעשי של השיטות לעיל:
יְבוּא java.util.concurrent.ConcurrentHashMap ;מעמד רָאשִׁי {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) //יצירת שיטת main()
{ // הצהרת ConcurrentHashMap
צוות ConcurrentHashMap = חָדָשׁ ConcurrentHashMap ( ) ;
קְבוּצָה. לָשִׂים ( 'ת'ור' , 2 ) ;
קְבוּצָה. לָשִׂים ( 'מוּזָר' , 4 ) ;
קְבוּצָה. לָשִׂים ( 'הוקי' , 6 ) ;
קְבוּצָה. לָשִׂים ( 'פנתר שחור' , 8 ) ;
מערכת . הַחוּצָה . println ( 'ConcurrentHashMap: ' + קְבוּצָה ) ;
מערכת . הַחוּצָה . println ( 'אחזר מפתח וערכים:' + קְבוּצָה. entrySet ( ) ) ;
מערכת . הַחוּצָה . println ( 'אחזר מפתחות:' + קְבוּצָה. סט מפתחות ( ) ) ;
מערכת . הַחוּצָה . println ( 'אחזר ערכים:' + קְבוּצָה. ערכים ( ) ) ;
}
}
תיאור של בלוק הקוד לעיל:
- ראשית, צור 'ConcurrentHashMap' בשם ' קְבוּצָה ' והכנס בו מספר אלמנטים באמצעות ' לָשִׂים() ' שיטה.
- לאחר מכן, הצג את 'ConcurrentHashMap' במסוף באמצעות ' out.println() ' שיטה.
- לאחר מכן, השתמש ב' entrySet() שיטה לאחזר את כל הנתונים הקיימים במפה.
- לאחר מכן, השתמש ב' סט מפתחות() שיטה לאחזר מפתחות מהמפה בלבד.
- בסופו של דבר, השתמש ב' ערכים() ' שיטה לאחזר רק ערכים המשויכים לכל מפתח. זה מחזיר רק ערכים ברצף.
לאחר ביצוע הקוד לעיל:
בתמונת המצב שלמעלה, הפלט של השיטות בהן נעשה שימוש לעיל מוצג בקונסולה. וגבולות בצבעים שונים מנוצלים כדי ליצור הפרדה חזותית בין הפלט של כל שיטה.
כעת, הקבוצה השנייה כוללת את ' לקבל() ' ו' getOrDefault() ' שיטות. שיטות אלה משמשות כדי לאחזר את ' מפתחות ' מ ה ' ConcurrentHashMap '. לדוגמה, בקר בגוש הקוד שלהלן:
יְבוּא java.util.concurrent.ConcurrentHashMap ;מעמד רָאשִׁי {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) //יצירת שיטת main()
{ // הצהרת ConcurrentHashMap
צוות ConcurrentHashMap = חָדָשׁ ConcurrentHashMap ( ) ;
קְבוּצָה. לָשִׂים ( 'ת'ור' , 2 ) ;
קְבוּצָה. לָשִׂים ( 'מוּזָר' , 4 ) ;
קְבוּצָה. לָשִׂים ( 'הוקי' , 6 ) ;
קְבוּצָה. לָשִׂים ( 'פנתר שחור' , 8 ) ;
מערכת . הַחוּצָה . println ( 'באמצעות getOrDefault(): ' + ערך2 ) ;
int ערך1 = קְבוּצָה. לקבל ( 'הוקי' ) ;
מערכת . הַחוּצָה . println ( 'מפתח שאוחזר עבור הערך שצוין הוא:' + ערך1 ) ;
int ערך2 = קְבוּצָה. getOrDefault ( 'רומנוף' , 10 ) ;
מערכת . הַחוּצָה . println ( 'ConcurrentHashMap: ' + קְבוּצָה ) ;
}
}
הסבר על הקוד לעיל:
- השתמש באותו ' ConcurrentHashMap ' אשר נוצר בבלוק הקוד לעיל.
- בנוסף, החל את ' לקבל() ” שיטה ומעבירים את הערך שהמפתח שלו עומד להיות משוחזר בתוך הסוגריים שלו.
- יתר על כן, שימוש ב' getOrDefault() שיטה שלוקחת שני פרמטרים/ערכים, הערך ומפתח ברירת המחדל. אם האובייקט שצוין נמצא בתוך המפה, המפתח המתאים יוחזר. ואם הערך שצוין לא נמצא אז מפתח ברירת המחדל משמש.
- לאחר מכן, אחסן את התוצאות של שתי השיטות במשתנים והצג אותן על המסוף למטרות הדמיה.
לאחר ביצוע בלוק הקוד לעיל:
תמונת המצב לעיל מציגה את המפתחות ביחס לערכים שאוחזרו והודפסו על המסוף.
סיכום
כדי להסיר/למחוק אלמנטים ספציפיים מה-' ConcurrentHashMap ' ה ' לְהַסִיר() ניתן להשתמש בשיטה. על ידי שימוש בו, המתכנת יכול למחוק רכיב שיש לו ' מַפְתֵחַ ' או מקביל ' ערך '. עם השימוש ב' ברור() שיטת ', כל רכיב השוכן על המפה נמחק בבת אחת. לגישה, ה' entrySet() ', ' סט מפתחות() ' ו' ערכים() נעשה שימוש בשיטות. הם יכולים לאחזר את כל ' מפתחות/ערכים ', ' מפתחות ', ו' ערכים ' מ ה ' ConcurrentHashMap ' בבת אחת. כדי לאחזר רק מפתחות ספציפיים, ' לקבל ' ו' getOrDefault נעשה שימוש בשיטות.