வரிசைகள் வகுப்பு

மீண்டும் வணக்கம்! :) இன்றைய பாடத்தில், ஜாவாவில் உள்ள அரேஸ் வகுப்பைப் பற்றி பேசுவோம். கடந்த பாடத்தில், ஒரு வரிசை எனப்படும் தரவு கட்டமைப்பை நாங்கள் அறிந்தோம். அவற்றை எவ்வாறு உருவாக்குவது மற்றும் தரவுகளால் நிரப்புவது என்பதை நாங்கள் கற்றுக்கொண்டோம். அவை எவ்வாறு நினைவகத்தில் சேமிக்கப்படுகின்றன என்பதை நாங்கள் பார்த்தோம். உண்மையான வேலையில் நீங்கள் அடிக்கடி பார்க்கும் சில பணிகள் மற்றும் வரிசைகளுடன் வேலை செய்வதற்கான எடுத்துக்காட்டுகளை இன்று பார்ப்போம். எடுத்துக்காட்டாக, இந்த சூழ்நிலையை கற்பனை செய்து பாருங்கள்: எங்களிடம் 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];

வரிசைகளைப் பற்றி உங்களுக்கு ஏற்கனவே தெரிந்ததைப் பயன்படுத்தி அதை எவ்வாறு செய்வீர்கள் என்று யோசித்துப் பாருங்கள்? எடுத்துக்காட்டாக, நீங்கள் ஒரு சுழற்சியில் எண்களின் வரிசையின் வழியாகச் சென்று அதன் கூறுகளை எண்கள்நகலில் எழுதலாம் :

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];
       }

   }
}

சரி, இதோ, நாங்கள் அதைச் செய்துவிட்டோம்! நாங்கள் சிக்கலைத் தீர்த்துவிட்டதாகத் தெரிகிறது. இருப்பினும், நீங்கள் இதை அடிக்கடி செய்ய வேண்டியிருந்தால், உங்கள் குறியீட்டில் ஒரே மாதிரியான சுழல்கள் இருக்கும். உண்மையில், இந்த (மற்றும் பிற) பணிகள் ஜாவாவின் படைப்பாளர்களால் நீண்ட காலமாக தீர்க்கப்பட்டுள்ளன. நாங்கள் "சக்கரத்தை மீண்டும் கண்டுபிடித்து" எங்கள் சொந்த தீர்வைக் குறியீடாக்க வேண்டிய அவசியமில்லை. வரிசைகளுடன் பணிபுரியும் போது பொதுவான பணிகளைச் செய்ய உங்களுக்கு உதவ ஒரு சிறப்பு நிலையான வகுப்பு ( வரிசைகள் ) உள்ளது . ஜாவா புரோகிராமர்கள் எதிர்கொள்ளும் பொதுவான பணிகளைச் செய்வதற்கான முறைகள் இந்த வகுப்பில் சேர்க்கப்பட்டுள்ளன. எடுத்துக்காட்டாக, நாங்கள் கையாள முயற்சித்த ஒரு வரிசையை வரிசைப்படுத்தும் பணி ஒற்றை வரியில் தீர்க்கப்படுகிறது:

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.toString() . ஜாவாவில் உள்ள அணிவரிசைகள் தாங்களாகவே toString() முறையை மீறுவதில்லை . எனவே, நீங்கள் வெறுமனே எழுதினால்

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

ஆப்ஜெக்ட் வகுப்பின் toString() என்று அழைக்கப்படும். ஒரு வரிசைக்கு, வெளியீடு இப்படி இருக்கும்: [I@4554617c இது ஏன் சரியாக இருக்கிறது என்பது பற்றி இப்போது விரிவாகப் பேச மாட்டோம். முக்கிய விஷயம் என்னவென்றால், அது நமக்குத் தேவையானது அல்ல. ஆனால் Arrays.toString() நாம் விரும்புவதைத் துல்லியமாகச் செய்கிறது. மூலம், வரிசை வகுப்பில் நகலெடுப்பதும் எளிதாக நிறைவேற்றப்படுகிறது:

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] மூலம், அணிவரிசையின் தொடக்கத்தை விட நடுவில் இருந்து ஒரு வரிசையின் பகுதியை நகலெடுக்கவும் வரிசைகள் உங்களை அனுமதிக்கிறது:

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() முறையைப் போலவே , வரிசைகளே சமம்() முறையை மீறாது . எனவே அவர்களை இப்படி ஒப்பிட்டுப் பார்க்க முயன்றால்

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() , என்று அழைக்கப்படும். மற்றும், வெளிப்படையாக, அவர்கள் வித்தியாசமாக இருக்கிறார்கள்! ஆனால் நமக்குத் தேவை வரிசை உள்ளடக்கங்களை ஒப்பிடுவது, குறிப்புகள் அல்ல. நாம் விரும்புவதைச் சரியாகச் செய்ய, வரிசைகள் வகுப்பு சமம்() முறையை மீறுகிறது :

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));
   }
}

வெளியீடு: உண்மை , வரிசைகள் வகுப்பு சாதாரண வரிசைகளுடன் மட்டுமல்ல, இரு பரிமாணங்களுடனும் செயல்படுகிறது:

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));
   }
}

வெளியீடு: இந்த இரு பரிமாண வரிசைகள் சமமானதா? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] நீங்கள் பார்க்கிறபடி, Arrays.copyOf() முறையானது இரு பரிமாண வரிசையை நகலெடுக்க முடிந்தது. இரு பரிமாண வரிசைகளை ஒப்பிடுவதற்கும் காண்பிப்பதற்கும் வகுப்பில் சிறப்பு முறைகள் உள்ளன: deepEquals மற்றும் deepToString() . எதிர்காலத்தில், ஜாவாவின் படைப்பாளிகள் புரோகிராமர்கள் அடிக்கடி எதிர்கொள்ளும் பல சூழ்நிலைகளை எதிர்பார்த்திருப்பதையும், அவர்களுக்கான ஆயத்த தீர்வுகளை மொழியில் செயல்படுத்தியதையும் நீங்கள் மீண்டும் மீண்டும் பார்ப்பீர்கள் (உண்மையில் மகிழ்ச்சி அடைவீர்கள்). சக்கரத்தை மீண்டும் கண்டுபிடிப்பதை விட இந்த தீர்வுகளைப் பயன்படுத்துவது மிகவும் எளிதானது மற்றும் வசதியானது, இல்லையா? :) Oracle இணையதளத்தில் Arrays வகுப்பிற்கான ஆவணங்களைப் படிக்க மறக்காதீர்கள் . உங்கள் படிப்பில் நல்ல அதிர்ஷ்டம்!