CodeGym /جاوا بلاگ /Random-SD /جاوا ۾ نقشو انٽرفيس

سطح

San Francisco

14 February 2023
43 views
0 comments

جاوا ۾ نقشو انٽرفيس

جاوا ميپ انٽرفيس ڇا آهي

جاوا ميپ انٽرفيس جاوا ڪليڪشن فريم ورڪ جو حصو آهي، پر اهو ڪليڪشن انٽرفيس جو ذيلي قسم ناهي. تنهن ڪري اهو هڪ مختلف طريقي سان عمل ڪري ٿو مقابلي ۾، چئو، فهرستون، يا ٻيون شيون گڏ ڪرڻ. نقشي جو هر عنصر<Key, Value> هڪ اهم-قدر جوڙو جي نمائندگي ڪري ٿو. ٻئي ڪيئي ۽ قدر ڪجھ شيون آھن. ھڪڙي خاص نقشي ۾ سڀ ڪنجيون منفرد آھن، جڏھن ته قدر نه آھن، تنھنڪري اھي نقل ڪري سگھجن ٿيون. توهان شايد جاوا ۾ نقشي جي باري ۾ سوچي سگهو ٿا جهڙوڪ هڪ قسم جي ڊڪشنري يا آن لائن دڪان جي فهرست، جتي توهان ڪنهن به شيء کي ڳولي سگهو ٿا ان جي منفرد انڊيڪس استعمال ڪندي. اهم نقشي ۾ قدر جو ھڪڙو منفرد سڃاڻپ ڪندڙ آھي. مثال طور نقشي ۾<String, Item> String آن لائن دڪان مان ڪجھ شيون جي سڃاڻپ آھي. دستاويزن جي مطابق نقشي ۾ ايندڙ سب انٽرفيس آهن:

پابنديون ؛

سمورو نقشو<K,V> ;

ConcurrentNavigable Map<K,V> ;

LogicalMessageContext ؛

پيغام جو حوالو ؛

Navigable Map<K,V> ;

SOAPMessageContext ؛

ترتيب ڏنل نقشو<K,V> .

۽ لاڳو ڪلاس:

خلاصو نقشو
صفتون
اختيار فراهم ڪندڙ
ڪنورنٽ هش ميپ
ConcurrentSkipListMap
EnumMap
HashMap
هيش ٽيبل
سڃاڻپ هش ميپ
LinkedHashMap
پرنٽر اسٽيٽ سببن
ملڪيتون
فراهم ڪندڙ
رينڊرنگ اشارو
سادي بائنڊنگس
TabularDataSupport
وڻن جو نقشو
UID defaults
WeakHashMap

Java AbstractMap ھڪڙو خلاصو طبقو آھي جيڪو نقشي جي گھڻن انٽرفيس کي لاڳو ڪري ٿو.
Java HashMap هڪ ڊيٽا جو ڍانچو آهي جيڪو هڪ هيش ٽيبل استعمال ڪندي ڪي-ويليو جوڑوں کي محفوظ ڪرڻ لاءِ.
Java TreeMap ھڪڙو ڊيٽا ڍانچو آھي جيڪو وڻ استعمال ڪرڻ لاءِ، يعني ترتيب ڏنل ڪيز سان ڏيکاريو.
WeakHashMap ڪمزور ڪنجين سان هيش ٽيبل کي استعمال ڪرڻ لاءِ، قدرن سان ڏيکاريو جيڪي ڪچري جي ڪليڪٽر طرفان ختم ڪري سگهجن ٿيون جيڪڏهن اهي وڌيڪ استعمال نه ڪيا وڃن.
LinkedHashMap ھڪڙو نقشو آھي جيڪو عناصر کي شامل ڪرڻ جي ترتيب سان، داخل ڪرڻ جي ترتيب ۾ ورجائي جي اجازت ڏئي ٿو.
EnumMap وڌائي ٿو AbstractMap ڪلاس enum ڪنجين سان استعمال لاءِ.

