Implementing ArrayList class manually

[Campbell Ritchie]

Winston Gutkowski wrote: . . . Blimey. The thread that refuses to die. . . .

But think how much he will learn if he ever finishes this class.

[Campbell Ritchie]

Winston Gutkowski wrote: . . . Blimey. The thread that refuses to die. . . .

Blimey. Page 3.

And no girls in sight

[Mansukhdeep Thind]

Campbell Ritchie wrote:

Winston Gutkowski wrote: . . . Blimey. The thread that refuses to die. . . .

But think how much he will learn if he ever finishes this class.

Forgive me for today guys. Went for a 10 km run. Will provide you the update tomorrow. I know it improving the add(T) method and reducing it to 2 lines has something to do with the ternary operator. Just wait till tomorrow.

[Mansukhdeep Thind]

Campbell Ritchie wrote:

Winston Gutkowski wrote: . . . Blimey. The thread that refuses to die. . . .

Blimey. Page 3.

And no girls in sight

Now what is this supposed to mean? What is the relation between page 3 and girls?

[Campbell Ritchie]

NSFW: Everybody in Britain knows about this sort of thing.

[Mansukhdeep Thind]

Campbell Ritchie wrote:Now we’re getting somewhere

Mansukhdeep Thind wrote: . . . /**
* @throws exception - {@link ArrayIndexOutOfBoundsException}
*/ . . .

Change that to read @throws IndexOutOfBoundsException if index < 0 or index > current size.
Similarly for other @throws tags. You need to quote the class of the Exception immediately after the tag. You should check whether I have got that right here.

Look at your add(T) method. That can be simplified no end; you can actually reduce it to two statements, and use much simpler if statement. Why are you casting the element? When you have simplified that add method, you can similarly simplify the add(int, T) method.

And there is more to come.

I changed the add(T) method to :

public final boolean add(T object) {

		/*if(size>=(values.length-1)){			
			// call the growArray method to copy existing contents
			this.growArray();			
		}*/
		values[size]=(size++>=values.length-1)?this.growArray():object;		
		return true;

	}

Am I on correct track? There is a flaw though. Every time the condition evaluates to true, that index has a null value. How to assign the value and grow the array at same time , while also adhering to your order of writing it in 2 lines.

[Campbell Ritchie]

Mansukhdeep Thind wrote: . . . Am I on correct track? . . .

No.

[Campbell Ritchie]

I often tell students, these things are a lot simpler than you think. You can simplify that add method and make it look elegant and short and concise. But you need to relax and work out what you really need in that method. And I said two statements, not two lines.

[Campbell Ritchie]

If you include return true; make that three statements.

[Mansukhdeep Thind]

Campbell Ritchie wrote:I often tell students, these things are a lot simpler than you think. You can simplify that add method and make it look elegant and short and concise. But you need to relax and work out what you really need in that method. And I said two statements, not two lines.

What I need is to add the element at index position = size. And if size becomes equal to 1 less than current capacity grow it and then add the element. That is what I am doing. How to achieve that using ternary operator? And what simpler if statement can ther possibly be. We have to check

if(size>=length-1)

. How else do you propose I should decide to grow() it?

[Campbell Ritchie]

You have already said under which circumstances you need to enlarge the array. Go back a page and you will find it.

[Mansukhdeep Thind]

Campbell Ritchie wrote:You have already said under which circumstances you need to enlarge the array. Go back a page and you will find it.

Mansukhdeep Thind wrote: Also done. The array should grow when the size of the current list becomes == its capacity.

Got it.

[Mansukhdeep Thind]

Here you go Campbell:

The add(T ) method :

/**
	 * Adds an element to the end of the list
	 * @param object - element to be added
	 * @return - true if the collection changed as a result to this call
	 */
public final boolean add(T object) {

		if(size==values.length){		
			this.growArray();	
		}
		values[size++]=object;		
		return true;

	}

and the add(int,T) method is as follows:

/**
	 * Adds a specific element at a specified position in the list. Moves the element at that particular location 
	 * one index to the right i.e adds 1 to the indices of all elements to the right of element inserted at indexPos
	 * @param indexPos - index at which element is to be inserted, should not be less than 0 or greater than current size
	 * @param object - element to be inserted
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or more that capacity
	 */
	public final void add(int indexPos, T object){

		if(size==values.length){
			this.growArray();
		}

		if(indexPos>0 && indexPos<=size){
			for(int i=size;i>indexPos;i--){
				values[i] = values[i-1];
			}
			values[indexPos] = object;
			size++;
		}		
		else{
			System.out.println("Index passed must be between 0 and current size");
			throw new IndexOutOfBoundsException();

		}

	}

