ڪلاس ڪلاس

هڪ ڀيرو ٻيهر ڀليڪار! :) اڄ جي سبق ۾، اسان جاوا ۾ Arrays ڪلاس بابت ڳالهائينداسين. پوئين سبق ۾، اسان ڄاڻون ٿا ته هڪ اهڙي ڊيٽا ڍانچي کي ايري سڏيو ويندو آهي. اسان سکيو ته انهن کي ڪيئن ٺاهيو ۽ انهن کي ڊيٽا سان ڀريو. ۽ اسان ڏٺو ته اهي ميموري ۾ ڪيئن محفوظ آهن. اڄ اسان ڪجهه ڪمن ۽ مثالن تي نظر ڪنداسين جيڪي صفن سان ڪم ڪن ٿا جيڪي توهان اڪثر حقيقي ڪم ۾ ڏسندا. مثال طور، هن صورتحال کي تصور ڪريو: اسان وٽ 10 بي ترتيب نمبرن جو هڪ صف آهي.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

اسان جو ڪم اهو آهي ته هن صف کي وڌندي ترتيب ۾ ترتيب ڏيو: ننڍي کان وڏي تائين. آخر ۾، اهو هن طرح ڏسڻ گهرجي: [-234، -2، 16، 26، 35، 43، 92، 99، 167] اسان اهو ڪيئن ڪريون؟ هي ڪم معمولي نه آهي. اسان هن کان اڳ ڪڏهن به نه ڪيو آهي:/ ڪي خيال؟ اندازو لڳائڻ جي ڪوشش ڪريو. هتي هڪ حل آهي:

• صف جي سڀني عناصر جي ذريعي وڃو. هر عنصر کي ايندڙ ([0] سان [1]، [1] سان [2]، [2] سان [3]، وغيره). جيڪڏهن موجوده عنصر ايندڙ کان وڌيڪ آهي، اسان انهن کي تبديل ڪريون ٿا، ۽ پوء ايندڙ عنصر ڏانهن وڃو. جيڪڏهن نه، انهن کي ڇڏي ڏيو جيئن اهي آهن، ۽ اڳتي وڌو
• اهڙيء طرح، عناصر جي ذريعي پهرين پاس کان پوء، سڀ کان وڏو قدر (167) آخري سيل ۾ هجڻ جي ضمانت آهي.
• ھاڻي اسان سڀني عنصرن کي ٻيهر ويھارينداسين، پر ھن ڀيري اسين انڊيڪس [0] کان پڇاڙيءَ واري عنصر تائين شروع ڪنداسين (سڀ کان وڏو انگ اڳ ۾ ئي پنھنجي جاءِ تي آھي) ۽ ساڳيا موازن ۽ ادل بدلائينداسين. هن پاس ڪرڻ کان پوء، آخري سيل ۾، اسان وٽ ٻيو نمبر وڏو قدر هوندو (99).
• هن عمل کي ڪيترائي ڀيرا ورجايو جيئن اسان وٽ آري عناصر آهن.

اسان کي خيال آيو آهي. هاڻي اسان کي صرف ڪوڊ لکڻ جي ضرورت آهي. اهو هن طرح نظر اچي ٿو:

public class Main {

   public static void main(String[] args) {
      
       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

اھا... اھو ٿورڙو پيچيدو لڳي ٿو -_- جيتوڻيڪ عام اصول سمجھ ۾ اچي ٿو، اسان کي اڃا تائين تمام گھڻو ڪوڊ لکڻو پوندو آھي ھڪڙو سادو ڪم حل ڪرڻ لاءِ. ٺيڪ، شايد اسان صرف پنهنجو پاڻ کي وڌايو آهي؟ اهو ڪم جيڪو اسان حل ڪيو آهي شايد اڃا تائين اسان لاءِ تمام پيچيده آهي. اچو ته ڪجھ سادو ڪوشش ڪريون. مثال طور، ساڳيو نمبر صف وٺو.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

اسان جو ڪم ان جي مواد کي ٻئي صف ۾ نقل ڪرڻ آهي.

int [] numbersCopy = new int[10];

سوچيو ته توهان ان کي استعمال ڪندي ڪيئن ڪندا جيڪو توهان اڳ ۾ ئي arrays بابت ڄاڻو ٿا؟ مثال طور، توهان لوپ ۾ انگن جي صف ذريعي وڃو ۽ ترتيب سان ان جي عناصر کي نمبرن ۾ لکو Copy :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];
      
       for (int i = 0; i < numbers.length; i++) {
          
           numbersCopy[i] = numbers[i];
       }

   }
}

خير، ها، هتي اسان بنيادي طور تي ڪيو آهي! اهو لڳي ٿو ته اسان مسئلو حل ڪيو آهي. تنهن هوندي، جيڪڏهن توهان کي اهو اڪثر ڪرڻ جي ضرورت آهي، توهان جي ڪوڊ ۾ هڪجهڙائي واري لوپ جو هڪ گروپ هوندو. حقيقت ۾، اهي (۽ ٻيا) ڪم گهڻو وقت جاوا جي تخليق ڪندڙن طرفان حل ڪيا ويا آهن. اسان کي ضرورت نه آهي ته "ٻيهر کي ٻيهر ٺاهيو" ۽ اسان جي پنهنجي حل کي ڪوڊ ڪريو. اتي ھڪڙو خاص جامد طبقو آھي ( Arrays ) توھان جي مدد ڪرڻ لاءِ عام ڪمن کي انجام ڏيڻ ۾ جڏھن arrays سان ڪم ڪري. جاوا پروگرامرز کي درپيش سڀ کان عام ڪم ڪرڻ جا طريقا ھن ڪلاس ۾ شامل ڪيا ويا آھن. مثال طور، هڪ صف کي ترتيب ڏيڻ جو ڪم، جنهن کي اسان سنڀالڻ جي ڪوشش ڪئي، هڪ واحد لڪير ۾ حل ڪيو ويو آهي:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
      
       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