IdentityHashMap حوالن جي برابري جي چڪاس کي استعمال ڪري ٿو جڏهن دستاويزن جي مقابلي ۾، چيڪن سان ميپنگ جي مقابلي ۾ == آپريشن برابر () طريقي جي بدران استعمال ڪندي

هتي اسان نقشي جي انٽرفيس جي تمام مشهور عملن ۾ دلچسپي رکون ٿا: HashMap، TreeMap ۽ LinkedHashMap. رستي جي ذريعي، نقشي جي عناصر جي ترتيب تي خاص عملن تي منحصر آهي. چئو، TreeMap ۽ LinkedHashMap وٽ عنصرن جي اڳڪٿي ڪرڻ واري ترتيب آهي، جڏهن ته HashMap نه آهي.

نقشي جا طريقا

ڪنهن به نقشي جا مکيه عمل آهن داخل ڪرڻ، هٽائڻ، ۽ عناصر جي ڳولا.

Public Object put (Object key، Object value) نقشي ۾ هڪ عنصر داخل ڪري ٿو.
Public void putAll (نقشي جو نقشو) نقشي اندر مخصوص نقشو داخل ڪري ٿو.
عوامي آبجیکٹ کي هٽايو (آبجڪٽ ڪيئي) مخصوص ڪيل ڪي جي مطابق هڪ داخلا خارج ڪري ٿو.
عوامي آبجیکٹ حاصل (آبجڪٽ ڪيچ) مخصوص ڪيل ڪي جي قيمت واپس ڪري ٿو.
عوامي بولين تي مشتمل آهي ڪي (آبجڪٽ ڪي) هن نقشي مان مخصوص ڪيل ڳولهي ٿو
public Set keySet() هڪ Set ڏيک ڏي ٿو جنهن ۾ سڀ ڪنجيون شامل آهن
public Set entrySet() هڪ سيٽ ڏيک ڏي ٿو سڀني ڪنجين ۽ قدرن سان.

HashMap ڇا آهي

HashMap ڇا آهي؟ اهو نقشو<Key,Value>انٽرفيس جو تمام گهڻو مشهور عمل آهي. هن ڊيٽا جي جوڙجڪ hashing اصول تي ٻڌل آهي.

HashMap ڪم جو بنيادي اصول: hashing

سمجھڻ لاءِ ته هيش ميپ ڇا آهي ۽ اهو ڪيئن ڪم ڪري ٿو، اچو ته پهرين هاشنگ ۽ هيش جي ڪمن بابت ڳالهايون. هيش فنڪشن صرف رياضياتي معنى ۾ هڪ فنڪشن آهي. تنهن ڪري اتي ڪجهه ان پٽ قيمت آهي (هڪ اعتراض، ڊيٽا جو هڪ ٽڪرو) ۽ فنڪشن ان کي تبديل ڪري ٿو هڪ مناسب قاعدي کي استعمال ڪندي آئوٽ جي قيمت ۾ - هڪ هيش. گهڻو ڪري هيش هڪ مناسب ڊيگهه جو هيڪساڊيڪل نمبر آهي. تبديل ٿيندڙ عمل جا ضابطا مختلف ٿي سگهن ٿا، پر اهي هيٺين اصولن جي تابع آهن:

هڪ خاص ان پٽ (آبجڪٽ) وٽ هڪ خاص هيش ڪوڊ هوندو آهي.
جيڪڏهن ٻه شيون برابر آهن، انهن جا هيش ڪوڊ پڻ برابر آهن. ريورس سچ نه آهي.
جيڪڏهن هيش ڪوڊ مختلف آهن، شيون ضرور برابر نه آهن.
ڪڏهن ڪڏهن مختلف شيون ساڳيا هيش ڪوڊ ڪري سگھن ٿيون. اهو هڪ تمام غير ممڪن واقعو آهي، جنهن جو نالو ”ٽڪر“ رکيو ويو آهي ۽ سٺي معيار جي هيش فنڪشن کي ٽڪراءَ جي امڪان کي گهٽ ڪرڻ گهرجي.

