ஜாவா இணைக்கப்பட்ட பட்டியல்

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

public class Main {

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

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str2);
       earlBio.add(str3);
       earlBio.add(str4);

       System.out.println(earlBio);

   }
}

வெளியீடு: [வணக்கம் உலகம்! எனது பெயர் ஏர்ல், நான் ஜாவாவை விரும்புகிறேன், நான் கனடாவில் வசிக்கிறேன்] எங்கள் பட்டியல் எப்படி இருக்கும் என்பது இங்கே: புதிய உறுப்பை எவ்வாறு சேர்ப்பது என்று பார்ப்போம். இது add() முறையைப் பயன்படுத்தி செய்யப்படுகிறது .

earlBio.add(str2);

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

public class Main {

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

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str3);
       earlBio.add(1, str2);

       System.out.println(earlBio);

   }
}

நீங்கள் பார்க்கிறபடி, ஓவர்லோடட் ஆட்() முறையானது ஒரு புதிய உருப்படிக்கான குறிப்பிட்ட குறியீட்டைக் குறிப்பிட உங்களை அனுமதிக்கிறது. இந்த வழக்கில், str1 மற்றும் str3 க்கு இடையில் String str2 ஐ சேர்க்க விரும்புகிறோம் . இது உள்நாட்டில் நடக்கும்: உள் இணைப்புகளை மாற்றிய பின், str2 வெற்றிகரமாக பட்டியலில் சேர்க்கப்பட்டது: இப்போது அனைத்து 3 கூறுகளும் இணைக்கப்பட்டுள்ளன. சங்கிலியின் முதல் உறுப்பிலிருந்து கடைசி மற்றும் மீண்டும் அடுத்த இணைப்பு வழியாக நீங்கள் செல்லலாம் . எனவே, செருகுவதில் நாங்கள் மிகவும் வசதியாக இருக்கிறோம், ஆனால் உறுப்புகளை அகற்றுவது பற்றி என்ன? கொள்கை சரியாகவே உள்ளது. அகற்றப்படும் உறுப்பின் "இடதுபுறம் மற்றும் வலதுபுறம்" இரண்டு உறுப்புகளில் உள்ள இணைப்புகளை நாங்கள் புதுப்பிக்கிறோம்:

public class Main {

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

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str3);
       earlBio.add(1, str2);

       earlBio.remove(1);
       System.out.println(earlBio);
   }
}

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

முறைகளின் கண்ணோட்டம்

LinkedList ஆனது ArrayList உடன் பொதுவான பல முறைகளைக் கொண்டுள்ளது . எடுத்துக்காட்டாக, இரண்டு வகுப்புகளும் add() , remove() , indexOf() , clear() , contains() (ஒரு உருப்படி பட்டியலில் உள்ளதா என்பதைக் குறிக்கிறது), set() (ஏற்கனவே உள்ள உறுப்பை மாற்றுகிறது) மற்றும் அளவு ( ) அவற்றில் பல உள்நாட்டில் வித்தியாசமாக வேலை செய்தாலும் ( சேர்() மற்றும் அகற்று() உடன் நாம் கண்டறிந்தது போல் ), இறுதி முடிவு ஒன்றுதான். இருப்பினும், லிங்க்ட்லிஸ்ட் பட்டியலின் ஆரம்பம் மற்றும் முடிவோடு வேலை செய்வதற்கான தனி முறைகளைக் கொண்டுள்ளது, அவை வரிசைப்பட்டியலில் இல்லை:

• addFirst() , addLast() : பட்டியலின் ஆரம்பம்/முடிவில் ஒரு உறுப்பைச் சேர்ப்பதற்கான இந்த முறைகள்

public class Car {

   String model;

   public Car(String model) {
       this.model = model;
   }

   public static void main(String[] args) {
       LinkedList<Car> cars = new LinkedList<>();
       Car ferrari = new Car("Ferrari 360 Spider");
       Car bugatti = new Car("Bugatti Veyron");
       Car lambo = new Car("Lamborghini Diablo");
       Car ford = new Car("Ford Mondeo");
       Car fiat = new Car("Fiat Ducato");

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);
       System.out.println(cars);

       cars.addFirst(ford);
       cars.addLast(fiat);
       System.out.println(cars);
   }

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

வெளியீடு: [கார்{மாடல்='ஃபெராரி 360 ஸ்பைடர்'}, கார்{மாடல்='புகாட்டி வெய்ரான்'}, கார்{மாடல்='லம்போர்கினி டையப்லோ'}] [கார்{மாடல்='ஃபோர்டு மொண்டியோ'}, கார்{மாடல்=' Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}, Car{model='Fiat Ducato'}] நாங்கள் பட்டியலில் முதலிடத்தில் "Ford" உடன் முடிவடைகிறோம் , மற்றும் இறுதியில் "Fiat".

• peekFirst() , peekLast() : முறைகள் பட்டியலில் முதல்/கடைசி உறுப்பை வழங்கும். பட்டியல் காலியாக இருந்தால் அவை பூஜ்யமாகத் திரும்பும் .

public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   System.out.println(cars.peekFirst());
   System.out.println(cars.peekLast());
}

வெளியீடு: கார்{மாடல்='ஃபெராரி 360 ஸ்பைடர்'} கார்{மாடல்='லம்போர்கினி டையப்லோ'}

• pollFirst() , pollLast() : இந்த முறைகள் பட்டியலில் உள்ள முதல்/கடைசி உறுப்பைத் திருப்பி பட்டியலிலிருந்து அகற்றும். பட்டியல் காலியாக இருந்தால் அவை பூஜ்யமாகத் திரும்பும்

public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   System.out.println(cars.pollFirst());
   System.out.println(cars.pollLast());

   System.out.println ("What's on the list?");
   System.out.println(cars);
}

வெளியீடு: கார்{மாடல்='ஃபெராரி 360 ஸ்பைடர்'} கார்{மாடல்='லம்போர்கினி டையப்லோ'} பட்டியலில் இன்னும் என்ன இருக்கிறது? [கார்{மாடல்='புகாட்டி வேய்ரான்'}]

• toArray() : இந்த முறை பட்டியல் உருப்படிகளைக் கொண்ட வரிசையை வழங்குகிறது

public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   Car[] carsArray = cars.toArray(new Car[3]);
   System.out.println(Arrays.toString(carsArray));
}

வெளியீடு: [Car{model='Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}] LinkedList எவ்வாறு செயல்படுகிறது மற்றும் அதன் அமைப்பு ArrayList இலிருந்து எவ்வாறு வேறுபடுகிறது என்பதை இப்போது அறிவோம் . LinkedList ஐப் பயன்படுத்துவதன் நன்மைகள் என்ன ? எல்லாவற்றிற்கும் மேலாக, பட்டியலில் நடுவில் பணிபுரியும் போது நாம் பயனடைகிறோம். இணைப்புப்பட்டியலின் நடுவில் உள்ள செருகுதல் மற்றும் அகற்றுதல் செயல்பாடுகள் வரிசைப்பட்டியலை விட மிகவும் எளிமையானவை . அண்டை உறுப்புகளின் இணைப்புகளை நாங்கள் புதுப்பிக்கிறோம், மேலும் தேவையற்ற உறுப்பு இணைப்புகளின் சங்கிலியிலிருந்து "வெளியேறும்". ஆனால் ஒரு வரிசைப்பட்டியலில் , நாம் வேண்டும்

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

வேறு வார்த்தைகளில் கூறுவதானால், பட்டியலின் நடுவில் உள்ள செருகல்/அகற்றுதல் செயல்பாடுகள் உங்கள் திட்டத்தில் மிகவும் பொதுவானதாக இருந்தால், LinkedList ஆனது ArrayList ஐ விட வேகமாக இருக்க வேண்டும் .

கோட்பாட்டில்

public class Main {

   public static void main(String[] args) {
       List<Integer> list = new LinkedList<>();

       for (int i = 0; i < 5_000_000; i++) {
           list.add(new Integer(i));
       }

       long start = System.currentTimeMillis();

       for (int i = 0; i < 100; i++) {
           list.add(2_000_000, new Integer(Integer.MAX_VALUE));
       }
       System.out.println("Time taken by LinkedList (in milliseconds) = " + (System.currentTimeMillis()-start));
   }
}

வெளியீடு: LinkedList எடுத்த நேரம் (மில்லி விநாடிகளில்) = 1873

public class Main {

   public static void main(String[] args) {
       List<Integer> list = new ArrayList<>();

       for (int i = 0; i < 5_000_000; i++) {
           list.add(new Integer(i));
       }

       long start = System.currentTimeMillis();

       for (int i = 0; i < 100; i++) {
           list.add(2_000_000, new Integer(Integer.MAX_VALUE));
       }
       System.out.println("Time taken by ArrayList (in milliseconds) = " + (System.currentTimeMillis()-start));
   }
}

வெளியீடு: ArrayList எடுத்த நேரம் (மில்லி விநாடிகளில்) = 181 இது எதிர்பாராதது! LinkedList மிகவும் திறமையானதாக இருக்க வேண்டிய ஒரு செயல்பாட்டை நாங்கள் செய்தோம் : ஒரு பட்டியலின் நடுவில் 100 உருப்படிகளைச் செருகுவது. எங்கள் பட்டியல் மிகப்பெரியது: 5,000,000 கூறுகள். ArrayList ஒவ்வொரு செருகுதலுக்கும் இரண்டு மில்லியன் உருப்படிகளை மாற்ற வேண்டும்! அது எப்படி வெற்றி பெற்றது? முதலாவதாக, உறுப்புகளை அணுகுவதற்கு ArrayList க்கு தேவையான நேரம் நிலையானது (நிலையானது). நீங்கள் எழுதும் போது

list.add(2_000_000, new Integer(Integer.MAX_VALUE));

பின்னர் ArrayList [2_000_000] என்பது ஒரு குறிப்பிட்ட நினைவக முகவரி (எல்லாவற்றுக்கும் மேலாக, பட்டியலில் ஒரு உள் வரிசை உள்ளது). ஆனால், ஒரு லிங்க்ட்லிஸ்ட்டில் அணிவரிசை இல்லை. இது இணைப்புகளின் சங்கிலியுடன் உறுப்பு எண் 2_000_000 ஐத் தேடும். LinkedListக்கு, இது நினைவக முகவரி அல்ல, ஆனால் இன்னும் அடைய வேண்டிய இணைப்பு: fistElement.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next. next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next…… . இதன் விளைவாக, பட்டியலின் நடுவில் ஒவ்வொரு செருகும் போதும் (அகற்றுதல்) , ArrayList ஆனது அணுகுவதற்கான சரியான நினைவக முகவரியை ஏற்கனவே அறிந்திருக்கிறது, ஆனால் LinkedList இன்னும் "அங்கு செல்ல" வேண்டும். இரண்டாவதாக, வரிசைப்பட்டியலின் அமைப்பு உள்ளதுதன்னை. ஒரு சிறப்பு உள் செயல்பாடு ( System.arrayCopy() ) உள் வரிசையை விரிவுபடுத்துகிறது, மேலும் அனைத்து உறுப்புகளையும் நகலெடுத்து மாற்றுகிறது. இது மிகவும் வேகமானது, ஏனெனில் இது குறிப்பிட்ட வேலைக்கு உகந்ததாக உள்ளது. ஆனால் நீங்கள் ஒரு குறிப்பிட்ட குறியீட்டை "பெற" வேண்டியதில்லை என்றால், LinkedList வெற்றியாளராக இருக்கும். பட்டியலின் ஆரம்பத்திலேயே நுழைக்கிறோம் என்று வைத்துக்கொள்வோம். ஒரு மில்லியன் கூறுகளைச் செருக முயற்சிப்போம்:

public class Main {

   public static void main(String[] args) {
       getTimeMsOfInsert(new ArrayList());
       getTimeMsOfInsert(new LinkedList());
   }

   public static long getTimeMsOfInsert(List list) {
       // Write your code here
       Date currentTime = new Date();
       insert1000000(list);
       Date newTime = new Date();
       long msDelay = newTime.getTime() - currentTime.getTime(); // Calculate the difference
       System.out.println("The result in milliseconds: " + msDelay);
       return msDelay;

   }

   public static void insert1000000(List list) {
       for (int i = 0; i < 1000000; i++) {
           list.add(0, new Object());
       }
   }

}

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

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

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