Arrays.sort () طريقو صف کي ترتيب ڏئي ٿو. ۽ ان جو الگورتھم اسان جي لکيل ڪوڊ کان گھڻو وڌيڪ ڪارائتو آھي. ڪنسول آئوٽ پُٽ: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] نوٽ: ايري کي اسٽرنگ ۾ تبديل ڪرڻ لاءِ، اسان Arrays ڪلاس جو ٻيو طريقو استعمال ڪيو: Arrays.toString() . جاوا ۾ Arrays پنهنجي طور تي toString() طريقي کي اوور رائڊ نه ڪندا آهن . تنهن ڪري، جيڪڏهن توهان صرف لکندا آهيو

System.out.println(numbers.toString());

Object ڪلاس جي toString() کي سڏيو ويندو. ايري لاءِ، آئوٽ پُٽ ڪجھ ھن طرح ھوندو: [I@4554617c اسان ھاڻي تفصيل ۾ نه وينداسين ته ھي آئوٽ پٽ ڇو آھي. بنيادي شيء اها آهي ته اهو واضح طور تي نه آهي جيڪو اسان کي گهربل آهي. پر Arrays.toString() اهو ئي ڪري ٿو جيڪو اسان چاهيون ٿا. رستي جي ذريعي، ڪاپي پڻ آساني سان مڪمل ڪئي وئي آهي Arrays ڪلاس سان:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

اسان Arrays.copyOf() طريقي ڏانهن وڃون ٿا اسان جي اصل صف (جنهن مان اسان قيمتون نقل ڪرڻ چاهيون ٿا) ۽ نئين سر جي ڊيگهه جنهن ۾ اسان ڊيٽا کي نقل ڪري رهيا آهيون. انهي صورت ۾، اسان اشارو ڪيو numbers.length کي ڊگھائي، ڇو ته سڄي صف کي نقل ڪرڻ چاهيون ٿا. جيڪڏهن اسان صرف پهرين چند عناصر کي نقل ڪرڻ چاهيون ٿا، اسان هڪ نئين ننڍڙي صف جي ڊيگهه کي بيان ڪري سگهون ٿا:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

هتي اسان 4 کي نئين صف جي ڊيگهه طور بيان ڪيو آهي. ان جي مطابق، انگن جي صرف پهرين 4 عناصر کي نئين صف ۾ نقل ڪيو ويندو. ڪنسول آئوٽ پُٽ: [167, -2, 16, 99] رستي ۾، Arrays توهان کي صف جي شروعات جي بجاءِ وچ مان هڪ صف جو حصو نقل ڪرڻ جي اجازت ڏئي ٿي:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

ٻاھر نڪتو: [16، 99، 26، 92] نمبرن کي نقل ڪيو ويو نئين صف ۾ ٻئي صف کان ٻئي (شامل) کان ڇھين (شامل نه آھي) عنصر تائين. اسان کي شايد ٻن صفن جي ڀيٽ ڪرڻ جي ضرورت پوندي. جيئن ته toString () طريقي سان، صفون پاڻ کي برابر نه ڪندا آھن () طريقي سان. پوء جيڪڏھن اسان انھن کي هن طرح compare ڪرڻ جي ڪوشش ڪئي

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

پوء اسان غلط ٿي وڃون ٿا. اهو ئي سبب آهي ته Object.equals() ، جيڪو حوالن جي ڀيٽ ڪري ٿو، سڏيو ويندو. ۽، ظاهر آهي، اهي مختلف آهن! پر ڇا اسان کي ضرورت آهي صفن جي مواد جو مقابلو ڪرڻ، نه حوالو. Arrays ڪلاس برابر ڪري ٿو () طريقي سان اهو ڪرڻ لاءِ جيڪو اسان چاهيون ٿا :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

آئوٽ پٽ: صحيح طريقي سان، Arrays ڪلاس ڪم ڪري ٿو نه رڳو عام صفن سان، پر ٻن طرفن سان پڻ:

public class Main {

   public static void main(String[] args) {

       int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));
      
       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

ٻاھر نڪرندڙ: ڇا اھي ٻه-dimensional array برابر آھن؟ true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] جيئن توهان ڏسي سگهو ٿا، Arrays.copyOf() طريقو ٻه طرفي صف کي نقل ڪرڻ جي قابل هو. ۽ ڪلاس وٽ خاص طريقا آھن موازن ڪرڻ ۽ ٻه طرفي صفن کي ڏيکارڻ لاءِ: deepEquals ۽ deepToString() . مستقبل ۾، توهان بار بار ڏسندؤ (۽ حقيقت ۾ خوش ٿيو) ته جاوا جي تخليق ڪندڙ ڪيترن ئي حالتن کي پيش ڪن ٿا جيڪي پروگرامرن کي اڪثر منهن ڏيڻو پوي ٿو، ۽ انهن لاء تيار ڪيل حل لاڳو ڪيو ٻوليء ۾. انهن حلن کي استعمال ڪرڻ تمام سولو ۽ وڌيڪ سولو آهي ڦيٿي کي ٻيهر ايجاد ڪرڻ کان، صحيح؟ :) پڙهڻ جي پڪ ڪريو آري ڪلاس لاءِ دستاويز کي Oracle ويب سائيٽ تي. توهان جي پڙهائي ۾ سٺي قسمت!