جاوا ۾، هر شئي وٽ هيش ڪوڊ آهي. اهو آبجیکٹ ڪلاس جي hashCode طريقي سان حساب ڪيو ويو آهي، سڀني جاوا آبجیکٹ جي والدين طبقي. عام طور تي، ڊولپرز هن طريقي کي پنهنجي طبقن لاءِ اوور رائڊ ڪن ٿا ۽ ان سان لاڳاپيل طريقن جي برابر آهي .

HashMap: اهو ڪيئن ڪم ڪري ٿو

تنهن ڪري ڪلاس HashMap<K,V> جيئن هر نقشي تي عمل درآمد ڪنجين ۽ قدرن تي مشتمل آهي. هي هيشنگ اصول استعمال ڪندي ڪنجيون محفوظ ڪري ٿو. اندر HashMap Key-value جوڙو "buckets" ۾ ذخيرو ٿيل آهن، اهي بالٽ گڏجي هڪ "ٽيبل" ٺاهيندا آهن، ڳنڍيل فهرستن جي هڪ اندروني صف ۽ ان جي شروعاتي سائيز 16 آهي . جاوا ۾ HashMap ڪيئي جو هيش ڪوڊ استعمال ڪري ٿو بڪيٽ جو تعين ڪرڻ لاءِ جتي ڪي/قدر جوڙو نقشو ڪرڻ گهرجي: HashMap جي مشڪل خصوصيت اها آهي ته ٽيبل جي هر سيل (بالٽ) کي نه رڳو هڪ جوڙو پر ڪيترائي رکي ٿو. اهي هڪ واضح اعتراض جي طور تي محفوظ نه آهن (جهڙوڪ LinkedList)، پر هڪ ضمني زنجير جي طور تي. زنجير انهي حقيقت جي ڪري پيدا ڪئي وئي آهي ته هر جوڙو ايندڙ جوڙي جي لنڪ کي محفوظ ڪري ٿو. اهو آهي، سڀ HashMap جوڙو 16 زنجيرن ۾ پکڙيل آهن. جڏهن توهان ٽيبل ۾ هڪ نئون جوڙو وجھو ٿا، ڪنجي جو هيش سمجهيو ويندو آهي. هي هيش هڪ هيش ڪوڊ فنڪشن نه آهي جيڪو اهم اعتراض ۾ ٺهيل آهي. اهو 0-15 جي حد ۾ سمجهيو ويندو آهي. جوڙو بالٽ ۾ ذخيرو ٿيل جوڑوں جي زنجير ۾ شامل ڪيو ويو آهي هيش انڊيڪس سان. اهو طريقو اسان کي ڳولا جي رفتار ڏئي ٿو. چاٻي ذريعي هڪ جوڙي جي ڳولا دوران، پوري ٽيبل ذريعي وڃڻ جي ڪا ضرورت ناهي. چاٻي جو هيش سمجهيو ويندو آهي ۽ صرف زنجير جيڪو سيل ۾ ذخيرو ٿيل آهي هيش انڊيڪس سان چيڪ ڪيو ويندو آهي. جيڪڏهن HashMap ۾ تمام گهڻا جوڙا آهن، زنجير تمام ڊگهو ٿي ويندا آهن. پوءِ صف جي سائيز وڌائي ٿي، سڀني ذخيرو ڪيل شين جي هيش ٻيهر ڳڻپيو وڃي ٿي، ۽ اهي نئين زنجيرن سان پکڙيل آهن.

HashMap اعلان

جيڪڏهن توهان ڪلاس ڏانهن وڃو HashMap ڪوڊ توهان کي ايندڙ اعلان ملندو:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

جتي K هن نقشي پاران برقرار رکيل چاٻين جو قسم آهي ۽ V - نقشي ڪيل قدرن جو قسم. هي توهان جي ڪوڊ ۾ Integer Key ۽ String Value سان HashMap جي اعلان جو هڪ مثال آهي:

HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

HashMap طريقا

هتي HashMap طريقن جي فهرست آهي.

