جاوا میں ٹری میپ

اگر آپ اس مضمون کو پڑھ رہے ہیں، تو آپ غالباً نقشہ کے انٹرفیس سے واقف ہوں گے اور کہاں مناسب طریقے سے لاگو کیا جا سکتا ہے۔ اگر نہیں تو یہاں آجاؤ ۔ آج ہم جاوا ٹری میپ کے نفاذ کی خصوصیات کے بارے میں بات کریں گے، اور خاص طور پر، یہ HashMap سے کیسے مختلف ہے اور اسے صحیح طریقے سے کیسے استعمال کیا جائے۔

TreeMap، HashMap، اور LinkedHashMap کا موازنہ کرنا

نقشہ انٹرفیس کا سب سے زیادہ استعمال کیا جانے والا عمل HashMap ہے۔ یہ استعمال کرنا آسان ہے اور ڈیٹا تک فوری رسائی کی ضمانت دیتا ہے، اس لیے یہ زیادہ تر مسائل کو حل کرنے کے لیے بہترین امیدوار ہے۔ زیادہ تر، لیکن سب نہیں۔ کبھی کبھی آپ کو ڈیٹا کو منظم طریقے سے اسٹور کرنے اور اس کے ذریعے نیویگیٹ کرنے کے قابل ہونے کی ضرورت ہوتی ہے۔ اس صورت میں، نقشہ انٹرفیس (TreeMap) کا ایک اور نفاذ بچاؤ کے لیے آتا ہے۔ TreeMap NavigableMap انٹرفیس کو لاگو کرتا ہے، جو SortedMap کو وراثت میں ملتا ہے ، جو بدلے میں Map انٹرفیس کو وراثت میں ملتا ہے۔ NavigableMap اور SortedMap انٹرفیس کو لاگو کرنے سے ، TreeMap اضافی فعالیت حاصل کرتا ہے جو HashMap میں دستیاب نہیں ہے، لیکن یہ کارکردگی کے لحاظ سے قیمت ادا کرتا ہے۔ LinkedHashMap کلاس بھی ہے ، جو آپ کو ایک مخصوص ترتیب (جس ترتیب میں آپ اسے نقشے میں شامل کرتے ہیں) میں ڈیٹا ذخیرہ کرنے کی بھی اجازت دیتی ہے۔ ان تین طبقات کے درمیان فرق کو سمجھنے کے لیے اس جدول کو دیکھیں: جیسا کہ آپ دیکھ سکتے ہیں، ان کلاسوں میں بہت کچھ مشترک ہے، لیکن کئی فرق بھی ہیں۔ اگرچہ TreeMap کلاس سب سے زیادہ ورسٹائل ہے، یہ ہمیشہ null کو کلید کے طور پر ذخیرہ نہیں کر سکتا۔ اس کے علاوہ، TreeMap کے عناصر تک رسائی میں سب سے زیادہ وقت لگتا ہے۔ لہذا، اگر آپ کو ڈیٹا کو کسی ترتیب سے ذخیرہ کرنے کی ضرورت نہیں ہے، تو HashMap یا LinkedHashMap استعمال کرنا بہتر ہے ۔

سرخ سیاہ درخت

