جاوا مجموعوں کی ترتیب ()

ڈیٹا سے نمٹنے والے ڈویلپرز کے طور پر ہمیں سب سے زیادہ عام کاموں میں سے ایک کی ضرورت ہے - اپنے ڈیٹا کو ترتیب دینے کے قابل ہونے سے، ہم اپنے الگورتھم کو زیادہ تیزی سے چلانے کے لیے بہتر بنا سکتے ہیں، اور اس ڈیٹا کو تلاش کر سکتے ہیں جس کی ضرورت اس وقت کے ایک حصے میں ہے۔ دوسری صورت میں لے جائے گا. آج کے سبق میں، ہم جاوا کلیکشن sort() کے بارے میں بات کریں گے۔ ایک فوری سوچنے والے تجربے کے طور پر: تصور کریں کہ آپ یونیورسٹی کے روسٹر کے ذریعے نام تلاش کر رہے ہیں۔ اس سکول میں ہزاروں کی تعداد میں طلباء ہو سکتے ہیں۔ اگر آپ کو جو روسٹر دیا گیا ہے وہ حروف تہجی کی ترتیب میں نہیں تھا، تو آپ کو ہر ایک صفحے کو پلٹ کر بہت غور سے دیکھنا ہوگا تاکہ یہ یقینی بنایا جا سکے کہ آپ نے کہیں بھی ایک نام نہیں چھوڑا، جب تک کہ آپ کو وہ نام نہ ملے جس کی آپ تلاش کر رہے ہیں۔ دوسری طرف، اگر روسٹر حروف تہجی کے مطابق تھا، تو نہ صرف آپ کو اپنی تلاش میں کم سختی کرنی ہوگی، بلکہ آپ آسانی سے اسی پہلے حرف کے ساتھ روسٹر کے حصے پر جاسکتے ہیں، اور بڑی چھلانگ لگا کر صفحات کے ارد گرد کودنا جاری رکھ سکتے ہیں۔ جب تک کہ آپ اس شخص پر نہ اتریں جس کی آپ تلاش کر رہے تھے۔ آپ جتنے زیادہ ڈیٹا کے ساتھ کام کر رہے ہیں، اتنا ہی اہم یہ ہے کہ آپ اسے زیادہ سے زیادہ مؤثر اور مؤثر طریقے سے استعمال کر رہے ہیں۔ اس آرٹیکل میں، ہم جاوا میں کسی بھی فہرست کے نفاذ کو کس طرح ترتیب دیں گے (بشمول ArrayList) Collections sort طریقہ استعمال کرتے ہوئے۔

جاوا کلیکشن ترتیب کے طریقہ کار کا استعمال کرتے ہوئے جاوا میں اری لسٹ کو کیسے ترتیب دیا جائے۔

آئیے جاوا Collections.sort طریقہ کے بارے میں بات کرتے ہیں۔ java.util پیکیج میں بہت سے مفید یوٹیلیٹیز اور پیکجز شامل ہیں جو اکثر ڈویلپرز بشمول ArrayList کے استعمال کرتے ہیں۔ فرض کریں کہ آپ کے پاس درج ذیل آسان پروگرام ہے:

import java.util.*;
import java.io.*;
class Main{
     public static void main(String[] args){
          List<String> colors = new ArrayList<String>();
          colors.add("Red    ");
          colors.add("Orange");
          colors.add("Green");
          colors.add("Blue");
    }
}

آپ رنگوں کی فہرست کو پرنٹ کرنے کے قابل ہونا چاہتے ہیں، لیکن حروف تہجی کی ترتیب میں۔ آپ یہ کیسے کر سکتے ہیں؟ java.util.Collections کا استعمال کرتے ہوئے، چھانٹنا اتنا ہی آسان ہے جتنا ون لائنر:

Collections.sort(colors);

ٹا-ڈا! آپ کے رنگوں کی فہرست اب جگہ جگہ ترتیب دی گئی ہے۔ اگر آپ فہرست کو پرنٹ کرنا چاہتے تھے، جیسے:

System.out.println(colors);

تب آپ کو درج ذیل آؤٹ پٹ ملے گا:

[Blue, Green, Orange, Red]

یہ کتنا آسان تھا؟! Collections.sort() کو صعودی ترتیب میں ترتیب دینے کے لیے انٹیجرز، فلوٹس، یا اس معاملے کے لیے کسی دوسرے سادہ ڈیٹا کی قسم کو استعمال کرنا اتنا ہی آسان ہوگا۔ لیکن اگر آپ نزولی ترتیب میں ترتیب دینا چاہتے ہیں تو کیا ہوگا؟ یقینی طور پر ایسے معاملات ہیں جہاں یہ معنی رکھتا ہے - تصور کریں کہ آپ کے پاس ایک مخصوص کلاس کے ٹیسٹ اسکورز کی فہرست ہے، اور آپ یہ جاننا چاہتے ہیں کہ سب سے زیادہ اسکور کرنے والے طلباء کون ہیں۔ فہرست کو نزولی ترتیب میں ترتیب دینا زیادہ معنی خیز ہوگا (سب سے زیادہ اسکور پہلے)، تاکہ آپ جو جواب تلاش کر رہے ہیں وہ سب سے اوپر ہوں۔ شکر ہے، Collections.sort() کو اختیاری 2 پیرامیٹر کے ساتھ اوور رائٹ کر دیا گیا ہے، جو آپ کو صرف یہ کرنے کی اجازت دیتا ہے:

sort(List l, Comparator c)

لیکن ایک موازنہ کیا ہے؟ ٹھیک ہے، ایک موازنہ کرنے والا صرف ایک فنکشن ہے جو دو ان پٹ کا موازنہ کرتا ہے اور ایک نمبر لوٹاتا ہے جس کی نمائندگی کرتا ہے کہ کون سا ان پٹ پہلے آتا ہے۔ اگر آپ قدیم ڈیٹا کی اقسام کی ایک ArrayList کو ترتیب دے رہے ہیں، تو Java Collection پہلے سے ہی آپ کو ایک reverseOrder() comparator فراہم کرتا ہے۔ اسے اس طرح کہا جا سکتا ہے:

Collections.sort(colors, Collections.reverseOrder());

اب، رنگوں کو جگہ جگہ الٹا ترتیب دیا گیا ہے تاکہ اگر آپ اسے پرنٹ کریں تو آپ کو درج ذیل آؤٹ پٹ ملے گا۔

[Red, Orange, Green, Blue]

جاوا میں غیر قدیم ڈیٹا کی اقسام کو ترتیب دینے کے لیے مجموعے کا استعمال کیسے کریں۔

اب تک، آپ نے دیکھا ہے کہ Collections.sort() طریقہ استعمال کرتے ہوئے جاوا میں تاروں یا ints کی ArrayLists کو ترتیب دینا اتنا ہی آسان ہے جتنا کوڈ کی ایک لائن۔ لیکن اکثر اوقات، آپ کی ArrayLists غیر قدیم ڈیٹا کی اقسام کو ذخیرہ کر رہی ہوں گی۔ جب آپ ڈیٹا کے ساتھ کام کر رہے ہیں جس میں زیادہ پیچیدہ صفات ہیں، تو آپ ان اشیاء کی نمائندگی کرنے کے لیے کلاسز لکھنا چاہیں گے اور ان کی صفات کا استعمال کرتے ہوئے ان کا ایک دوسرے سے موازنہ کیسے کیا جائے گا۔ اس کی ایک مثال کو تلاش کرنے کے لیے، آئیے رنگوں کی فہرست کو ترتیب دینے کی مثال پر نظرثانی کرتے ہیں، لیکن اس بار، Strings کو چھانٹنے کے بجائے، ہم رنگین اشیاء کو ترتیب دیں گے۔ ہماری بنیادی رنگین کلاس کچھ اس طرح نظر آسکتی ہے:

public class Color{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(String name, int red, int green, int blue){
   	this.name = name;
    	this.r = red;
   	this.g = green;
   	this.b = blue;
	}
}

ہمارے کلر کلاس کو Collections.sort() کے ساتھ ہم آہنگ بنانے کے لیے، تاکہ کلیکشنز کو سمجھ سکے کہ رنگین اشیاء کا موازنہ اور ترتیب کیسے دیا جائے، ہمیں دو چھوٹی تبدیلیاں کرنے کی ضرورت ہے:

1. رنگ کو موازنہ آبجیکٹ بنائیں (مقابلے کے قابل اطلاقات شامل کریں<Object>)
2. کلاس میں compareTo طریقہ کو اوور رائیڈ کریں (عوامی int compareTo(Object o) کو اوور رائیڈ کریں)

ان ترامیم کے ساتھ، ہماری کلاس اب اس طرح نظر آتی ہے:

public class Color implements Comparable<Object>{
	private int r;
	private int g;
	private int b;
	private String name;

	Color(int red int green, int blue, String name){
    	this.r = red;
   	this.g = green;
   	this.b = blue;
   	this.name = name;
	}

	@Override
	public int compareTo(Object o) {
    	Color c = (Color) o;
    	return this.name.compareTo(c.name);
	}
}

نوٹ کریں کہ Color's compareTo طریقہ صرف String کے compareTo طریقہ کو کہتے ہیں۔ ترتیب حروف تہجی کے مطابق کی جائے گی۔ اگر ہم سرخ قدر کے حساب سے صعودی ترتیب میں ترتیب دینا چاہتے ہیں، مثال کے طور پر، ہم ریٹرن اسٹیٹمنٹ کو return this.r - cr; (اگر ہم سبز قدر کے حساب سے نزولی ترتیب میں چھانٹنا چاہتے ہیں، تو یہ واپسی cg - this.g؛) ہوگی۔ اب اگر ہم فون کریں۔

Collections.sort(colors);

صرف Strings کے بجائے رنگوں کی ArrayList پر، یہ کام کرے گا کیونکہ مجموعے رنگین اشیاء کا موازنہ کرنے کا طریقہ سمجھتے ہیں۔ اگر آپ اپنے آبجیکٹ کو Comparable<Object> کو لاگو نہیں کرنا چاہتے ہیں، تو آپ متبادل طور پر اپنی کلاس کے لیے کمپیریٹر لکھ سکتے ہیں، اور اسے 2-پیرامیٹر Collections.sort() طریقہ میں منتقل کر سکتے ہیں۔ ایک موازنہ کرنے والا عوامی int compare (آبجیکٹ ون، آبجیکٹ ٹو) کو اوور رائیڈ کرتا ہے اور Collections.sort() طریقہ اسے چھانٹتے وقت اشیاء کا موازنہ کرنے کے لیے استعمال کرتا ہے۔ SortByName اور SortByRed موازنہ کرنے والوں کی ایک مثال ذیل میں لاگو کی گئی ہے۔

class SortByName implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.name.compareTo(b.name);
	}
}

class SortByRGB implements Comparator<Color>
{
	public int compare(Color a, Color b)
	{
    	return a.r - b.r;
	}
}

اس کے ساتھ، اب آپ کال کر سکتے ہیں۔

Collections.sort(colors, new SortByName());

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

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

جیسا کہ آپ نے اندازہ لگایا ہوگا، (a، b) لیمبڈا فنکشنز کے پیرامیٹرز کی نمائندگی کرتا ہے (دو اشیاء جن کا موازنہ کیا جانا ہے)۔ -> اس بات کی نشاندہی کرتا ہے کہ اس کے بعد لیمبڈا فنکشن کی تعریف ہے۔ یہ اس کے بارے میں ہے! اب آپ نے کلیکشن پیکج کا استعمال کرتے ہوئے جاوا میں ArrayLists کو ترتیب دینے کے سب سے مشہور طریقے دیکھے ہیں۔