اعتراض حاصل ڪريو (آبجڪٽ ڪيچ) بيان ڪيل ڪي جي قيمت ڏي ٿو.
Object put(Key k, Value v) نقشي ۾ ڪيئي ويل ميپنگ داخل ڪري ٿو.
اعتراض کي هٽايو (آبجڪٽ ڪي) هن نقشي مان مخصوص ڪيل ڪي جي نقشي کي هٽائي ٿو جيڪڏهن موجود هجي؛
void clear() HashMap مان تمام اهم-قدر جوڙو هٽائي ٿو؛
آبجیکٹ کلون () چاٻين ۽ قدرن کي ڪلون ڪرڻ کان سواءِ هن HashMap مثال جي هڪ ٿلهي ڪاپي موٽائي ٿو؛
boolean containsKey(Object key) صحيح موٽائي ٿو جيڪڏهن مخصوص ڪيئي نقشي ۾ ملي ٿي، غلط آهي جيڪڏهن نه؛
boolean containsValue(Object Value) صحيح موٽائي ٿو جيڪڏهن مخصوص ڪيچي نقشي ۾ ملي ٿي، غلط آهي جيڪڏهن نه؛
boolean isEmpty() واپسي صحيح آھي جيڪڏھن نقشو خالي آھي، غلط آھي جيڪڏھن ناھي؛
سيٽ keySet() نقشي مان حاصل ڪيل چابين جو سيٽ واپس ڏئي ٿو.
int size() ڪيئي-ويل ميپنگ جي مقدار کي موٽائي ٿو؛
مجموعي قدر() نقشي جي قدرن جو مجموعو واپس ڏئي ٿو.
اعتراض کي هٽايو (آبجڪٽ ڪي) مخصوص ڪيل ڪي لاءِ ڪي-ويل جوڙو هٽائي ٿو؛
void putAll(Map m) نقشي جي سڀني عنصرن کي ٻئي نقشي تي نقل ڪري ٿو.

Java HashMap مثال

اچو ته Java HashMap مثال سان هڪ پروگرام ٺاهيون ته اهو ڏيکاريو ته اهو ڪيئن ڪم ڪري ٿو:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;

public class HashMap {

   public static void main(String[] args) {

       {

           // HashMap declaration
           HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

           //Adding elements into HashMap
           myHashMap.put(7, "Johnny");
           myHashMap.put(8, "Ivy");
           myHashMap.put(1, "Rick");
           myHashMap.put(4, "Stan");
           myHashMap.put(3, "Kyle");

           //print out the map content using Iterator
           Set set = myHashMap.entrySet();
           Iterator iterator = set.iterator();
           while (iterator.hasNext()) {
               Map.Entry mapEntry = (Map.Entry) iterator.next();
               System.out.print("key: " + mapEntry.getKey() + " value: ");
               System.out.println(mapEntry.getValue());
           }
           System.out.println("get an element from myHashMap via key and print the value out:");
           System.out.println(myHashMap.get(8));
           //print out hashMap on standard way:
           System.out.println(myHashMap);

           // Get values based on key
           String var = myHashMap.get(2);
           //here we'll get null, we don't have such a key
           System.out.println("Value with key 2: " + var);
           var = myHashMap.get(7);
           System.out.println("Value with key 7: " + var);

           // Remove values based on key
           myHashMap.remove(4);
           System.out.println("myHashMap after removing element:");
           System.out.println(myHashMap);
           myHashMap.clear();
           System.out.println("myHashMap after total clearing:");
           System.out.println(myHashMap);
       }

   }
}

پروگرام هلائڻ جو نتيجو:


key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}

وڻن جو نقشو