آپ نے شاید محسوس کیا ہے کہ، ہڈ کے نیچے، TreeMap ایک ڈیٹا ڈھانچہ استعمال کرتا ہے جسے سرخ سیاہ درخت کہتے ہیں۔ اس ڈھانچے میں ڈیٹا کو ذخیرہ کرنا بالکل وہی ہے جو ڈیٹا آرڈرنگ فراہم کرتا ہے۔ تو یہ کس قسم کا درخت ہے؟ آئیے اس کا پتہ لگائیں! تصور کریں کہ آپ کو Number-String جوڑوں کو ذخیرہ کرنے کی ضرورت ہے۔ نمبر 16، 20، 52، 55، 61، 65، 71، 76، 81، 85، 90، 93، اور 101 کلیدیں ہوں گی۔ اگر آپ ڈیٹا کو روایتی فہرست میں ذخیرہ کرتے ہیں اور آپ کو کلید 101 کے ساتھ عنصر کو تلاش کرنے کی ضرورت ہے، تو آپ کو اسے تلاش کرنے کے لیے تمام 13 عناصر سے گزرنا ہوگا۔ 13 عناصر کے لیے، یہ کوئی بڑی بات نہیں ہے، لیکن ایک ملین کے ساتھ کام کرتے وقت، ہمیں بڑی پریشانیوں کا سامنا کرنا پڑے گا۔ ان مسائل کو حل کرنے کے لیے، پروگرامرز قدرے پیچیدہ ڈیٹا ڈھانچے کا استعمال کرتے ہیں۔ یہ وہ جگہ ہے جہاں سرخ سیاہ درخت اسٹیج میں داخل ہوتا ہے! ایک عنصر کی تلاش درخت کی جڑ سے شروع ہوتی ہے، جو کہ ہمارے معاملے میں 61 ہے۔ پھر ہم نوڈ کی قدروں کا موازنہ اس قدر سے کرتے ہیں جس کی ہم تلاش کر رہے ہیں۔ اگر ہماری قدر کم ہے، تو ہم بائیں طرف چلے جاتے ہیں۔ اگر یہ زیادہ ہے، تو ہم دائیں طرف جاتے ہیں۔ یہ عمل اس وقت تک دہرایا جاتا ہے جب تک کہ ہمیں مطلوبہ قدر نہ مل جائے یا کسی ایسے عنصر کا سامنا نہ ہو جس کی قیمت صفر ہو (درخت کا ایک پتا)۔ سرخ اور سیاہ رنگوں کا استعمال درخت پر گشت اور توازن کو آسان بنانے کے لیے کیا جاتا ہے۔ سرخ سیاہ درخت بناتے وقت ایسے اصول ہیں جن کا ہمیشہ مشاہدہ کرنا ضروری ہے:

• جڑ کالا ہونا ضروری ہے۔
• درخت کے پتے سیاہ ہونے چاہئیں۔
• ایک سرخ نوڈ میں دو سیاہ چائلڈ نوڈس ہونے چاہئیں۔
• بلیک نوڈ میں کسی بھی رنگ کے چائلڈ نوڈس ہو سکتے ہیں۔
• نوڈ سے اس کے پتوں تک کے راستے میں بلیک نوڈس کی اتنی ہی تعداد ہونی چاہیے۔
• پتوں میں نئے نوڈس شامل کیے جاتے ہیں۔

اگر آپ رولز 3، 4 اور 5 پر ایک ساتھ غور کریں تو آپ سمجھ سکتے ہیں کہ کس طرح نوڈ کا رنگ ہمیں درخت کو زیادہ تیزی سے نیویگیٹ کرنے دیتا ہے: بلیک نوڈس سے گزرنے والا راستہ ہمیشہ سرخ نوڈس کے راستے ایک سے چھوٹا ہوتا ہے۔ اس کے مطابق، درخت کے کل سائز کا تعین سیاہ نوڈس کی تعداد سے کیا جاتا ہے، جسے "سیاہ اونچائی" کہا جاتا ہے. سرخ سیاہ درخت کے اعداد و شمار کا ڈھانچہ مختلف پروگرامنگ زبانوں میں لاگو ہوتا ہے۔ انٹرنیٹ پر جاوا کے بہت سارے نفاذ ہیں، لہذا ہم یہاں دیر نہیں کریں گے۔ اس کے بجائے، آئیے TreeMap کی فعالیت کو جاننا جاری رکھیں۔

وہ طریقے جو SortedMap اور NavigableMap انٹرفیس سے آتے ہیں۔

HashMap کی طرح، TreeMap میپ انٹرفیس کو لاگو کرتا ہے، جس کا مطلب ہے کہ TreeMap میں وہ تمام طریقے ہیں جو HashMap میں موجود ہیں۔ لیکن TreeMap SortedMap اور NavigableMap انٹرفیس کو بھی لاگو کرتا ہے ، اور اس طرح ان سے اضافی فعالیت حاصل کرتا ہے۔ SortedMap ایک انٹرفیس ہے جو Map کو بڑھاتا ہے اور ترتیب شدہ ڈیٹاسیٹ سے متعلقہ طریقے شامل کرتا ہے:

• firstKey() : نقشے میں پہلے عنصر کی کلید واپس کرتا ہے۔
• lastKey() : آخری عنصر کی کلید واپس کرتا ہے۔
• headMap(K end) : ایک نقشہ لوٹاتا ہے جس میں موجودہ نقشے کے تمام عناصر شامل ہیں، شروع سے لے کر کلیدی اختتام کے ساتھ عنصر تک
• tailMap(K start) : ایک نقشہ لوٹاتا ہے جس میں موجودہ نقشے کے تمام عناصر شامل ہیں، ابتدائی عنصر سے آخر تک
• subMap(K start, K ​​end) : ایک نقشہ لوٹاتا ہے جس میں موجودہ نقشے کے تمام عناصر شامل ہیں، ابتدائی عنصر سے کلیدی اختتام والے عنصر تک۔

