ஜாவா வரிசை பட்டியல்

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

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


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


• ஒரு பொருளை நீக்க எந்த முறையும் இல்லை. ஒரு மதிப்பை "பூஜ்ஜியமாக" மட்டுமே செய்ய முடியும்.

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

      
      
       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

வெளியீடு: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] அதிர்ஷ்டவசமாக, ஜாவாவின் படைப்பாளிகள் அணிகளின் நன்மைகள் மற்றும் தீமைகள் பற்றி நன்கு அறிந்திருக்கிறார்கள், எனவே Java ArrayList எனப்படும் மிகவும் சுவாரஸ்யமான தரவு கட்டமைப்பை உருவாக்கியுள்ளனர் . முடிந்தவரை எளிமையாகப் பேசினால், ஜாவா அரேலிஸ்ட் என்பது பல புதிய அம்சங்களைக் கொண்ட "சூப் அப்" வரிசையாகும்.

ஒரு வரிசைப்பட்டியலை எவ்வாறு உருவாக்குவது

உருவாக்குவது மிகவும் எளிதானது:

ArrayList<Cat> cats = new ArrayList<Cat>();

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

• அக வரிசை நிரப்பப்படும் போது, ​​ArrayList உள்நாட்டில் ஒரு புதிய வரிசையை உருவாக்குகிறது. புதிய அணிவரிசையின் அளவு பழைய வரிசையின் அளவு 1.5 கூட்டல் 1 ஆகும்.


• எல்லா தரவும் பழைய வரிசையில் இருந்து புதியதாக நகலெடுக்கப்படும்


• பழைய வரிசை குப்பை சேகரிப்பாளரால் சுத்தம் செய்யப்படுகிறது.

இந்த பொறிமுறையானது Java ArrayList ஐ (சாதாரண வரிசையைப் போலல்லாமல்) புதிய கூறுகளைச் சேர்ப்பதற்கான ஒரு முறையைச் செயல்படுத்த அனுமதிக்கிறது. அது add()முறை

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Behemoth"));
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

வெளியீடு: Cat{name='Behemoth'} கூடுதலாக, ArrayList இல் குறிப்பிட்ட பொருள் உள்ளதா என்பதை நீங்கள் எளிதாகக் கண்டறியலாம். இது ArrayList contains() முறையைப் பயன்படுத்தி செய்யப்படுகிறது :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.remove(fluffy);
   System.out.println(cats.contains(fluffy));
}

இந்த முறை, ArrayList இன் உள் அணிவரிசையில் உறுப்பு உள்ளதா என்பதைச் சரிபார்த்து, ஒரு பூலியன் (சரி அல்லது தவறு) கொடுக்கிறது. வெளியீடு: தவறான மற்றும் செருகுவதைப் பற்றிய மற்றொரு முக்கியமான விஷயம். அணிவரிசையின் முடிவில் மட்டும் இல்லாமல், எங்கும் உறுப்புகளைச் செருக, குறியீட்டைப் பயன்படுத்த வரிசைப்பட்டியல் உங்களை அனுமதிக்கிறது. இதற்கு இரண்டு முறைகள் உள்ளன:

• ArrayList add(int index, Cat உறுப்பு)
• வரிசைப்பட்டியல் தொகுப்பு (இன்ட் இன்டெக்ஸ், கேட் உறுப்பு)

வாதங்களாக, இந்த இரண்டு முறைகளும் நீங்கள் செருக விரும்பும் நிலையின் குறியீட்டையும், பொருளின் குறிப்பையும் எடுத்துக்கொள்கிறது. வித்தியாசம் என்னவென்றால், set() ஐப் பயன்படுத்தி செருகுவது பழைய மதிப்பை மேலெழுதுகிறது. add() ஐப் பயன்படுத்தி செருகுவது முதலில் அனைத்து உறுப்புகளையும் [index] இலிருந்து வரிசையின் இறுதிக்கு மாற்றுகிறது, பின்னர் குறிப்பிட்ட பொருளை அதன் விளைவாக வரும் வெற்று நிலையில் சேர்க்கிறது.

இங்கே ஒரு உதாரணம்:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

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

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

   System.out.println(cats.toString());
}

வெளியீடு: [[பூனை{பெயர்='தாமஸ்'}, பூனை{பெயர்='பெஹெமோத்'}] [பூனை{பெயர்='லியோனல் மெஸ்ஸி'}, பூனை{பெயர்='பெஹிமோத்'}] எங்களிடம் 2 பூனைகளின் பட்டியல் இருந்தது . பின்னர் செட்() முறையைப் பயன்படுத்தி உறுப்பு 0 ஆக இன்னொன்றைச் செருகினோம் . இதன் விளைவாக, பழைய உறுப்பு புதியதாக மாற்றப்பட்டது.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

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

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

   System.out.println(cats.toString());
}

மேலும் add() வித்தியாசமாக செயல்படுவதை இங்கு காண்கிறோம் . இது அனைத்து உறுப்புகளையும் வலது பக்கம் நகர்த்தி, பின்னர் புதிய மதிப்பை உறுப்பு 0 என எழுதுகிறது. வெளியீடு: [பூனை{பெயர்='தாமஸ்'}, பூனை{பெயர்='பெஹெமோத்'}] [பூனை{பெயர்='லியோனல் மெஸ்ஸி'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] பட்டியலை முழுமையாக அழிக்க, நாங்கள் clear() முறையைப் பயன்படுத்துகிறோம்:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.clear();

   System.out.println(cats.toString());
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

வெளியீடு: [பூனை{பெயர்='தாமஸ்'}, பூனை{பெயர்='பெஹெமோத்'}, பூனை{பெயர்='லியோனல் மெஸ்ஸி'}, பூனை{பெயர்='பஞ்சுபோன்ற'}] நீங்கள் எதிர் திசையிலும் செல்லலாம்: கிடைக்கும் ArrayList பொருளிலிருந்து ஒரு வரிசை . toArray() முறையைப் பயன்படுத்தி இதைச் செய்கிறோம் :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

ஒரு வரிசையின் நீளப் பண்பு போலல்லாமல், ArrayList.size() முறையானது அசல் கொள்ளளவை அல்ல, உண்மையான உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது என்பதைப் புரிந்துகொள்வது அவசியம் . எல்லாவற்றிற்கும் மேலாக, ArrayList ஐ உருவாக்கும் போது நாங்கள் அளவைக் குறிப்பிடவில்லை . இருப்பினும், நீங்கள் அதைக் குறிப்பிடலாம் - ArrayList க்கு பொருத்தமான கட்டமைப்பாளர் உள்ளது. ஆனால் புதிய கூறுகளைச் சேர்ப்பதன் அடிப்படையில், இது அதன் நடத்தையை மாற்றாது:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

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