جاوا ۾ TreeMap پڻ نقشو<Key,Value> انٽرفيس لاڳو ڪري ٿو، پر اھو ڳاڙھو-ڪارو وڻ ڊيٽا جي جوڙجڪ تي ٻڌل آھي. هڪ وڻ "نوڊس" ۽ لائينن تي مشتمل هوندو آهي جيڪي نوڊس - شاخن کي ڳنڍيندا آهن. "روٽ" نوڊ وڻ جي چوٽي تي هوندو آهي. جڙ مان، شاخون ۽ نوڊس ٿي سگهن ٿيون. اهو هڪ ترتيب وار ساخت آهي، توهان سوچيو. اهي نوڊس روٽ جا ”ٻار“ آهن. چائلڊ نوڊس جا پنهنجا ٻار ٿي سگهن ٿا - هيٺيون نوڊس. ٻارن کان سواءِ نوڊس کي ”اينڊ-نوڊس“ يا ”پتي“ چئبو آهي. بائنري وڻ هڪ وڻ آهي، جتي هر نوڊ ۾ صفر، هڪ هوندو آهي. ، يا ٻه ٻار. بائنري ڳولا جو وڻ هڪ ڍانچي آهي، جتي هر اندروني نوڊ هڪ ڪنجي کي محفوظ ڪري ٿو، ۽ ڪڏهن ڪڏهن هڪ لاڳاپيل قدر، ۽ ٻه نمايان ذيلي وڻ ("کاٻي" ۽ "ساڄي") آهن. هڪ خود توازن بائنري ڳولا. وڻ هڪ نوڊ تي ٻڌل بائنري ڳولا وارو وڻ آهي جيڪو خود بخود پنهنجي اوچائي رکي ٿو (جڙ کان هيٺ جي سطح جو وڌ ۾ وڌ تعداد) پاڻمرادو شيون داخل ڪرڻ ۽ حذف ڪرڻ جي مقابلي ۾. هڪ ڳاڙهو-ڪارو وڻ هڪ متوازن بائنري وڻ آهي خاصيتن سان:

هر نوڊ يا ته ڳاڙهو يا ڪارو آهي
جڙ هميشه ڪارو آهي
هر پني هڪ NIL (خالي، null جو قسم) نوڊ آهي ۽ اهو ڪارو آهي
جيڪڏهن هڪ ڳڙو ڳاڙهو آهي، ان جا ٻار ضرور ڪارا آهن.
هر سادو رستو هڪ نوڊ کان هڪ نسلي پتي تائين هڪ ئي تعداد ۾ ڪاري نوڊس تي مشتمل آهي.

هڪ TreeMap خاصيتون

هڪ TreeMap استعمال ڪري ٿو وڻ جي ڊيٽا جي جوڙجڪ ڪنجين کي نوڊس طور ذخيرو ڪرڻ لاءِ ۽ ترتيب ڏئي ٿو ڪن کي ريڊ-بليڪ ٽري الگورٿم استعمال ڪندي. تنهن ڪري، TreeMap ان جي داخلائن کي ترتيب ڏئي ٿو ان جي ڪنجي جي قدرتي ترتيب جي مطابق. انگن لاءِ قدرتي چڙهندڙ ترتيب آهي، تارن لاءِ - الفابيٽيڪل آرڊر. جيڪڏهن توهان کي ترتيب ڏيڻ جي منطق کي تبديل ڪرڻ جي ضرورت آهي ته توهان هڪ موازنہ استعمال ڪري سگهو ٿا. قدرتي طريقي سان شين کي ترتيب ڏيڻ TreeMap جو هڪ وڏو فائدو آهي، انهي سان گڏ مختلف فلٽر ۽ حالتون استعمال ڪندي ڪجهه شيون ڳولڻ.

TreeMap طريقا