NavigableMap ایک انٹرفیس ہے جو SortedMap کو بڑھاتا ہے اور نقشے کے عناصر کے درمیان نیویگیٹ کرنے کے طریقے شامل کرتا ہے:

• firstEntry() : پہلا کلیدی قدر جوڑا لوٹاتا ہے۔
• lastEntry() : آخری کلیدی قدر کا جوڑا لوٹاتا ہے۔
• pollFirstEntry() : پہلا جوڑا واپس کرتا ہے اور حذف کرتا ہے۔
• pollLastEntry() : آخری جوڑی واپس کرتا ہے اور حذف کرتا ہے۔
• ceilingKey(K obj) : سب سے چھوٹی کلید k لوٹاتا ہے جو کلیدی اعتراض سے بڑی یا اس کے برابر ہے۔ اگر ایسی کوئی کلید نہیں ہے تو، null لوٹاتا ہے۔
• floorKey(K obj) : سب سے بڑی کلید k لوٹاتا ہے جو کلیدی آبجیکٹ سے کم یا اس کے برابر ہے۔ اگر ایسی کوئی کلید نہیں ہے تو، null لوٹاتا ہے۔
• LowerKey(K obj) : سب سے بڑی کلید k لوٹاتا ہے جو کلیدی اعتراض سے کم ہے۔ اگر ایسی کوئی کلید نہیں ہے تو، null لوٹاتا ہے۔
• highKey(K obj) : سب سے چھوٹی کلید k لوٹاتا ہے جو کلیدی اعتراض سے بڑی ہے۔ اگر ایسی کوئی کلید نہیں ہے تو، null لوٹاتا ہے۔
• ceilingEntry(K obj) : ceilingKey(K obj) طریقہ کی طرح، صرف کلیدی قدر کا جوڑا واپس کرتا ہے (یا null)
• floorEntry(K obj) : floorKey(K obj) طریقہ کی طرح، صرف کلیدی قدر کا جوڑا واپس کرتا ہے (یا null)
• LowEntry(K obj) : LowerKey(K obj) طریقہ کی طرح، صرف کلیدی قدر کا جوڑا واپس کرتا ہے (یا null)
• highEntry(K obj) : HigherKey(K obj) طریقہ کی طرح، صرف کلیدی قدر والی جوڑی (یا null) لوٹاتا ہے
• descendingKeySet() : ایک NavigableSet لوٹاتا ہے جس میں تمام کلیدیں الٹی ترتیب میں ترتیب دی گئی ہیں
• descendingMap() : ایک NavigableMap لوٹاتا ہے جس میں تمام جوڑوں کو الٹ ترتیب میں ترتیب دیا گیا ہے۔
• navigableKeySet() : ایک NavigableSet آبجیکٹ لوٹاتا ہے جس میں وہ تمام کلیدیں شامل ہیں جس ترتیب میں وہ محفوظ ہیں۔
• headMap(K upperBound, boolean incl) : ایک نقشہ لوٹاتا ہے جس میں شروع سے اوپری باؤنڈ عنصر تک جوڑے ہوتے ہیں۔ incl پیرامیٹر اشارہ کرتا ہے کہ آیا واپس کیے گئے نقشے میں اوپری باؤنڈ عنصر کو شامل کرنا ہے۔
• tailMap(K LowerBound, boolean incl) : پچھلے طریقہ کی طرح فعالیت، لوئر باؤنڈ سے آخر تک صرف جوڑے لوٹاتا ہے
• subMap(K LowerBound, boolean lowIncl, K upperBound, boolean highIncl) : پچھلے طریقوں کی طرح، لوئر باؤنڈ سے اپر باؤنڈ تک جوڑے واپس کرتا ہے۔ دلائل lowIncl اور highIncl بتاتے ہیں کہ آیا نئے نقشے میں باؤنڈری عناصر کو شامل کرنا ہے۔

معمول کے کنسٹرکٹرز کے علاوہ، TreeMap میں ایک اور کنسٹرکٹر ہے جو موازنہ کرنے والے کی مثال قبول کرتا ہے۔ یہ موازنہ کرنے والا اس ترتیب کے لیے ذمہ دار ہے جس میں عناصر کو ذخیرہ کیا جاتا ہے۔

TreeMap کی مثالیں۔

اضافی طریقوں کی یہ کثرت غیر ضروری معلوم ہوسکتی ہے، لیکن وہ اس سے کہیں زیادہ کارآمد ثابت ہوں گے جتنا آپ کو پہلی نظر میں محسوس ہوگا۔ آئیے مل کر مندرجہ ذیل مثال کو دیکھیں۔ تصور کریں کہ ہم ایک بڑی کمپنی کے مارکیٹنگ ڈیپارٹمنٹ میں کام کرتے ہیں، اور ہمارے پاس ان لوگوں کا ڈیٹا بیس ہے جنہیں ہم اشتہارات دکھانا چاہتے ہیں۔ ذہن میں رکھنے کے لئے دو تفصیلات ہیں:

• ہمیں ہر شخص کے لیے نقوش کی تعداد پر نظر رکھنے کی ضرورت ہے۔
• نابالغوں کو اشتہارات دکھانے کا الگورتھم مختلف ہے۔

آئیے ایک پرسن کلاس بنائیں، جو ہر فرد کے بارے میں تمام متعلقہ معلومات کو محفوظ کرے گا:

public class Person {
   public String firstName;
   public String lastName;
   public int age;

   public Person(String firstName, String lastName, int age) {
       this.firstName = firstName;
       this.lastName = lastName;
       this.age = age;
   }
}

ہم مین کلاس میں منطق کو لاگو کرتے ہیں :

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Main {
   public static void main(String[] args) {
      TreeMap<Person, Integer> map = new TreeMap<>(Comparator.comparingInt(o -> o.age));
      map.put(new Person("John", "Smith", 17), 0);
      map.put(new Person("Ivan", "Petrenko", 65), 0);
      map.put(new Person("Pedro", "Escobar", 32), 0);
      map.put(new Person("Shirley", "Hatfield", 14), 0);
      map.put(new Person("Abby", "Parsons", 19), 0);

      Person firstAdultPerson = map.navigableKeySet().stream().filter(person -> person.age>18).findFirst().get();

       Map<Person, Integer> youngPeopleMap = map.headMap(firstAdultPerson, false);
       Map<Person, Integer> adultPeopleMap = map.tailMap(firstAdultPerson, true);
       showAdvertisementToYoung(youngPeopleMap);
       showAdvertisementToAdult(adultPeopleMap);
   }

   public static void showAdvertisementToYoung(Map map) {}
   public static void showAdvertisementToAdult(Map map) {}
}

مین کلاس میں، ایک TreeMap بنائیں، جس میں ہر کلید ایک مخصوص شخص کی نمائندگی کرتی ہے، اور ہر قدر اس مہینے کے اشتھاراتی نقوش کی تعداد ہے۔ ہم کنسٹرکٹر کو ایک کمپیریٹر پاس کرتے ہیں جو لوگوں کو عمر کے لحاظ سے ترتیب دیتا ہے۔ ہم نقشے کو صوابدیدی اقدار سے بھرتے ہیں۔ اب ہم اپنے چھوٹے ڈیٹا ریپوزٹری میں پہلے بالغ کا حوالہ حاصل کرنا چاہتے ہیں۔ ہم یہ Stream API کا استعمال کرتے ہوئے کرتے ہیں۔ پھر ہمیں دو الگ الگ نقشے ملتے ہیں، جنہیں ہم اشتہارات دکھانے والے طریقوں کو منتقل کرتے ہیں۔ بہت سے، بہت سے طریقے ہیں جن سے ہم اس کام کو پورا کر سکتے تھے۔ TreeMap کلاس کے طریقوں کا ہتھیار ہمیں ہر ضرورت کے لیے حسب ضرورت حل بنانے دیتا ہے۔ آپ کو ان سب کو یاد رکھنے کی ضرورت نہیں ہے، کیونکہ آپ ہمیشہ اپنے IDE سے دستاویزات یا تجاویز استعمال کر سکتے ہیں۔ جو کچھ آپ نے سیکھا ہے اس کو تقویت دینے کے لیے، ہم تجویز کرتے ہیں کہ آپ ہمارے جاوا کورس سے ایک ویڈیو سبق دیکھیں ابھی کے لیے بس اتنا ہی ہے! مجھے امید ہے کہ TreeMap کلاس اب آپ کے لیے واضح ہے، اور یہ کہ آپ کوڈنگ کے عملی کاموں کو حل کرنے میں اس کا صحیح طریقے سے اطلاق کریں گے۔