خلاصہ کافی بوجھل نکلا اس لیے میں نے اسے دو حصوں میں تقسیم کر دیا۔ دوسرا حصہ کنکرنسی اور ملٹی تھریڈنگ سے متعلق سوالات کے جوابات پر مشتمل ہے۔ پہلا حصہ باقی پر مشتمل ہے۔ لکھنا کافی مشکل تھا۔ مجھے اب بھی زیادہ سمجھ نہیں آئی، اس لیے ہمیشہ کی طرح تبصرے، ریمارکس، اضافے کا خیرمقدم ہے)
1. موازنہ انٹرفیس کا استعمال کیسے کریں؟
انٹرفیس Comparableصرف ایک طریقہ کا اعلان کرتا ہے compareTo(Object obj)، جو کلاس آبجیکٹ کی ترتیب کو نافذ کرنے کے لیے ڈیزائن کیا گیا ہے۔ آرڈر شدہ فہرستوں یا اشیاء کی صفوں کو چھانٹتے وقت استعمال کرنا آسان ہے۔ یہ طریقہ نامی آبجیکٹ کا موازنہ کرتا ہے۔
اعتراض اس طریقہ کے برعکس
equals، جو
صحیح یا
غلط لوٹتا ہے ،
compareToواپس آتا ہے:
0 اگر اقدار برابر ہیں؛
ایک منفی قدر اگر کالی پیرامیٹر سے کم ہے؛
اگر کالی پیرامیٹر سے زیادہ ہو تو مثبت۔
یہ بنیادی طور پر ترتیب دی گئی فہرستوں (
java.util.List) اور اشیاء کی صفوں کو ترتیب دینے کے لیے مفید ہے۔ اگر فہرست/سرنی میں ایسے عناصر شامل ہیں جو اس انٹرفیس کو نافذ کرتے ہیں، تو وہ خود بخود ترتیب دے سکتے ہیں
java.util.Collections.sort(List)/Arrays.sort(Object[])۔ قدرتی ترتیب کا تصور ایک انٹرفیس سے وابستہ ہے
Comparable، کیونکہ یہ کسی بھی طبقے کی مثالوں کے لیے قدرتی ترتیب قائم کرتا ہے جو اس انٹرفیس کو نافذ کرتا ہے۔ دوسرے لفظوں میں، حکم (x، y) شرط کی تکمیل سے مطابقت رکھتا ہے
x.compareTo(y) <= 0۔ نفاذ کے قواعد
Comparable، یا اس کے بجائے، اس کا طریقہ
compareTo(Object)درج ذیل ہے (x اور y اس کلاس کی مثالیں ہیں جو لاگو کرتی ہے
Comparable):
x.compareTo(y)اگر x بالترتیب y سے پہلے یا بعد میں ہونا چاہئے تو -1 یا 1 لوٹاتا ہے۔ اگر طریقہ 0 لوٹاتا ہے، تو آرڈرز (x، y) اور (y، x) برابر ہیں۔
اگر sign(a)ایک فنکشن ہے جو a کے لیے بالترتیب -1,0,1 لوٹاتا ہے، 0 سے کم، 0 کے برابر اور 0 سے بڑا، تو برابری کو مطمئن ہونا چاہیے sign(x.compareTo(y))==-sign(y.compareTo(x))۔ جو منطقی ہے: اگر x y سے پہلے آتا ہے، تو y کو x کے بعد اور اس کے برعکس آنا چاہیے۔
اگر x.compareTo(y) > 0اور y.compareTo(z) > 0، پھر x.compareTo(z) > 0- عدم مساوات کی منتقلی کا تعلق۔
اگر x.compareTo(y) == 0، پھر sign(x.compare(z)) == sign(y.compareTo(z))، کسی بھی z کے لیے۔
کال کو x.compareTo(null)مستثنیٰ ہونا چاہیے NullPointerException۔ یہ نفاذ کی منطق کے ساتھ ایک تضاد ہے equals(میں آپ کو یاد دلاتا ہوں، x.equals(null)یہ واپس آتا ہے false )۔
اگر y کی قسم کا x سے موازنہ نہیں کیا جا سکتا، تو کال کو x.compareTo(y)ایک استثنا دینا چاہیے ClassCastException۔
(x.compareTo(y) == 0) == x.equals(y)، یعنی کال کو x.compareTo(y)0 واپس کرنا ضروری ہے اگر اور صرف اس صورت میں جب x.equals(y)یہ سچ ہو ۔ یہ مستقل مزاجی کا اصول ہے اور اس پر غور کرنا بہت ضروری ہے۔
انٹرفیس
Comparatorدو طریقوں کا اعلان کرتا ہے
compare(Object obj1, Object obj2)اور
equals(Object obj). انٹرفیس کا استعمال کرتے وقت
Comparator، اشیاء کے جوڑے کا موازنہ کرنے کی منطق کلاس/آبجیکٹ کے اندر پوشیدہ نہیں ہوتی ہے، بلکہ اسے الگ کلاس میں لاگو کیا جاتا ہے۔ طریقہ
compare(x,y)بالکل کال جیسا ہی ہے
x.compareTo(y)۔ تمام اصولوں پر بالکل اسی طرح عمل کیا جانا چاہیے جس طرح
compareTo(Object)انٹرفیس کے طریقہ کار کو لاگو کرنے کے اصول ہیں
Comparable۔
Comparatorکہیں بھی استعمال کیا جا سکتا ہے جہاں چھانٹنے کی ضرورت ہے۔ اس صورت میں، سب سے پہلے، ضروری لچک ظاہر ہوتی ہے - کئی چھانٹی کے قوانین کو لاگو کرنے کی صلاحیت. اور دوسری بات یہ کہ جن اشیاء کو ترتیب دیا جا رہا ہے ان پر عمل درآمد نہیں ہو سکتا
Comparable۔ اگر وہ اس پر عمل درآمد کرتے ہیں تو
Comparatorاس کی ترجیح ہے۔ انٹرفیس
Comparatorایک طریقہ کی بھی وضاحت کرتا ہے
equals(Object)، متضاد طور پر جیسا کہ یہ لگتا ہے۔ یہ طریقہ انٹرفیس کی مثالوں کا خود موازنہ کرتا ہے
Comparatorاور صرف اس صورت میں
درست ہونا چاہئے جب موازنہ کی جانے والی اشیاء ایک ہی ترتیب فراہم کریں۔ تاہم، اصل نفاذ کو
Object.equals(Object)برقرار رکھنا ہمیشہ محفوظ ہے
Source:
public static <T> boolean addAll(Collection<? super T> c, T... elements) طریقہ
elementsمجموعہ میں صف کے عناصر کو شامل کرتا ہے
Collection<? super T> c۔ عناصر کو انفرادی طور پر یا ایک صف کے طور پر بیان کیا جا سکتا ہے۔ جب عناصر کو انفرادی طور پر متعین کیا جاتا ہے، تو یہ طریقہ تمام عناصر کو موجودہ مجموعہ میں آسانی سے شامل کرنے کی صلاحیت فراہم کرتا ہے:
Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) دونوں طریقے بائنری سرچ الگورتھم کا استعمال کرتے ہوئے پیرامیٹر میں پاس کردہ آبجیکٹ کے لیے پیرامیٹر میں پاس کردہ فہرست کو تلاش کرتے ہیں۔ اگر فہرست میں ایسا عنصر موجود ہے تو عنصر کا اشاریہ لوٹاتا ہے، بصورت دیگر فہرست کے پہلے عنصر کا اشاریہ اس سے بڑا ہے
key، اگر تمام عناصر اس سے کم ہیں
key، لوٹاتا ہے
list.size()۔ ان طریقوں کو استعمال کرنے سے پہلے، فہرستوں کو ترتیب دینا ضروری ہے۔ پہلی صورت میں، انہیں فہرست کے عناصر کی "قدرتی" ترتیب میں صعودی ترتیب میں ترتیب دیا جاتا ہے (جیسے استعمال کرتے وقت
Collections.sort(list))۔ دوسری صورت میں، فہرست کو صعودی ترتیب میں ترتیب دیا جانا چاہیے جو پاس شدہ کمپیریٹر کے ذریعہ فراہم کیا گیا ہے (وہی ترتیب جیسا کہ استعمال کرتے وقت
Collections.sort(list, c)[یہاں "کے ساتھ" بیان کردہ طریقہ کے پیرامیٹرز سے ایک موازنہ ہے])
public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)تمہید: generics میکانزم زبان میں کمپائل ٹائم ٹائپ چیکنگ فراہم کرتا ہے۔ عام طور پر یہ کافی ہے، لیکن بعض اوقات ایسا نہیں ہوتا ہے۔ مثال کے طور پر، ہم اپنے مجموعے کو لائبریری کوڈ میں منتقل کرتے ہیں، جو ہمارے لیے نامعلوم جگہ ہے، اور ہم واقعی چاہتے ہیں کہ اس "تیسرے فریق کی لائبریری" کا کوڈ ہمارے مجموعہ میں غلط قسم کا عنصر داخل نہ کرے۔ یہ ممکنہ مسئلہ نمبر 1 ہے۔ ممکنہ مسئلہ نمبر 2 درج ذیل ہے۔ ہم کہتے ہیں کہ ہمارا پروگرام ہمیں ایک پیغام دیتا ہے ClassCastExceptionجو ہمیں مطلع کرتا ہے کہ مجموعہ میں غلط قسم کا عنصر داخل کیا گیا تھا۔ بدقسمتی سے، یہ استثناء کسی بھی وقت غلط عنصر کے داخل ہونے کے بعد پھینکا جا سکتا ہے، اور عام طور پر ہمیں مسئلہ کے ماخذ کے بارے میں بہت کم یا کوئی معلومات فراہم نہیں کرتا ہے۔ طریقہ کار کا استعمال کرتے ہوئے
checkedCollectionہم اپنے آپ کو ایک اور دو مسائل سے بچا سکتے ہیں، کیونکہ یہ طریقہ ایک مجموعہ بناتا ہے جو رن ٹائم پر قابل تصدیق ہوتا ہے۔ اس طریقہ کو استعمال کرتے ہوئے مسئلہ نمبر دو کو حل کرنا: مثال کے طور پر، ہمارے پاس یہ ہے، اور یہ ختم ہو جاتا ہے
ClassCastException۔
Collection<String> c =newHashSet<String>();
مندرجہ بالا کوڈ کو عارضی طور پر اس سے تبدیل کیا جا سکتا ہے:
Collection<String> c =Collections.checkedCollection(newHashSet<String>(),String.class);
جب ہم دوبارہ پروگرام چلاتے ہیں، تو ہم کوڈ کی لائن کو لوکلائز کرتے ہیں جو ہمارے مجموعہ میں غلط قسم کا عنصر داخل کرتی ہے۔ میری رائے میں متعلقہ طریقے:
public static <E> List<E> checkedList(List<E> list,Class<E> type)public static <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType,Class<V> valueType)public static <E> Set<E> checkedSet(Set<E> s,Class<E> type)public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m,Class<K> keyType,Class<V> valueType)public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,Class<E> type)public static <T> void copy(List<? super T> dest,List<? extends T> src) طریقہ src عناصر کو dest پر کاپی کرتا ہے۔ کاپی شدہ عناصر کے اشاریہ جات ایک جیسے ہوں گے۔
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)public static <T> T min(Collection<? extends T> coll,Comparator<? super T> comp)public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp) طریقے مجموعہ میں کم از کم/زیادہ سے زیادہ عنصر کو "قدرتی ترتیب" (موازنہ انٹرفیس) یا پاس شدہ موازنہ کرنے والے کی ترتیب کے لحاظ سے واپس کرتے ہیں۔ اگر مجموعوں میں یکساں عناصر نہ ہوں تو
درستpublic static boolean disjoint(Collection<?> c1,Collection<?> c2) لوٹاتا ہے ۔ - بالترتیب ایک خالی فہرست، نقشہ اور سیٹ واپس کریں۔ - دیئے گئے عنصر کے ساتھ فہرست بھرتا ہے؛ - مجموعہ میں دیئے گئے عنصر کے واقعات کی تعداد لوٹاتا ہے۔
- n مخصوص عناصر کی فہرست لوٹاتا ہے ۔ - تمام مخصوص عناصر کو نئے عناصر سے بدل دیتا ہے۔ - فہرست کو "الٹتا ہے"؛ - عناصر کی ایک مخصوص تعداد کے ذریعہ فہرست کو چکرا کر تبدیل کرتا ہے۔ - فہرست عناصر کو شفل کرتا ہے۔ - ایک عنصر پر مشتمل ایک سیٹ، فہرست اور ڈسپلے نقشہ بنائیں؛ - فہرست کو قدرتی ترتیب میں ترتیب دینا اور اس کے مطابق استعمال کرنا؛ - مخصوص پوزیشنوں پر فہرست عناصر کو تبدیل کرتا ہے۔
ذرائع:<T> List <T> emptyList(), <K,V> Map <K,V> emptyMap(),<T> Set <T> emptySet()<T> void fill(List<? super T> list, T obj)int frequency(Collection<?> c, Object o)<T> List <T> nCopies(int n, T o)<T> boolean replaceAll(List<T> list, T oldVal, T newVal)void reverse(List<?> list)void rotate(List<?> list, int distance)void shuffle(List<?> list)<T> Set <T> singleton(T o), singletonList(T o), singletonMap(K key, V value)<T extends Comparable<? super T>> void sort(List<T> list),<T> void sort(List<T> list, Comparator<? super T> c)Comparatorvoid swap(List<?> list, int i, int j)
Arrays کلاس کے طریقوں کی مکمل فہرست
دستاویزات میں دیکھی جا سکتی ہے ۔ اس خلاصہ میں میں ان میں سے صرف چند کا حوالہ دوں گا۔ [دستاویزات سے ترجمہ شدہ طریقے، اور بدقسمتی سے میرا زیادہ تر ترجمہ ضائع ہو گیا۔ یہ شرم کی بات ہے، اور میں ایک ہی چیز پر وقت ضائع نہیں کرنا چاہتا، اس لیے میں جو کچھ میں نے گوگل کیا ہے اسے پیسٹ کروں گا]
public static <T> List<T> asList(T... a) ایک صف کی بنیاد پر ایک فہرست تیار کرتا ہے۔ صف کو فہرست کی اندرونی نمائندگی کے لیے استعمال کیا جاتا ہے۔ یہ فہرست اور اصل صف کے درمیان تعلق کو محفوظ رکھتا ہے: صف میں ہونے والی تبدیلیاں فہرست میں ظاہر ہوں گی:
String[] a ={"foo","bar","baz"};List<String> list =Arrays.asList(a);System.out.println(list);// [foo, bar, baz]
a[0]="aaa";System.out.println(list);// [aaa, bar, baz]
فہرست میں تبدیلیاں صف میں ظاہر ہوں گی:
String[] a ={"foo","bar","baz"};List<String> list =Arrays.asList(a);System.out.println(list);// [foo, bar, baz]
list.set(0,"bbb");System.out.println(Arrays.toString(a));// [bbb, bar, baz]
اگر صف میں اشیاء شامل ہیں، تو ظاہر ہے کہ صف اور فہرست دونوں ایک ہی مثالوں کا حوالہ دیں گے:
Object[] a ={newObject(),newObject(),newObject()};List<Object> list =Arrays.asList(a);System.out.println(a[0]== list.get(0));// true
int binarySearch(параметры)- قدیم اور آبجیکٹ کی اقسام کی صفوں میں قدر کے لیے بائنری تلاش کو منظم کرنے کا ایک اوور لوڈ شدہ طریقہ۔ پہلے میچ کی پوزیشن لوٹاتا ہے۔
void fill(параметры)- مختلف اقسام اور قدیم اقدار کے ساتھ صفوں کو بھرنے کا ایک اوور لوڈ شدہ طریقہ؛
void sort(پیرامیٹر) – Comparator انٹرفیس کا استعمال کرتے ہوئے اور اس کے بغیر کسی صف یا اس کے کچھ حصے کو چھانٹنے کا ایک اوور لوڈ شدہ طریقہ؛
static <T> T[] copyOf(T[] original, int newLength)- ایک مخصوص لمبائی کی ایک صف کو بھرتا ہے، عناصر کو ضائع کرتا ہے یا اگر ضروری ہو تو null سے بھرتا ہے۔
static <T> T[] copyOfRange(T[] original, int from, int to)- صف کے مخصوص علاقے کو ایک نئی صف میں کاپی کرتا ہے۔
<T> List<T> asList(T… a)- ایک ایسا طریقہ جو صف کے عناصر کو List<T> قسم کے کسی آبجیکٹ میں کاپی کرتا ہے۔
ذریعہ:
5. Collections.sort() کو کال کرتے وقت استعمال ہونے والی ترتیب کا کیا نام ہے؟
دستاویزات سے : عمل درآمد ٹم پیٹرز کی ازگر کی فہرست کی ترتیب (ٹم سورٹ) کی موافقت ہے۔ یہ نفاذ فہرست کو ایک صف میں پھینک دیتا ہے، صف کو ترتیب دیتا ہے، پھر فہرست کے ذریعے اعادہ کرتا ہے اور فہرست کے ہر عنصر کو متعلقہ صف کے عنصر سے دوبارہ لوڈ کرتا ہے۔ یہ n*n log(n) پیچیدگی سے بچتا ہے جو براہ راست
ویکی سے منسلک فہرست کو ترتیب دینے کی کوشش سے پیدا ہوتا ہے: ٹمسورٹ ایک ہائبرڈ چھانٹنے والا الگورتھم ہے جو اندراج کی ترتیب اور انضمام کی ترتیب کو یکجا کرتا ہے، جسے 2002 میں ٹم پیٹرز نے شائع کیا تھا۔ Timsort فی الحال Python، OpenJDK 7 میں معیاری ترتیب دینے والا الگورتھم ہے اور Android JDK 1.5 میں نافذ کیا گیا ہے۔ الگورتھم کا بنیادی خیال یہ ہے کہ حقیقی دنیا میں، ترتیب دینے والے ڈیٹا کی صفوں میں اکثر ترتیب شدہ ذیلی ریز ہوتی ہیں۔ اس طرح کے اعداد و شمار پر، Timsort بہت سے چھانٹنے والے الگورتھم سے نمایاں طور پر تیز ہے۔
10. تکرار کنندہ کیا ہے؟
جاوا زبان کے JDK 1.2 ریلیز میں متعارف کرایا گیا انٹرفیس
java.util.Iteratorکنٹینر کلاسوں کے تکرار کی اجازت دیتا ہے۔ ہر Iterator طریقوں کو نافذ کرتا ہے
next()اور
hasNext()اختیاری طور پر ایک کی حمایت کر سکتا ہے
remove()۔ تکرار کرنے والے متعلقہ کنٹینر کلاسوں کے ذریعہ بنائے جاتے ہیں، عام طور پر کے ذریعہ
iterator()۔ یہ طریقہ
next()تکرار کرنے والے کو اگلی قدر تک لے جاتا ہے اور مخصوص قدر کو دوبارہ کرنے والے کو واپس کرتا ہے۔ جب ابتدائی طور پر تخلیق کیا جاتا ہے، تکرار کرنے والا پہلے عنصر سے پہلے ایک خاص قدر کی طرف اشارہ کرتا ہے، لہذا پہلا عنصر صرف پہلی کال کے بعد ہی حاصل کیا جا سکتا ہے
next()۔ اس لمحے کا تعین کرنے کے لیے جب کنٹینر میں موجود تمام عناصر کو دہرایا گیا ہے، ٹیسٹ کا طریقہ استعمال کیا جاتا ہے
hasNext()۔ درج ذیل مثال تکرار کرنے والوں کے سادہ استعمال کو ظاہر کرتی ہے:
Iterator iter = list.iterator();//Iterator<MyType> iter = list.iterator(); в J2SE 5.0while(iter.hasNext())System.out.println(iter.next());
ایک قسم کے مجموعہ کے لیے جو اس کی حمایت کرتا ہے، تکرار کرنے والا طریقہ
remove()کنٹینر سے آخری 'وزٹ شدہ' عنصر کو ہٹاتا ہے۔ تکرار کے دوران کنٹینر میں ترمیم کی تقریباً تمام دوسری اقسام غیر محفوظ ہیں۔ اس کے علاوہ، اسی طرح کے API کے ساتھ
java.util.Listموجود ہے
java.util.ListIterator، لیکن آگے اور پیچھے کی تکرار کی اجازت دیتا ہے، فہرست میں موجودہ انڈیکس کی تعریف فراہم کرتا ہے اور عنصر کو اس کی پوزیشن کے مطابق منتقل کرتا ہے۔
ذریعہ:
GO TO FULL VERSION