Object get(Object key) ملندڙ چاٻي جي قيمت ڏي ٿو.
Object put (Object key، Object value) نقشي ۾ نقشي کي داخل ڪري ٿو؛
آبجیکٹ کي هٽائي ڇڏيو (آبجڪٽ ڪي) هن ڪيچي جي ميپنگ کي هٽائي ٿو جيڪڏهن TreeMap ان تي مشتمل آهي؛
boolean containsKey(Object key) صحيح موٽائي ٿو جيڪڏھن ھن نقشي ۾ مخصوص ڪيل ڪي جي نقشي تي مشتمل آھي؛
boolean containsValue(Object value) صحيح موٽائي ٿو جيڪڏھن TreeMap نقشي ۾ ھڪڙي يا وڌيڪ ڪنجي کي مخصوص قدر ڏانھن ڇڪي ٿو.
Object firstKey() هن وقت ترتيب ڏنل نقشي ۾ پهرين ڪنجي موٽائي ٿو.
Object lastKey() هن وقت ترتيب ڏنل نقشي ۾ آخري ڪنجي موٽائي ٿو.
void putAll (نقشي جو نقشو) سڀني نقشن کي نقل ڪري ٿو مخصوص نقشي کان نقشي تي؛
سيٽ entrySet() ميپنگ جو هڪ سيٽ ڏيک ڏي ٿو
int size() ڪيئي-ويل ميپنگ جي مقدار کي واپس ڪري ٿو
ڪليڪشن ويلز() قدرن جو مجموعو ڏيک ڏئي ٿو
آبجیکٹ کلون () TreeMap جي هڪ ٿلهي ڪاپي موٽائي ٿو
void clear() TreeMap مان سڀ نقشا هٽائي ٿو
SortedMap headMap(Object key_value) نقشي جي حصي جو ڏيک ڏئي ٿو پيراميٽر key_value کان گھٽ
سيٽ keySet() ٽري ميپ ۾ موجود ڪنجين جو هڪ سيٽ ڏيک ڏي ٿو
SortedMap subMap(K fromKey، K toKey) هن نقشي جي حصي جو ڏيک ڏئي ٿو جنهن جي ڪنجين جي حد ڪني کان وٺي، شامل، ٽوڪي تائين، خاص
آبجیکٹ firstKey() TreeMap مان پھريون ڪنجي موٽائي ٿو.

TreeMap مثال

import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;

public class TreeMapExample {

   public static void main(String args[]) {

       //TreeMap declaration
       TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();

       //put elements to TreeMap
       myTreeMap.put(1, "Stuart");
       myTreeMap.put(23, "Michael");
       myTreeMap.put(7, "Johnny");
       myTreeMap.put(5, "Ivy");
       myTreeMap.put(2, "Alex");

       //Display and print out myTreeMap using Iterator
       Set set = myTreeMap.entrySet();
       Iterator iterator = set.iterator();
       while (iterator.hasNext()) {
           Map.Entry myEntry = (Map.Entry) iterator.next();
           System.out.print("key: " + myEntry.getKey() + " value: ");
           System.out.println(myEntry.getValue());
       }
       //TreeMap printed in classical way
       System.out.println(myTreeMap);
       //removing an element with the key =2
       myTreeMap.remove(2);
       //myTreeMap after removing:
       System.out.println(myTreeMap);
   }
}

پروگرام هلائڻ جو نتيجو:


key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}

LinkedHashMap

LinkedHashMap هڪ ڊيٽا جي جوڙجڪ آهي جيڪا ڳنڍيل فهرستن ۽ هيش نقشن کي گڏ ڪري ٿي. درحقيقت، LinkedHashMap HashMap ڪلاس کي وڌايو ۽ نقشي جي انٽرفيس کي لاڳو ڪري ٿو، پر ڳنڍيل فهرستن بابت ڇا آهي؟ LinkedHashMap جو اعلان:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

هي نئون ڳنڍيل هش ميپ HashMap کان ملڪيت حاصل ڪري ٿو (جهڙوڪ ٽيبل، لوڊ فيڪٽر، حد، سائيز، داخلا سيٽ)، پڻ ٻه خاص خاصيتون حاصل ڪري ٿو:

هيڊر هڪ ٻيڻو ڳنڍيل فهرست جو سر آهي. شروعات جي دوران، اهو پاڻ ڏانهن اشارو ڪري ٿو
AccessOrder ظاھر ڪري ٿو ته آئٽرٽر استعمال ڪندي عناصر تائين رسائي ڪيئن حاصل ڪجي. جيڪڏهن صحيح، آخري رسائي جي ترتيب ۾. جيڪڏهن غلط آهي، رسائي ان ترتيب ۾ هوندي جيڪا عناصر داخل ڪيا ويا هئا.

هي جڙيل لسٽ بيان ڪري ٿو تکرار جي ترتيب کي. عام طور تي، اهو نقشي ۾ چابيون داخل ڪرڻ جو حڪم آهي.

LinkedHashMap طريقا

