ஜாவாவில் சேகரிப்பு வகுப்பு

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

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

வெளியீடு: [பூமி, வியாழன், செவ்வாய், புதன், நெப்டியூன், சனி, யுரேனஸ், வீனஸ்] சரங்கள் அகரவரிசைப்படி வரிசைப்படுத்தப்பட்டுள்ளன! ஆனால் ஏன் அகரவரிசையில்? Stringசரங்கள் எவ்வாறு ஒப்பிடப்படுகின்றன என்பதை நிர்வகிக்கும் தர்க்கத்தை வர்க்கம் உண்மையில் செயல்படுத்துகிறது (இது அகர வரிசைப்படி நடக்கும்) . நீங்களே உருவாக்கும் வகுப்புகளுக்கு, உங்கள் சொந்த ஒப்பீட்டு தர்க்கத்தை நீங்கள் செயல்படுத்தலாம், ஆனால் இதைப் பற்றி மற்ற பாடங்களில் பேசுவோம். ஒரு இல் குறைந்தபட்ச மற்றும் அதிகபட்ச உறுப்பைக் கண்டறியவும் வகுப்பு Collectionsஉதவுகிறது ArrayList. min()இது மற்றும் முறைகளைப் பயன்படுத்தி செய்யப்படுகிறது max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

வெளியீடு: 7 1 இயற்கையாகவே, கைமுறையாக குறியீட்டை எழுதுவதை விட இது மிகவும் வசதியானது, எல்லா உறுப்புகளையும் மீண்டும் மீண்டும் செய்யவும் மற்றும் மிகப்பெரிய/சிறிய உறுப்பைக் கண்டறியவும் :) மற்றொரு மிகவும் பயனுள்ள முறை reverse(). நாம் பட்டியலை "புரட்ட" வேண்டும் என்றால், உறுப்புகள் எதிர் வரிசையில் சென்றால், அதை எப்படி செய்வோம்? அத்தகைய வழிமுறையை நீங்களே எழுதுவது அவ்வளவு சுலபமாக இருக்காது :) அதிர்ஷ்டவசமாக, முறை reverse()எப்படி என்று ஏற்கனவே தெரியும். இந்த முறை நமது கிரகங்களை அகர வரிசைப்படி வரிசைப்படுத்தியது நமக்குப் பிடிக்கவில்லை என்று வைத்துக்கொள்வோம் sort(), மேலும் அவற்றின் வரிசையை மாற்ற விரும்புகிறோம்: Z இலிருந்து A வரை:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

வெளியீடு: [வீனஸ், யுரேனஸ், சனி, நெப்டியூன், புதன், செவ்வாய், வியாழன், பூமி] நாம் வரிசைப்படுத்துதல், தனிமங்களின் வரிசை போன்றவற்றைப் பற்றி நிறைய பேசிக்கொண்டிருக்கிறோம். ஆனால் நாம் எதிர் நோக்கமாக இருந்தால் என்ன செய்வது? உதாரணமாக, நாம் ஒரு பிங்கோ விளையாட்டை செயல்படுத்த முயற்சிக்கிறோம் என்று வைத்துக்கொள்வோம். டிரம்மில் 100 எண்களைச் சேர்க்கிறோம். அவர்கள் ஒரு நேரத்தில் திரையில் தோன்ற வேண்டும். டிக்கெட்டில் உள்ள அனைத்து எண்களையும் கடந்து செல்லும் முதல் வீரர் வெற்றி பெறுவார். இந்த முறையைப் பயன்படுத்தி செயல்படுத்த எளிதானது shuffle():

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> bingoDrum = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           bingoDrum.add(i);// add the numbers 1 to 100 to the drum
       }

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(bingoDrum.get(i));
       }

   }
}

வெளியீடு: உங்கள் கவனம், தயவுசெய்து! டிரம்மில் இருந்து முதல் 10 எண்கள் இதோ! 32 61 4 81 25 8 66 35 42 71 இது மிகவும் எளிதானது! சிக்கல் தீர்க்கப்பட்டது, மற்றும் விளையாட்டின் எங்கள் பகுதி எழுதப்பட்டுள்ளது :) இப்போது வேறு சூழ்நிலையை கற்பனை செய்யலாம். solarSystemமுன்னதாக, கிரகங்கள் அடங்கிய பட்டியலை உருவாக்கினோம் . மேலும் இது எல்லா வகையிலும் எங்களுக்குப் பொருந்துவதாகத் தோன்றுகிறது, ஆனால் ஒன்றைத் தவிர: அதிலிருந்து உருப்படிகளை நீக்கிவிட்டு புதியவற்றைச் சேர்க்கலாம் ! இது தெளிவாக நாம் எதிர்பார்க்கும் நடத்தை அல்ல: நமது திட்டத்தில் சூரிய குடும்பம் மாறாமல் இருக்க வேண்டும். வகுப்பில் Collectionsமிகவும் சுவாரஸ்யமான முறை உள்ளது: unmodifiableList(). இது ஒரு வாதமாக அனுப்பப்பட்ட பட்டியலில் இருந்து ஒரு மாறாத பட்டியலை உருவாக்குகிறது. இந்தப் பட்டியலில் இருந்து உருப்படிகளைச் சேர்க்கவோ நீக்கவோ முடியாது. சூரிய மண்டலத்தில் உள்ள கிரகங்களின் பட்டியலைக் கையாளும் போது, ​​இதுவே நாம் விரும்புவது!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");// Try to add a new element
   }
}

வெளியீடு: "main" java.lang நூலில் விதிவிலக்கு எதையும் சேர் solarSystem! இங்கே நீங்கள் கவனம் செலுத்த வேண்டிய ஒரே விஷயம் என்னவென்றால், இந்த முறை திரும்பும் List<>(இல்லை ArrayList<>), ஏனெனில் இந்த வகை அனைத்து வகையான பட்டியல்களுக்கும் பொதுவானது. எளிதில் நிகழக்கூடிய மற்றொரு பொதுவான சூழ்நிலை, புரோகிராமர் தவறான வரிசையில் கூறுகளைச் சேர்ப்பது. இது நடந்தால், புதனும் நெப்டியூனும் கலந்திருப்பதைக் கண்டறிந்தால், இந்த swap()முறையைப் பயன்படுத்தி இந்த தவறை சரிசெய்யலாம்:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// The planets are in the wrong order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

swap()நாங்கள் பட்டியலின் முறை மற்றும் மாற்றப்பட வேண்டிய இரண்டு கூறுகளின் குறியீடுகளுக்கு செல்கிறோம் . இந்த முறை குறியீடுகளுடன் செயல்படுகிறது, குறிப்புகளுடன் அல்ல. எனவே, இங்கே நாம் முறையைப் பயன்படுத்த வேண்டியிருந்தது ArrayList.indexOf(). வெளியீடு: [நெப்டியூன், வீனஸ், பூமி, செவ்வாய், வியாழன், சனி, யுரேனஸ், புதன்] [புதன், வீனஸ், பூமி, செவ்வாய், வியாழன், சனி, யுரேனஸ், நெப்டியூன்] இறுதியாக, மிகவும் சுவாரஸ்யமான முறையைப் பற்றி அறிந்து கொள்வோம் : disjoint(). இது இரண்டு சேகரிப்புகள் வெட்டுகின்றனவா என்பதைச் சரிபார்க்கிறது, அதாவது, அவற்றில் குறைந்தபட்சம் ஒரே மாதிரியான உறுப்பு உள்ளதா . அவர்கள் செய்யவில்லை என்றால், அது உண்மையாகத் திரும்பும். அவர்கள் அதை செய்கிறார்கள், பின்னர் அது பொய்யாகிவிடும்

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

நீங்கள் பார்க்க முடியும் என, எங்கள் இரண்டு பட்டியல்கள் முற்றிலும் வேறுபட்ட கூறுகள் உள்ளன, எனவே நிரல் வெளியீடு உண்மை . இது ஒரு சுவாரஸ்யமான மற்றும் மிகவும் பயனுள்ள வகுப்பு. , இது Arraysநமக்கு நிறைய வழக்கமான, கடினமான வேலைகளைச் செய்கிறது, மற்ற விஷயங்களில் கவனம் செலுத்த அனுமதிக்கிறது.