Is this what you were expecting of me? Is it elegant enough to your British standards now? Or is it still too Indian for your liking?

[Campbell Ritchie]

Mansukhdeep Thind wrote:Here you go Campbell:

The add(T ) method :

/**
	 * Adds an element to the end of the list
	 * @param object - element to be added
	 * @return - true if the collection changed as a result to this call
	 */
public final boolean add(T object) {

		if(size==values.length){		
			this.growArray();	
		}
		values[size++]=object;		
		return true;

	}

. . .

Yes, yes, yes

[Campbell Ritchie]

You can elide the size++; line in add(int, T) similarly. In add(int, T), throw the Exception at the beginning of the method.

[Mansukhdeep Thind]

Campbell Ritchie wrote:You can elide the size++; line in add(int, T) similarly. In add(int, T), throw the Exception at the beginning of the method.

Here is the improved add(int,T) method Campbell:

/**
	 * Adds a specific element at a specified position in the list. Moves the element at that particular location 
	 * one index to the right i.e adds 1 to the indices of all elements to the right of element inserted at indexPos
	 * @param indexPos - index at which element is to be inserted, should not be less than 0 or greater than current size
	 * @param object - element to be inserted
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or more that capacity
	 */
	public final void add(int indexPos, T object){

		if(indexPos>size || indexPos<0){
			System.out.println("Index passed must be between 0 and current size");
			throw new IndexOutOfBoundsException();

		}
		if(size==values.length){
			this.growArray();
		}

		if(indexPos>0 && indexPos<=size){
			for(int i=size++;i>indexPos;i--){
				values[i] = values[i-1];
			}
			values[indexPos] = object;		
		}

	}

Why do you insist in throwing the exception at the beginning? So, that it does not have to interpret extra if() statements?

Learned a new word , elide.

[Campbell Ritchie]

You throw the Exception early in the method because it is obvious to readers what is happening. You can still improve that method, however. I can see two things I would alter, possibly three.
You are saying that you can add something at index 2 if the List contains "Campbell" "Manskukhdeep" only, in the documentation.

[Mansukhdeep Thind]

Campbell Ritchie wrote:You throw the Exception early in the method because it is obvious to readers what is happening. You can still improve that method, however. I can see two things I would alter, possibly three.
You are saying that you can add something at index 2 if the List contains "Campbell" "Manskukhdeep" only, in the documentation.

/**
	 * Adds a specific element at a specified position in the list. Moves the element at that particular location 
	 * one index to the right i.e adds 1 to the indices of all elements to the right of element inserted at indexPos
	 * @param indexPos - index at which element is to be inserted, should not be less than 0 or greater than current size
	 * @param object - element to be inserted
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or more that size
	 */
	public final void add(int indexPos, T object){

		if(indexPos>size || indexPos<0){
			System.out.println("Index passed must be between 0 and current size");
			throw new IndexOutOfBoundsException();

		}
		else if(size==values.length){
			this.growArray();
		}

		for(int i=size++;i>indexPos;i--){
			values[i] = values[i-1];
		}
		values[indexPos] = object;		


	}

Here is a shortened version. Anything else that can be chucked out?

[Jeff Verdegan]

if(indexPos>size || indexPos<0){
System.out.println("Index passed must be between 0 and current size");
throw new IndexOutOfBoundsException();

}

If you were writing this as a real library class that you expected to be used in multiple applications, possibly by people other than yourself, you wouldn't want to be calling System.out.println() anywhere in your code.

When throwing an exception, you should include useful information about what was expected and what happened instead, to aid debugging:

throw new IndexOutOfBoundsException("index was " + indexPos + ", size is " + size);

Also, these are more subjective, but personally, I hate seeing unnecessary uses of "this":

        else if(size==values.length){  
            this.growArray();  // YUCK! Just call growArray(), no "this"

And more standard whitespace around binary operators and between the pieces of the for loop header and between the closing paren and opening brace will make it easier to read:

        for(int i=size++;i>indexPos;i--){    // Ick.
        for(int i = size++; i > indexPos; i--) {    // Better.

[Campbell Ritchie]

Maybe you should throw an ArrayIndexOutOfBoundsException.
I was a little worried about the size++ in an unusual place. Risk of confusion. I would have put it after the loop.
myArray[size++] = ...; // Well‑recognised usage, but can be confusing to beginners
for (int i = size++; i > index; i--) {...} // Unusual usage, and potential cause for confusion.

Passing the message to the exception constructor, as Jeff showed you, that was the other thing I saw.

[Mansukhdeep Thind]

Here you go Campbell/Jeff:

/**
	 * Adds a specific element at a specified position in the list. Moves the element at that particular location 
	 * one index to the right i.e adds 1 to the indices of all elements to the right of element inserted at indexPos
	 * @param indexPos - index at which element is to be inserted, should not be less than 0 or greater than current size
	 * @param object - element to be inserted
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or more that size
	 */
	public final void add(int indexPos, T object){

		if(indexPos > size || indexPos < 0){			
			throw new IndexOutOfBoundsException("index provided was" + indexPos + "size is" + size);

		}
		else if(size == values.length){
			growArray();
		}

		for(int i = size; i > indexPos; i--){
			values[i] = values[i-1];
		}
		values[indexPos] = object;		

		size++;

	}

Looks prefect now?

[Mansukhdeep Thind]

Jeff Verdegan wrote:

if(indexPos>size || indexPos<0){
System.out.println("Index passed must be between 0 and current size");
throw new IndexOutOfBoundsException();

}

If you were writing this as a real library class that you expected to be used in multiple applications, possibly by people other than yourself, you wouldn't want to be calling System.out.println() anywhere in your code.

When throwing an exception, you should include useful information about what was expected and what happened instead, to aid debugging:

throw new IndexOutOfBoundsException("index was " + indexPos + ", size is " + size);

Also, these are more subjective, but personally, I hate seeing unnecessary uses of "this":

        else if(size==values.length){  
            this.growArray();  // YUCK! Just call growArray(), no "this"

And more standard whitespace around binary operators and between the pieces of the for loop header and between the closing paren and opening brace will make it easier to read:

        for(int i=size++;i>indexPos;i--){    // Ick.
        for(int i = size++; i > indexPos; i--) {    // Better.

Thank you Jeff. You just made me happy by correcting me, unknowingly though.

[Campbell Ritchie]

Getting better all the time
Now let’s see a remove method.

[Mansukhdeep Thind]

Campbell Ritchie wrote:Getting better all the time
Now let’s see a remove method.

As long as you guys are present to teach me the right things the right way, this shall continue. I will become better and better at this. It is 35 degrees centigrade out there and I am going for a bike ride. An easy paced 3-4 hour work out. Will revert back after that.

[Campbell Ritchie]

Mansukhdeep Thind wrote: . . . An easy paced 3-4 hour work out. . . .

So about 50 miles?

[Mansukhdeep Thind]

No, the route has climbs ranging from 3-4 % to 7-8 % at places. More of a strength oriented workout. It ends up with the cyclometer tripping at 50 km not 50 miles. When I go for a route which is flat, I do at least 80-100 km. By the way, you are British, then why miles and not km?

[Campbell Ritchie]

Kilometers are French

[Mansukhdeep Thind]

Campbell Ritchie wrote:Kilometers are French

Something personal against the French it seems?

[Mansukhdeep Thind]

Campbell Ritchie wrote:Getting better all the time
Now let’s see a remove method.

Here you go Campbell:

/**
	 * Removes the element at the specified index position,if any, and
	 * shifts the elements to the right of that index one place to the left
	 * i.e. subtracts 1 from the indices of all elements to right of element at indexPos
	 * @param indexPos - index position of element to be removed
	 * @return - element removed from the list
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or greater than size of the list
	 */
	public final T remove(int indexPos){
		if(indexPos > size || indexPos < 0){			
			throw new IndexOutOfBoundsException("index provided was" + indexPos + "size is" + size);
		}
		else if(indexPos > 0 && indexPos < size && values[indexPos] != null){
			T temp = (T)values[indexPos];
			for(int i = indexPos; i < size; i++){
				values[i] = values[i+1];
			}
			size--;	
			return temp;
		}
		return null;		

	}

Is that OK? Or can it be further improved upon?

[Campbell Ritchie]

There is a pitfall which you have fallen into. I would have fallen into it myself, had I not read Joshua Bloch’s Effective Java™ (2/e) page 24. (In the first edition it is page 16.)

[Campbell Ritchie]

You have duplicated code in those add and remove methods. That should be refactored into a separate private method.

[Mansukhdeep Thind]

Campbell Ritchie wrote:There is a pitfall which you have fallen into. I would have fallen into it myself, had I not read Joshua Bloch’s Effective Java™ (2/e) page 24. (In the first edition it is page 16.)

Rectified the duplicated code part:

/**
	 * Removes the element at the specified index position,if any, and
	 * shifts the elements to the right of that index one place to the left
	 * i.e. subtracts 1 from the indices of all elements to right of element at indexPos
	 * @param indexPos - index position of element to be removed
	 * @return - element removed from the list
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or greater than size of the list
	 */
	public final T remove(int indexPos){
		ensureCorrectIndex(indexPos);
		if(indexPos >= 0 && indexPos < size && values[indexPos] != null){
			T temp = (T)values[indexPos];
			for(int i = indexPos; i < size; i++){
				values[i] = values[i+1];
			}

			size--;	
			return temp;
		}
		return null;		

	}

Here is the private method for validating the index:

/**
	 * Checks if the index passed to the add(int,T) and remove(int) methods
	 * is correct or not. A correct index should not be less than 0 or greater than
	 * the size of the list 
	 * @param indexPos - index which is to be checked
	 */
	private final void ensureCorrectIndex(int indexPos){
		if(indexPos >= size || indexPos < 0){			
			throw new IndexOutOfBoundsException("index provided was " + indexPos + " size is " + size);

		}
	}

Now back to your point about Joshua Bloch's rule of thumb regarding obsolete object references - It talks about eliminating obsolete object references by explicitly setting them to null. He says that any elements outside the active portion of the array are are termed as obsolete references. Active portion of the array means elements having their index less than size of the array. I do not understand where is the reference that has become obsolete in my remove(int) method. Any elements outside the active portion of the array are automatically becoming null when the loop inside the remove(int) method runs. Correct? Or is it the variable temp that you are hinting at?

[Campbell Ritchie]

Why have you got the if inside the method still? Why are you checking for != null when removing? If you are not permitting nulls at this stage, why are you permitting users to add them in the add methods?
The temp variable is a local variable which goes out of scope when that method completes.
Write down the structure of your List after you add a few elements and remove one:

CustomList myList = new CustomList(4);
myList.add("Campbell");
myList.add("Ritchie");
myList.add("Mansukhdeep");
myList.add("Thind");
myList.remove(1);

[Mansukhdeep Thind]

Campbell Ritchie wrote:Why have you got the if inside the method still? Why are you checking for != null when removing? If you are not permitting nulls at this stage, why are you permitting users to add them in the add methods?
The temp variable is a local variable which goes out of scope when that method completes.
Write down the structure of your List after you add a few elements and remove one:

CustomList myList = new CustomList(4);
myList.add("Campbell");
myList.add("Ritchie");
myList.add("Mansukhdeep");
myList.add("Thind");
myList.remove(1);

Here are the updated add(int), add(int,T) , remove(int) and the utility methods:

/**
	 * Adds an element to the end of the list
	 * @param object - element to be added, should not be null
	 * @return - true if the collection changed as a result to this call
	 * @throws Exception - if the element is null
	 */


	public final boolean add(T object) throws Exception {
		ensureNonNullElement(object);
		if(size==values.length){		
			growArray();	
		}
		if(object!=null){
			values[size++]=object;
		}
		return true;

	}

	/**
	 * Adds a specific element at a specified position in the list. Moves the element at that particular location 
	 * one index to the right i.e adds 1 to the indices of all elements to the right of element inserted at indexPos
	 * @param indexPos - index at which element is to be inserted, should not be less than 0 or greater than current size
	 * @param object - element to be inserted
	 * @throws Exception - if the element is null
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or more that size
	 */
	public final void add(int indexPos, T object) throws Exception{
		ensureNonNullElement(object);
		ensureCorrectIndex(indexPos);

		if(size == values.length){
			growArray();
		}

		for(int i = size; i > indexPos; i--){
			values[i] = values[i-1];
		}
		values[indexPos] = object;		

		size++;

	}
/**
	 * Removes the element at the specified index position,if any, and
	 * shifts the elements to the right of that index one place to the left
	 * i.e. subtracts 1 from the indices of all elements to right of element at indexPos
	 * @param indexPos - index position of element to be removed
	 * @return - element removed from the list
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or greater than size of the list
	 */
	public final T remove(int indexPos){
		ensureCorrectIndex(indexPos);
		
			T temp = (T)values[indexPos];
			for(int i = indexPos; i < size; i++){
				values[i] = values[i+1];
			}

			size--;	
			return temp;			

	}
	
	/**
	 * Checks if the element being added is a valid non-null
	 * value or not.
	 * @param object - Element to be added to list
	 * @throws Exception - if object is a null
	 */

	private final void ensureNonNullElement(T object) throws Exception{
		if(object==null){
			throw new Exception("element is " + object + " it should be non-null");
		}
	}

	/**
	 * Checks if the index passed to the add(int,T) and remove(int) methods
	 * is correct or not. A correct index should not be less than 0 or greater than
	 * the size of the list 
	 * @param indexPos - index which is to be checked
	 */
	private final void ensureCorrectIndex(int indexPos){		
		if(indexPos >= size || indexPos < 0){			
			throw new IndexOutOfBoundsException("index provided was " + indexPos + " size is " + size);

		}
	}

If it is not a problem with the temp variable, then what is the issue? I tried doing what you asked me to, i.e.:

myList.add(5);  
		myList.add(3);
		myList.add(34);  
		myList.add(6);  

output is :

Size of list is 4
Capacity of list is 10
At index position :0 5
At index position :1 3
At index position :2 34
At index position :3 6


and after I do this:

myList.add(5);  
		myList.add(3);
		myList.add(34);  
		myList.add(6);  
		
		myList.remove(2);

output is :

Size of list is 3
Capacity of list is 10
At index position :0 5
At index position :1 3
At index position :2 6

What's wrong with this? All the elements beyond the size are null. So where is the problem that Joshua is talking about obsolete object references in the active array?

[Campbell Ritchie]

You have changed the class’ general contract. You used to permit null values and you don’t any more. Both options are valid, but you must decide which is correct and which you are using.
Don’t use a plain simple Exception. If you are going to thrown an Exception, try NullPointerException. Also that way, you are throwing an unchecked Exception, which is appropriate for incorrect arguments.
You have changed the return type of add(int, T); it used to be boolean, and it is now void (at least I think it was). I would have thought boolean as you used to have is better.
Why are you casting the elements in the array to (T)?
Have you printed out the no 3 element in the array? You are only printing up to < size. What happens when you print up to <= size?

You have tried to change too many things all at once. By doing so, you have messed up some things which used to work

[Jeff Verdegan]

Campbell Ritchie wrote:If you are going to thrown an Exception, try NullPointerException.

I prefer IllegalArgumentException. Either one is valid, and it really comes down to personal preference. I prefer to let NPE only be thrown when a null pointer is actually dereferenced (or when I call into a library that throws it in situations like this, which I can't control ). I think IAE is more descriptive of what went wrong here. The fact that the argument was null doesn't make it an NPE, IMHO. Again, though, totally subjective. Pick whichever one you think fits better. The key points are that it should be more descriptive than Exception and it should be an unchecked exception.

[Mansukhdeep Thind]

Campbell Ritchie wrote:You have changed the class’ general contract. You used to permit null values and you don’t any more. Both options are valid, but you must decide which is correct and which you are using.

I want to disallow null elements. I will be sticking to that.

Campbell Ritchie wrote:Don’t use a plain simple Exception. If you are going to thrown an Exception, try NullPointerException. Also that way, you are throwing an unchecked Exception, which is appropriate for incorrect arguments.

OK.

Campbell Ritchie wrote:You have changed the return type of add(int, T); it used to be boolean, and it is now void (at least I think it was). I would have thought boolean as you used to have is better.

I have made it like Joshua Bloch's ArrayList's add(int,T) method. That also has return type as void. Why do you think boolean is better?

Campbell Ritchie wrote:Why are you casting the elements in the array to (T)?

Otherwise it is a compile time error.

Campbell Ritchie wrote:Have you printed out the no 3 element in the array? You are only printing up to < size. What happens when you print up to <= size?

No. 3 element prints as null after removing the 3rd element. What are you getting at?

You have tried to change too many things all at once. By doing so, you have messed up some things which used to work

[Campbell Ritchie]

Mansukhdeep Thind wrote: . . .

No. 3 element prints as null after removing the 3rd element. What are you getting at?
. . .

You are right. By using i + 1 you have correctly copied the null in no 3 to no 2, so you are not getting the memory leak. I was mistaken about that. Sorry.

Are you sure there is no chance that you will get an array out of bounds exception from remove(int) if size == values.length?
If you are using void return type for add(), then change both add methods to the same return type. Then you can reduce add(T) to the dreaded two statements.
You either have to cast the array when you create it, or cast each element as you extract it from the array. I would prefer the former, but java.util.ArrayList prefers the latter approach.

[Mansukhdeep Thind]

Jeff Verdegan wrote:

Campbell Ritchie wrote:If you are going to thrown an Exception, try NullPointerException.

I prefer IllegalArgumentException. Either one is valid, and it really comes down to personal preference. I prefer to let NPE only be thrown when a null pointer is actually dereferenced (or when I call into a library that throws it in situations like this, which I can't control ). I think IAE is more descriptive of what went wrong here. The fact that the argument was null doesn't make it an NPE, IMHO. Again, though, totally subjective. Pick whichever one you think fits better. The key points are that it should be more descriptive than Exception and it should be an unchecked exception.

I will go for IllegalArgumentException.

[Mansukhdeep Thind]

Campbell Ritchie wrote:

Mansukhdeep Thind wrote: . . .

No. 3 element prints as null after removing the 3rd element. What are you getting at?
. . .

You are right. By using i + 1 you have correctly copied the null in no 3 to no 2, so you are not getting the memory leak. I was mistaken about that. Sorry.

No problem Campbell. Everyone makes mistakes, even Britishers.

Campbell Ritchie wrote:Are you sure there is no chance that you will get an array out of bounds exception from remove(int) if size == values.length?

You are correct. I am getting this IndexOutOfBoundsException when trying to remove the element when size==values.length. Hence, I was using the size==values.length-1 condition to grow the array rather than size==values.length. Here are the rectified add(int), add(int,T), ensureCorrectIndex(int) methods:

/**
	 * Adds an element to the end of the list
	 * @param object - element to be added, should not be null
	 * @return - true if the collection changed as a result to this call
	 * @throws IllegalArgumentException - if the element being passes is null
	 */


	public final boolean add(T object) throws IllegalArgumentException {
		ensureNonNullElement(object);
		if(size==values.length-1){		
			growArray();	
		}
		if(object!=null){
			values[size++]=object;
		}
		return true;

	}

	/**
	 * Adds a specific element at a specified position in the list. Moves the element at that particular location 
	 * one index to the right i.e adds 1 to the indices of all elements to the right of element inserted at indexPos
	 * @param indexPos - index at which element is to be inserted, should not be less than 0 or greater than current size
	 * @param object - element to be inserted
	 * @throws IllegalArgumentException - if the element being added is null
	 * @throws IndexOutOfBoundsException if indexPos is less than 0 or more that size
	 */
	public final void add(int indexPos, T object) throws IllegalArgumentException{
		
		ensureNonNullElement(object);
		
		ensureCorrectIndex(indexPos);

		if(size == values.length-1){
			growArray();
		}

		for(int i = size; i > indexPos; i--){
			values[i] = values[i-1];
		}
		values[indexPos] = object;		

		size++;

	}
/**
	 * Checks if the index passed to the add(int,T) and remove(int) methods
	 * is correct or not. A correct index should not be less than 0 or greater than
	 * the size of the list 
	 * @param indexPos - index which is to be checked
	 */
	private final void ensureCorrectIndex(int indexPos){		
		if(indexPos > size || indexPos < 0){			
			throw new IndexOutOfBoundsException("index provided was " + indexPos + " size is " + size);

		}
	}

Campbell Ritchie wrote:If you are using void return type for add(), then change both add methods to the same return type. Then you can reduce add(T) to the dreaded two statements.

But Joshua does it like this in his implementation of java.util.ArrayList. See here. Why do you say both methods should have the same return type? How do we decide what return type a method should have? I am merely following Joshua. But what is the logic that we use for deciding return types when we are dealing methods which could make do with either void or boolean return types?

Campbell Ritchie wrote:You either have to cast the array when you create it, or cast each element as you extract it from the array. I would prefer the former, but java.util.ArrayList prefers the latter approach.

You mean to say when either in the overloaded constructor OR as and when I do values[indexPos]?