Object get(Object key) اها قيمت واپس ڪري ٿي جنهن ۾ مخصوص ڪيل ڪي ميپ ٿيل آهي، يا null جيڪڏهن هن نقشي ۾ ڪيچي لاءِ ڪا ميپنگ نه آهي
void clear() نقشي مان سڀني نقشن کي هٽائي ٿو.
boolean containsKey (Object key) صحيح موٽائي ٿو جيڪڏهن مخصوص عنصر کي هڪ يا وڌيڪ ڪنز سان ميپ ڪيو وڃي
جيڪڏهن نقشو نقشي مان ان جي پراڻي داخل ٿيڻ کي هٽائي ٿو ته بولين ريمو ايلڊسٽ اينٽي(Map.Entry eldest) صحيح موٽائي ٿو
Set<Map.Entry<K,V>> entrySet() هن نقشي ۾ موجود نقشن جو هڪ سيٽ ڏيئو ڏي ٿو
void forEach(BiConsumer<? super K,? super V> action) هن نقشي ۾ هر انٽري لاءِ ڏنل ايڪشن کي انجام ڏئي ٿو جيستائين سڀني داخلائن تي عمل نه ڪيو وڃي يا عمل هڪ استثنا نه ڏئي.
آبجیکٹ getOrDefault(Object key، V defaultValue) اها قيمت موٽائي ٿو جنهن ۾ مخصوص ڪيل ڪي ميپ ٿيل آهي. جيڪڏهن نقشي ۾ مکيه واپسي defaultValue لاءِ ميپنگ شامل نه آهي.
Set<K> keySet() نقشي ۾ موجود ڪنجين جو سيٽ ڏيک ڏي ٿو
boolean removeEldestEntry(Map.Entry<K,V> eldest) صحيح موٽائي ٿي جيڪڏھن ھن نقشي کي پنھنجي پراڻي داخلا ختم ڪرڻ گھرجي
void replaceAll(BiFunction<? super K,? super V,? extensions V> function) هر انٽري ويليو کي ان انٽري تي ڏنل فنڪشن کي سڏڻ جي نتيجي ۾ تبديل ڪري ٿو جيستائين سڀني داخلائن تي عمل نه ڪيو وڃي يا فنڪشن استثنا ڏئي.
Collection<v>values() نقشي ۾ موجود قدرن جو مجموعو ڏيک ڏئي ٿو

LinkedHashMap مثال

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
   public class HashLinkedListExample {
       public static void main(String args[]) {
           // LinkedHashMap Declaration
           LinkedHashMap<Integer, String> myLinkedHashMap =
                   new LinkedHashMap<Integer, String>();

           //Adding elements into LinkedHashMap
           myLinkedHashMap.put(7, "Johnny");
           myLinkedHashMap.put(12, "Rick");
           myLinkedHashMap.put(1, "Kyle");
           myLinkedHashMap.put(5, "Percy");
           myLinkedHashMap.put(85, "Sebastian");

           // Generate a Set of entries
           Set set = myLinkedHashMap.entrySet();

           // Display and print out the nodes  of LinkedHashMap
           Iterator iterator = set.iterator();
           while(iterator.hasNext()) {
               Map.Entry me = (Map.Entry)iterator.next();
               System.out.print("key: "+ me.getKey() +
                       " value: "+me.getValue()+"\n");
           }
           //print out HashLinkedMap on standard way:
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(21, "Ivy");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.remove(12);
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(12, "Ronny");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(1, "Stan");
           System.out.println(myLinkedHashMap);
       }
   }

ھتي اسان ھڪڙو نئون LinkedHashMap ٺاھيو آھي، پنج عناصر شامل ڪري، پوءِ ان کي پرنٽ آئوٽ ڪري آئٽرٽر استعمال ڪندي ۽ ڪلاسيڪل انداز ۾. جئين توهان ڏسي سگهو ٿا، LinkedHashMap اندراج جي حڪم کي برقرار رکي ٿو. ان کان پوء اسان پنهنجي نقشي مان هڪ عنصر کي حذف ڪريون ٿا، پوء نئون شامل ڪريو ۽ بعد ۾ - هڪ وڌيڪ عنصر چاٻي سان، جيڪو اڳ ۾ ئي نقشي تي آهي. اهو پراڻي قدر کي تبديل ڪري ٿو جيڪو هن ڪيچي ڏانهن نقشو ڪيو ويو آهي. هلندڙ پروگرام جو نتيجو:


key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

HashMap، TreeMap، LinkedHashMap مقابلو

HashMap، TreeMap، ۽ LinkedHashMap نقشي جي انٽرفيس جا عمل آھن. HashMap ۽ LinkedHashMap ڊيٽا ڍانچي آهن جيڪي هيش ڪنجيون آهن. TreeMap ڳولا واري وڻ کي ترتيب ڏيڻ لاءِ پنهنجي ڪنجين جي قدرتي ترتيب کي استعمال ڪري ٿو. آرڊر:

HashMap ڪنهن به ترتيب کي برقرار نٿو رکي.
TreeMap داخلائن کي ترتيب ڏئي ٿو چاٻين جي وڌندي ترتيب ۾.
LinkedHashMap داخل ڪرڻ جي حڪم کي برقرار رکي ٿو.

خالي ڪنجيون:

HashMap ۽ LinkedHashMap اجازت ڏئي ٿو ھڪڙي نال چاٻي رکڻ جي.
LinkedHashMap null keys جي اجازت نه ٿو ڏئي ته ڪيز استعمال ڪرڻ جي صورت ۾ قدرتي ترتيب ڏيڻ يا Comparator null leys تي مقابلي جي حمايت نٿو ڪري.

اچو ته هڪ جاوا نقشي جو مثال ڏيون جنهن ۾ هن مضمون ۾ نظرثاني ٿيل سڀئي ٽي عمل شامل آهن:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

هتي هن پروگرام کي هلائڻ جو نتيجو آهي:


HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

جيئن ته اسان ڏسي سگهون ٿا، HashMap ۾ عناصر جو حڪم واضح ناهي، TreeMap ۾ اهو ڪنجي تي منحصر آهي، LinkedHashMap ۾ اهو داخل ڪرڻ جي حڪم بابت آهي. جيڪڏهن اسان null key کي linkedHashMap ۾ وجهڻ جي ڪوشش ڪنداسين ته اسان کي NullPointerException حاصل ٿيندو، پر LinkedHashMap1 ۾، جتي ڪيز اسٽرنگ آهن، اسان اهو ڪري سگهون ٿا. هيش نقشو بهترين عام مقصد جي نقشي تي عمل درآمد آهي. اهو وڌ ۾ وڌ ڳولا جي رفتار، تيز اسٽوريج، ۽ ٻيهر حاصل ڪرڻ جي عملن کي مهيا ڪري ٿو، پر توهان کي ان جي افراتفري جي ترتيب بابت ياد رکڻ گهرجي. هڪ ڳنڍيل هيش نقشو HashMap فائدن کي ورثي ۾ ڏئي ٿو ۽ ڪنجي لاءِ آرڊر حاصل ڪري ٿو. بهرحال، ان ۾ ڳنڍيل لسٽ شامل آهي، جيڪا ياداشت جي لحاظ کان نسبتا قيمتي آهي. اهو ڳولڻ ۾ HashMap کان وڌيڪ سست آهي ۽ ڳنڍيل لسٽ برقرار رکڻ جي ڪري شامل ڪرڻ/هٽائڻ لاءِ ٿورو سست آهي. هڪ وڻ جو نقشو ذخيرو ڪنجيون ترتيب ڏنل ترتيب ڏنل ترتيب سان. بهرحال، اهو پيش ڪري ٿو بدترين عام ڪارڪردگي HashMap ۽ LinkedHashMap کان. جيڪو توهان سکيو ان کي مضبوط ڪرڻ لاءِ، اسان توهان کي اسان جي جاوا ڪورس مان هڪ وڊيو سبق ڏسڻ جي صلاح ڏيون ٿا

وڌيڪ پڙهڻ:
HashMap ۾ موجود ڪي جي قيمت کي ڪيئن تازه ڪاري ڪجي HashMap getOrDefault طريقو جاوا ۾ java.util.Map ۾ KeySet طريقو

تبصرا

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION