தரவு கட்டமைப்புகள்: அடுக்கு மற்றும் வரிசை

வணக்கம்! எந்தவொரு புரோகிராமருக்கும் மிக முக்கியமான ஒன்றைப் பற்றி இன்று பேசுவோம்: தரவு கட்டமைப்புகள். விக்கிபீடியா கூறுகிறது: "ஒரு தரவு அமைப்பு என்பது தரவு அமைப்பு, மேலாண்மை மற்றும் சேமிப்பக வடிவமாகும், இது திறமையான அணுகல் மற்றும் மாற்றத்தை செயல்படுத்துகிறது. இன்னும் துல்லியமாக, தரவு கட்டமைப்பு என்பது தரவு மதிப்புகள், அவற்றுக்கிடையேயான உறவுகள் மற்றும் செயல்பாடுகள் அல்லது செயல்பாடுகள் ஆகியவற்றின் தொகுப்பாகும். தரவுகளுக்குப் பயன்படுத்தப்பட்டது." வரையறை சற்று குழப்பமாக உள்ளது, ஆனால் அதன் சாராம்சம் தெளிவாக உள்ளது. தரவு கட்டமைப்பு என்பது ஒரு வகையான களஞ்சியமாகும், அங்கு நாம் எதிர்கால பயன்பாட்டிற்காக தரவைச் சேமிக்கிறோம். நிரலாக்கத்தில், பல்வேறு வகையான தரவு கட்டமைப்புகள் உள்ளன. குறிப்பிட்ட சிக்கல்களைத் தீர்க்கும் போது, ​​மிக முக்கியமான விஷயம், சிக்கலுக்கு மிகவும் பொருத்தமான தரவு கட்டமைப்பைத் தேர்ந்தெடுப்பதாகும். அவர்களில் பலரை நீங்கள் ஏற்கனவே அறிந்திருக்கிறீர்கள்! எடுத்துக்காட்டாக, வரிசைகளைப் பற்றி உங்களுக்குத் தெரியும். மேலும் உங்களுக்கும் தெரிந்திருக்கும்Map(இந்த தரவு கட்டமைப்பை "அகராதி" அல்லது "துணை வரிசை" என்றும் குறிப்பிடலாம்). தரவு கட்டமைப்புகள் எந்தவொரு குறிப்பிட்ட மொழியுடனும் பிணைக்கப்படவில்லை என்பதைப் புரிந்துகொள்வது மிகவும் முக்கியம். அவை வெறுமனே சுருக்கமான "புளூப்ரிண்டுகள்" ஆகும், அவை ஒவ்வொரு நிரலாக்க மொழியும் அதன் சொந்த வகுப்புகள் அல்லது ஒரு குறிப்பிட்ட கட்டமைப்பின் செயலாக்கங்களை உருவாக்கப் பயன்படுத்துகின்றன. எடுத்துக்காட்டாக, மிகவும் பிரபலமான தரவு கட்டமைப்புகளில் ஒன்று இணைக்கப்பட்ட பட்டியல். நீங்கள் விக்கிபீடியாவிற்குச் சென்று, இது எவ்வாறு செயல்படுகிறது மற்றும் அதன் நன்மைகள் மற்றும் தீமைகள் என்ன என்பதைப் பற்றி படிக்கலாம். ஒருவேளை அதன் வரையறை உங்களுக்கு நன்கு தெரிந்ததாகத் தோன்றலாம் :) "இணைக்கப்பட்ட பட்டியல் என்பது தரவு உறுப்புகளின் நேரியல் தொகுப்பாகும், அதன் வரிசையானது நினைவகத்தில் அவற்றின் இயற்பியல் இருப்பிடத்தால் வழங்கப்படவில்லை. மாறாக, ஒவ்வொரு உறுப்பும் அடுத்ததைச் சுட்டிக்காட்டுகிறது." அது நம் காதலியை விவரிக்கிறது LinkedList, இல்லையா? ஆம், அது தான் :) ஜாவாவில், "இணைக்கப்பட்ட பட்டியல்" தரவு அமைப்பு வகுப்பால் செயல்படுத்தப்படுகிறது LinkedList. ஆனால் மற்ற மொழிகளும் இணைக்கப்பட்ட பட்டியல்களை செயல்படுத்துகின்றன! பைத்தானில், இந்த தரவு அமைப்பு " llist" என்று அழைக்கப்படுகிறது. LinkedListஜாவாவைப் போலவே ஸ்கலாவில் இது "" என்று அழைக்கப்படுகிறது . இணைக்கப்பட்ட பட்டியல் அடிப்படை பொதுவான தரவு கட்டமைப்புகளில் ஒன்றாகும், எனவே இது எந்த நவீன நிரலாக்க மொழியிலும் செயல்படுத்தப்படுவதை நீங்கள் காணலாம். அசோசியேட்டிவ் வரிசைகளிலும் இதுவே உண்மை. விக்கிப்பீடியாவின் வரையறை இதோ: "ஒரு துணை வரிசை, வரைபடம், குறியீட்டு அட்டவணை அல்லது அகராதி என்பது (விசை, மதிப்பு) ஜோடிகளின் தொகுப்பைக் கொண்ட ஒரு சுருக்க தரவு வகையாகும், அதாவது ஒவ்வொரு சாத்தியமான விசையும் சேகரிப்பில் ஒரு முறை தோன்றும்." இது உங்களுக்கு ஏதாவது நினைவூட்டுகிறதா? :) ஆம். எங்களுக்கு ஜாவா டெவலப்பர்கள், ஒரு துணை வரிசைMapஇடைமுகம். ஆனால் இந்த தரவு கட்டமைப்பு மற்ற மொழிகளிலும் செயல்படுத்தப்படுகிறது! எடுத்துக்காட்டாக, சி# புரோகிராமர்கள் அதை "அகராதி" என்ற பெயரில் அறிவார்கள். மேலும் ரூபியில், இது "ஹாஷ்" என்ற வகுப்பில் செயல்படுத்தப்படுகிறது. சரி, நீங்கள் புள்ளியைப் பெறுகிறீர்கள்: தரவு கட்டமைப்புகள் நிரலாக்கத்தில் உலகளாவிய கருத்துக்கள், மேலும் ஒவ்வொரு நிரலாக்க மொழியும் அவற்றை அதன் சொந்த வழியில் செயல்படுத்துகிறது. இன்று நாம் அத்தகைய இரண்டு கட்டமைப்புகளைப் படிப்போம் - அடுக்கு மற்றும் வரிசை - மற்றும் அவை ஜாவாவில் எவ்வாறு செயல்படுத்தப்படுகின்றன என்பதைப் பார்ப்போம்.

ஜாவாவில் அடுக்குகள்

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

public class Card {

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

   private String name;

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

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

import java.util.Stack;

public class SimpleCardGame {

   // Draw deck
   private Stack<Card> deck;
  
   // Discard pile
   private Stack<Card> discardPile;

   public Card getCardFromDeck() {
       return deck.pop();
   }

   public void discard(Card card) {
       discardPile.push(card);
   }

   public Card lookAtTopCard() {

       return deck.peek();
   }
  
   // ...getters, setters, etc.
}

நாங்கள் முன்பு கூறியது போல், எங்களிடம் இரண்டு அடுக்குகள் உள்ளன: ஒரு டிரா டெக் மற்றும் ஒரு நிராகரிப்பு பைல். ஜாவாவில், அடுக்கு தரவு அமைப்பு வகுப்பில் செயல்படுத்தப்படுகிறது java.util.Stack. எங்கள் அட்டை விளையாட்டில் வீரர்களின் செயல்களை விவரிக்கும் 3 முறைகள் உள்ளன:

• டெக்கிலிருந்து ஒரு அட்டையை எடுக்கவும் ( getCardFromDeck()முறை)
• ஒரு அட்டையை நிராகரிக்கவும் ( discard()முறை)
• மேல் அட்டையைப் பாருங்கள் ( lookAtTopCard()முறை). இது ஒரு "புலனாய்வு" போனஸ் என்று வைத்துக்கொள்வோம், இது விளையாட்டில் அடுத்ததாக எந்த அட்டை வரும் என்பதைக் கண்டறிய பிளேயரை அனுமதிக்கிறது.

எங்கள் முறைகளுக்குள், ஸ்டாக் வகுப்பின் பின்வரும் முறைகளை நாங்கள் அழைக்கிறோம்:

• push()- அடுக்கின் மேல் ஒரு பொருளைச் சேர்க்கிறது. நாம் டிஸ்கார்ட் பைலுக்கு ஒரு கார்டை அனுப்பும்போது, ​​அது பைலின் உச்சிக்கு செல்கிறது
• pop()— அடுக்கிலிருந்து மேல் உறுப்பை அகற்றி, அதைத் திருப்பித் தருகிறது. வீரர் ஒரு அட்டையை வரையும் செயல்களைச் செயல்படுத்த இந்த முறை சரியானது.
• peek()— அடுக்கின் மேல் உறுப்பு திரும்பும், ஆனால் அதை அடுக்கிலிருந்து அகற்றாது

எங்கள் ஆட்டம் எப்படி செயல்படும் என்று பார்ப்போம்:

import java.util.Stack;

public class Main3 {

   public static void main(String[] args) {

       // Create a deck and add cards to it
       Stack<Card> deck = new Stack<>();
       deck.push(new Card("Ragnaros"));
       deck.push(new Card("Patches the Pirate"));
       deck.push(new Card("Sylvanas Windrunner"));
       deck.push(new Card("Millhouse Manastorm"));
       deck.push (new Card ("Edwin VanCleef"));

       // Create the discard pile
       Stack<Card> discardPile = new Stack<>();

       // Start the game
       SimpleCardGame game = new SimpleCardGame();
       game.setDeck(deck);
       game.setDiscardPile(discardPile);

       // The first player draws 3 cards from the deck
       Card card1 = game.getCardFromDeck();
       Card card2 = game.getCardFromDeck();
       Card card3 = game.getCardFromDeck();

       System.out.println("Which cards went to the first player?");
       System.out.println(card1);
       System.out.println(card2);
       System.out.println(card3);

       // The first player discards 3 of his cards
       game.discard(card1);
       game.discard(card2);
       game.discard(card3);

       System.out.println("What cards are in the discard pile?");
       System.out.println(game.getDiscardPile().pop());
       System.out.println(game.getDiscardPile().pop());
       System.out.println(game.getDiscardPile().pop());
   }
}

எங்கள் டெக்கில் ஐந்து அட்டைகளைச் சேர்த்துள்ளோம். முதல் வீரர் அவர்களில் 3 ஐ எடுத்தார். அவள் எந்த அட்டைகளைப் பெற்றாள்? கன்சோல் வெளியீடு:

Card{name='Edwin VanCleef"}
Card{name='Millhouse Manastorm'}
Card{name='Sylvanas Windrunner'}

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

Card{name='Sylvanas Windrunner'}
Card{name='Millhouse Manastorm'}
Card{name='Edwin VanCleef"}

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

ஜாவாவில் வரிசை

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

All known subinterfaces

BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E>

All known implementing classes

AbstractQueue, ArrayBlockingQueue, ArrayDeque

ConcurrentLinkedDeque, ConcurrentLinkedQueue, DelayQueue

LinkedBlockingDeque, LinkedBlockingQueue, LinkedList, LinkedTransferQueue

PriorityBlockingQueue, PriorityQueue, SynchronousQueue

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

LinkedBlockingDeque, LinkedBlockingQueue, LinkedList, LinkedTransferQueue

ஹா! இதோ எங்கள் பழைய நண்பர் LinkedList! எனவே, இது வரிசை இடைமுகத்தை செயல்படுத்துகிறதா? ஆனால் அது எப்படி வரிசையாக இருக்க முடியும்? எல்லாவற்றிற்கும் மேலாக, ஒரு LinkedListஇணைக்கப்பட்ட பட்டியல்! உண்மை, ஆனால் அது வரிசையாக இருப்பதைத் தடுக்காது :) இது செயல்படுத்தும் அனைத்து இடைமுகங்களின் பட்டியல் இங்கே:

All implemented interfaces:

Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>

நீங்கள் பார்க்க முடியும் என, இடைமுகத்தை LinkedListசெயல்படுத்துகிறது Deque(மீண்டும், இதன் பொருள் இரட்டை முனை வரிசை). இது ஏன் தேவை? இதன் மூலம் a இன் ஆரம்பம் மற்றும் முடிவிலிருந்து உறுப்புகளைப் பெற முடியும் LinkedList. ஆரம்பம் மற்றும் முடிவில் கூறுகளைச் சேர்க்க இது அனுமதிக்கிறது. LinkedListஇடைமுகத்திலிருந்து கிடைக்கும் முறைகள் இங்கே Deque:

• peekFirst()— முதல் உறுப்பைத் தருகிறது (ஆனால் அதை வரிசையில் இருந்து அகற்றாது).
• peekLast()— கடைசி உறுப்பைத் தருகிறது (ஆனால் அதை வரிசையில் இருந்து அகற்றாது).
• pollFirst()— வரிசையில் இருந்து முதல் உறுப்பு திரும்ப மற்றும் அதை நீக்குகிறது.
• pollLast()- வரிசையில் இருந்து கடைசி உருப்படியை திருப்பி அதை நீக்குகிறது.
• addFirst()- வரிசையின் முன் ஒரு புதிய உருப்படியைச் சேர்க்கிறது.
• addLast()- வரிசையின் முடிவில் ஒரு பொருளைச் சேர்க்கிறது.

நீங்கள் பார்க்க முடியும் என, LinkedListஇரட்டை முனை வரிசையின் செயல்பாட்டை முழுமையாக செயல்படுத்துகிறது! உங்கள் திட்டத்தில் அத்தகைய செயல்பாடு உங்களுக்குத் தேவை, அதை எங்கு கண்டுபிடிப்பது என்பது உங்களுக்குத் தெரியும் :) இன்றைய பாடம் முடிவுக்கு வருகிறது. முடிவில், கூடுதல் வாசிப்புக்கு இரண்டு இணைப்புகளைத் தருகிறேன். முதலில், PriorityQueue பற்றிய இந்தக் கட்டுரையில் கவனம் செலுத்துங்கள் . இது மிகவும் சுவாரஸ்யமான மற்றும் பயனுள்ள செயலாக்கங்களில் ஒன்றாகும் Queue. உதாரணமாக, உங்கள் கடையில் 50 பேர் வரிசையில் காத்திருக்கிறார்கள், அவர்களில் 7 பேர் விஐபி வாடிக்கையாளர்கள் என்று வைத்துக்கொள்வோம். முன்னுரிமை வரிசை முதலில் அவர்களுக்கு சேவை செய்ய உங்களை அனுமதிக்கும்! மிகவும் பயனுள்ள விஷயம், இல்லையா? :) இரண்டாவதாக, ராபர்ட் லாஃபோரின் புத்தகமான "ஜாவாவில் தரவு கட்டமைப்புகள் மற்றும் வழிமுறைகள்" பற்றி மீண்டும் ஒருமுறை குறிப்பிடுவது வலிக்காது.. இந்தப் புத்தகத்தைப் படிப்பதன் மூலம், நீங்கள் பல தரவுக் கட்டமைப்புகளை (ஸ்டாக் மற்றும் வரிசை உட்பட) கற்றுக்கொள்வது மட்டுமல்லாமல், அவற்றில் பலவற்றை நீங்களே செயல்படுத்துவீர்கள்! எடுத்துக்காட்டாக, ஜாவாவில் ஸ்டாக் கிளாஸ் இல்லையென்றால் என்ன செய்வது? உங்கள் நிரலுக்கு அத்தகைய தரவு அமைப்பு தேவைப்பட்டால் நீங்கள் என்ன செய்வீர்கள்? நிச்சயமாக, அதை நீங்களே எழுத வேண்டும். நீங்கள் லாஃபோரின் புத்தகத்தைப் படிக்கும்போது , ​​நீங்கள் அடிக்கடி அதைச் செய்வீர்கள். இதன் விளைவாக, தரவு கட்டமைப்புகள் பற்றிய உங்கள் புரிதல் கோட்பாட்டின் ஒரு எளிய ஆய்வில் இருந்து நீங்கள் பெறுவதை விட மிகவும் ஆழமாக இருக்கும் :) நாங்கள் இன்று கோட்பாட்டை முடிக்கிறோம், ஆனால் நடைமுறையில் இல்லாத கோட்பாடு ஒன்றும் இல்லை! பணிகள் தானாகவே தீர்க்கப்படாது, எனவே அவற்றைச் சமாளிக்க வேண்டிய நேரம் இது! :)