Implementing ArrayList class manually

[Mansukhdeep Thind]

I was asked in an interview that how would I go about implementing the functionality that the current java.util.ArrayList class provides (like add, remove, indexOf, get(int) etc..). I was stumped and did not know what to say. Could someone give me some hint as to how to go about this task? I shall try and figure out the rest.

[Akhilesh Trivedi]

Are you allowed to use arrays or no?

[Mansukhdeep Thind]

He said assume that Collections are not available in Java. You can use arrays. How will you go about creating a growable array which can do all the things an ArrayList can?

[Akhilesh Trivedi]

Mansukhdeep Thind wrote:How will you go about creating a growable array which can do all the things an ArrayList can?

You will have to manually grow the array with new size and do a copy.

[Abhay Agarwal]

Hi Mansukhdeep

It is very well possible to write basic ArrayList implementation using Array class.
Arraylist is basically an auto growable collection of elements where in size of arraylist grows automatically. And also you can provide add/delete/modify array list elements.
So you just need to use Array to create a auto growable ArrayList

Just to give your starting point, below mentioned is the CustomArrayList class which is being initialized in constructor. You can furthur build CustomArrayList to increase size at runtime and can also add insertion/deletion methods

for example -

class CustomArrayList {

private static final sizeratio=10;
private Object[] objectArray;
private int currentSize;

public CustomArrayList() {
// now initializes elements
this.objectArray = new Object[sizeratio];
this.currentSize = sizeratio;
}

~abhay

[Campbell Ritchie]

I can see several ways you can improve that class. Apart from the poor formatting, that is.

[Mansukhdeep Thind]

It is very well possible to write basic ArrayList implementation using Array class.

Which Array class? In the java.lang.reflect package? How is that going to help? Or do you mean by using the concept of creating a generic Object[] array? How does one make an array grow dynamically as and when elements are added to it? In Java language, arrays are defined as containers with a fixed size.

[Abhay Agarwal]

Which Array class? In the java.lang.reflect package?

By Array class, I meant Array of Objects (like I have shown in my previous post in this thread). No Reflection API.

How is that going to help? Or do you mean by using the concept of creating a generic Object[] array?

If you do not want to hard code /use Object class (probably because at runtime, your CustomArrayList can contains elements of different types such as - String, Integer etc) then you can use Generic declaration in your CustomArrayList. for example -

class CustomArrayList<T>{  
  
private static final sizeratio=10;  
private T[] objectArray;  
private int currentSize;  
  
public CustomArrayList() {  
// now initializes elements  
this.objectArray = new T[sizeratio];  
this.currentSize = sizeratio;  
} 

How does one make an array grow dynamically as and when elements are added to it? In Java language, arrays are defined as containers with a fixed size.

Yes you are correct - In Java language, arrays are defined as containers with a fixed size. Just give a thought ... otherwise I shall post a pseudo code of it in this forum thread.

~abhay

[Mansukhdeep Thind]

Ok Abhay. I will try and work at it. One thing. What is the "sizeratio" for? What does it represent?

[Campbell Ritchie]

Mansukhdeep Thind wrote:. . . What is the "sizeratio" for? . . .

I think it is the less severe of the two errors I can see

[Mansukhdeep Thind]

I think it is the less severe of the two errors I can see

Hmm.. I am trying without referring to any other sources Ritchie. Why do you term this as an error? We have to start with some size. Then as we add elements, we have to increase the size proportionately. Correct?

[Abhay Agarwal]

@Campbell - I shall be more than happy to know two errors that you forsee it this code.
My take is that you are probably referring to synchronization issues in my above code.

sizeratio is number by which arraylist size is initialized.

~ abhay

[Winston Gutkowski]

Abhay Agarwal wrote:sizeratio is number by which arraylist size is initialized.

Then why not call it 'initialSize'?

This is one of the problems with posting ready-made solutions - quite apart from being against the ethos of this site, they WILL be critiqued.

@Mansukhdeep: Unfortunately, we don't really have enough information about this interview question: ie, Precisely what they wanted your "CustomArrayList" class to be able to do.

If it was simply an exercise in understanding how to build an outwardly "dynamic" array, I suspect you already have the understanding to do that - all you need to know is when you need to resize it.

The real problem is that ArrayList implements the List interface; and that has a pile of stuff - including two types of Iterator - that are likely to present you with a lot more problems than just the business of when and how to resize an array.

Winston

[Mansukhdeep Thind]

@Mansukhdeep: Unfortunately, we don't really have enough information about this interview question: ie, Precisely what they wanted your "CustomArrayList" class to be able to do.

He asked me to design a custom class similar to ArrayList which:

a) When instantiated, would result in creation of reference to an array of objects which would grow dynamically as and when elements are added to it.

b) I should implement add and remove functionality given the index or the element.

c) I should be able to find the index of the element provided.

all you need to know is when you need to resize it.

I believe I need to re-size it whenever I am adding a new element. Correct?

The real problem is that ArrayList implements the List interface; and that has a pile of stuff - including two types of Iterator - that are likely to present you with a lot more problems than just the business of when and how to resize an array

Let me go step by step. Let me successfully implement the first three basic requirements. Then we can move the more complicated stuff.

I will try now. Will come back if I am stuck somewhere.

[Winston Gutkowski]

Mansukhdeep Thind wrote:I believe I need to re-size it whenever I am adding a new element. Correct?

Sounds good to me. Some dynamic lists also "shrink", but it doesn't sound like that was part of your remit.

The main thing you need to work out is: when do you resize?

Winston

[Jeff Verdegan]

Mansukhdeep Thind wrote:I believe I need to re-size it whenever I am adding a new element. Correct?

That's one approach you could take. It would lead to poor performance though. Adding an element would be an O(N) operation, whereas in the existing ArrayList it's O(1). If I were the interviewer, I'd deduct points for that.

[Campbell Ritchie]

Abhay Agarwal wrote:. . .
My take is that you are probably referring to synchronization issues in my above code.

Not at all. The code does not have anything in which needed synchronisation. The errors I saw were much simpler. Real “beginning Java” stuff.

sizeratio is number by which arraylist size is initialized.

~ abhay

Apart from what Winston has already told you, and the poor formatting of the name: why on earth do you want a static field with the initial size at all? It is something which is only used locally in the constructor, so why not defy the style suggestion about magic numbers and simply write 10. It should be a local variable in the constructor. Add a comment explaining that you are initialising it to 10 elements. And, if you overload your constructor, make sure to do that correctly, otherwise I shall find another error.

I think the second error is more serious, but you won’t notice it if your class remains that small.

[Mansukhdeep Thind]

Adding an element would be an O(N) operation, whereas in the existing ArrayList it's O(1). If I were the interviewer, I'd deduct points for that.

What is meant by O(N) operation and O(1) operation? What functions are you referring to? The time it takes to add the element?

[Winston Gutkowski]

Jeff Verdegan wrote:

Mansukhdeep Thind wrote:I believe I need to re-size it whenever I am adding a new element. Correct?

That's one approach you could take. It would lead to poor performance though...

Hmmm. A subtle difference between 'when' and 'whenever'...I take your point though.

@Mansukhdeep: And so should you.

Winston

[Jeff Verdegan]

Mansukhdeep Thind wrote:

Adding an element would be an O(N) operation, whereas in the existing ArrayList it's O(1). If I were the interviewer, I'd deduct points for that.

What is meant by O(N) operation and O(1) operation?

http://en.wikipedia.org/wiki/Big_o_notation

In short, it's roughly "How fast does CPU or memory usage grow relative to how input size grows?"

Saying, "Adding an element is an O(N) operation," means that the time it takes to add an element is proportional to the size of your list (N). So it takes 5 times as long to add an element to a list that's already at size 50 as it does to add an element to a list of size 10. O(1) means it's a constant-time operation. Adding an element doesn't depend on the size of the list.

What functions are you referring to? The time it takes to add the element?

Yes, when I said "adding an element," I was referring to the time it takes to add an element.

[Campbell Ritchie]

Mansukhdeep Thind wrote: . . . What is meant by O(N) operation and O(1) operation? . . .

Wikipedia link.

[Winston Gutkowski]

Jeff Verdegan wrote:O(1) means it's a constant-time operation. Adding an element doesn't depend on the size of the list.

<nitpick>
Strictly speaking, all docs for ArrayList say that adds work in amortized O(1) time - and that's because of the internal algorithm that the class uses for expansion - it would be quite easy to pick one that doesn't work in O(1) time, amortized or otherwise.
</nitpick>

Ain't Fridays great?

Winston

[Jeff Verdegan]

Winston Gutkowski wrote:

Jeff Verdegan wrote:O(1) means it's a constant-time operation. Adding an element doesn't depend on the size of the list.

<nitpick>

Yeah, yeah, I know. I didn't want to throw too much new stuff out there at once.

@Mansukhdeep, this bit isn't important for what you're trying to do, but if you're curious, what this means, roughly, is that averaged over many adds, it approaches O(1). The first N adds will be O(1). Then at some point, an add triggers a resize of the backing array. That operation is O(N). Then the next M adds take O(1) again, and then a resize, and so on. By making sure the number of adds between resizes is larger each time around, the O(1) adds overshadow the O(N) add-plus-resize operations. Choosing when to resize, and by how much has implications for CPU and memory. And as is often the case, making more efficient use of one results in less efficient use of the other.

[Mansukhdeep Thind]

I succeeded in implementing a dynamically growable array. I did this by copying the array. But I am stuck at a point. When I add a new element, it is getting added to the next index position correctly, but the previous element becomes null.

package test;



// Custom Array List by Thind(with assistance from JavaRanch buddies!!)

public class CustomArrayList implements Cloneable{
	private Object[] customArray; // my custom array
	private Object[] copiedArray; // dynamically growing array...
	private static int nextIndex = 0; // index which shall
                 // point to next index position where element is to be added
	private int initialSize;

	// Constructor to initialize a custom array list
	public CustomArrayList(){
		this.initialSize = 10;
		this.customArray = new Object[initialSize];		
	}


	// method to add elements to the end of Custom Array List
	public void addElement(Object object, CustomArrayList list) {
		//check if the element at the nextIndex is null
		if(null==customArray[nextIndex]){
			//assign it the passed object reference
			customArray[nextIndex]=object;
			// copy the customArray contents into the copiedArray member.
			copiedArray = new Object[initialSize+nextIndex];  // I suspect
                           //  this statement should be put somewhere else. BUT WHERE??? 
			copiedArray[nextIndex] = customArray[nextIndex];				
			
		}
		nextIndex++; // increment to point to next position at which to add

	}


	public static void main(String[] args){
		CustomArrayList myList = new CustomArrayList();
		myList.addElement(new Integer(23), myList);
		myList.addElement(new Integer(45), myList); // when I add this,  23 becomes null
		myList.addElement(new Integer(76), myList); // when I add this both previous become null
		myList.addElement(new Integer(34), myList);
		System.out.println("Original array size is " +myList.customArray.length);
		System.out.println("New array size is " +myList.copiedArray.length);
		for(int i = 0; i<myList.copiedArray.length;i++)
		{
			System.out.println(myList.copiedArray[i]);
		}



	}


}

This is happening because I am creating a new copiedArray[] object inside the addElement() method. Where should I construct the new copiedArray so that it retains the last added element and adds the new one to it?

0
1
2
3
Original array size is 10
New array size is 13
null // this one
null // this one
null // this one
34
null
null
null
null
null
null
null
null
null

[Jeff Verdegan]

Break your problem down into independent pieces. Write, compile, test, debug each piece independently of the others. Use methods for distinct operations.

Since your problem is with growing the array...

import java.util.*;

public class GrowArrayTest {
  String[] x = {"A", "B", "C", "D"};
  
  public static void main(String[] args) {
    GrowArrayTest gat = new GrowArrayTest();

    System.out.println("x before grow: " + Arrays.toString(x);
    gat.growArray();
    System.out.println("x after grow: " + Arrays.toString(x);
  }

  private void growArray() {
    // Mansukhdeep, your job is to write, test and debug this method.
    // Ignore anything else about ArrayLists, etc.
    // All you care about is making this method work.
  }
}

...your job is to complete the above code.

The expected output is (approximately):


x before grow: [A, B, C, D]
x after grow: [A, B, C, D, null, null, null, null]



This is how you should always approach coding. Do this from the start, rather than writing a whole bunch of code to solve your entire problem, and only then testing it.

And when you do have a larger bunch of code put together, and some piece isn't working, write a smaller program to do only that piece, get that part working, and then re-integrate it with your larger project.

Once you get the above method working, you will place it into your ArrayList class. And I don't mean just copy the body of the method and stick it inside your add() method inline. I mean copy the whole method. So then your add() method will look something like:

public void add(...) {
  if (need to grow) {
    growArray();
  }

  insert new element into array
}

[Mansukhdeep Thind]

OK Jeff. Will put in some effort in this direction.

[Winston Gutkowski]

Mansukhdeep Thind wrote:OK Jeff. Will put in some effort in this direction.

And when you do, please DontWriteLongLines. I've broken up the ones in your previous post.

Thanks

Winston

[Mansukhdeep Thind]

package test;

import java.util.*;  

public class GrowArrayTest {  
	String[] x = {"A", "B", "C", "D"};  
	String[] growableArray;
	public static void main(String[] args) {  
		GrowArrayTest gat = new GrowArrayTest();  

		System.out.println("x before grow: " + Arrays.toString(gat.x));  
	    gat.growArray(gat.x,9);  
		System.out.println("x after grow: " + Arrays.toString(gat.growArray(gat.x,9)));  
	}  

	private String[] growArray(String[] x, int increasedSize) {
		growableArray =  new String[increasedSize];
		for(int i=0;i<x.length;i++){
			growableArray[i] = x[i];
		}
		x=growableArray;
		return x;
		
		// Mansukhdeep, your job is to write, test and debug this method.  
		// Ignore anything else about ArrayLists, etc.  
		// All you care about is making this method work.  
	}  
}  

It gives the output:

x before grow: [A, B, C, D]
x after grow: [A, B, C, D, null, null, null, null, null]

Is this what you were expecting of me?

[Mansukhdeep Thind]

Jeff. Got it. You are correct. I have to learn to break down the task in to manageable and logical constructs. Add is working properly with the array growing dynamically. I shall proceed with remove tomorrow. Went for a 10km run. So tired. Good night guys.

[Jeff Verdegan]

Mansukhdeep Thind wrote:
It gives the output:

x before grow: [A, B, C, D]
x after grow: [A, B, C, D, null, null, null, null, null]

Is this what you were expecting of me?

Yup! Good work!

There are a few implementation details that could use improvement.

I wouldn't bother passing the array to the method. That method is just meant to work on one specific, well-known member variable. It's not for growing an arbitrary array that's passed to it.

I would also do away with passing the new size. I would just calculate it on the fly based on the size of the original array. However, if you have some other approach to computing the new size, it may be appropriate for you to pass it.

Instead of iterating and copying yourself, you could use System.arraycopy, and there may also be an equivalent method in java.util.Arrays. This saves you a small amount of code, and allows the copy mechanism to use faster native code for copying blocks of memory. Not a big deal, but worth keeping in mind.

And finally, growableArray should not be a member variable. It's a temporary variable that's only used during the execution of that method, so it should be local to that method.

The main thing though is that you embrace the technique of writing a small class with a small number of methods to work out how to solve the current problem.

[Mansukhdeep Thind]

Thank you for your guidance Jeff. Will come back tomorrow and meet you and the other guys to keep up the implementation.

The main thing though is that you embrace the technique of writing a small class with a small number of methods to work out how to solve the current problem.

Wise words. The answer is important, but the way you get to it is even more important.

[Mansukhdeep Thind]

I wouldn't bother passing the array to the method. That method is just meant to work on one specific, well-known member variable. It's not for growing an arbitrary array that's passed to it.

Amendment made.

I would also do away with passing the new size. I would just calculate it on the fly based on the size of the original array. However, if you have some other approach to computing the new size, it may be appropriate for you to pass it.

Taken care of.

And finally, growableArray should not be a member variable. It's a temporary variable that's only used during the execution of that method, so it should be local to that method.

Done.

Once you get the above method working, you will place it into your ArrayList class. And I don't mean just copy the body of the method and stick it inside your add() method inline. I mean copy the whole method.

Also done.

Now I need to be able to iterate over the elements of the list. So I need to implement the Iterable interface. Will that be good as the next assignment?

[Campbell Ritchie]

Mansukhdeep Thind wrote:I succeeded in implementing a dynamically growable array.

No you didn’t. There is no such thing. What you are doing is replacing it with a larger array. Its implications have already been discussed.

package test;



// Custom Array List by Thind(with assistance from JavaRanch buddies!!)

public class CustomArrayList implements Cloneable{
	private Object[] customArray; // my custom array
	private Object[] copiedArray; // dynamically growing array...
	private static int nextIndex = 0; // index which shall
                 // point to next index position where element is to be added
	private int initialSize;

	// Constructor to initialize a custom array list
	public CustomArrayList(){
		this.initialSize = 10;
		this.customArray = new Object[initialSize];		
	}


	// method to add elements to the end of Custom Array List
	public void addElement(Object object, CustomArrayList list) {
		//check if the element at the nextIndex is null
		if(null==customArray[nextIndex]){
			//assign it the passed object reference
			customArray[nextIndex]=object;
			// copy the customArray contents into the copiedArray member.
			copiedArray = new Object[initialSize+nextIndex];  // I suspect
                           //  this statement should be put somewhere else. BUT WHERE??? 
			copiedArray[nextIndex] = customArray[nextIndex];				
			
		}
		nextIndex++; // increment to point to next position at which to add

	}


	public static void main(String[] args){
		CustomArrayList myList = new CustomArrayList();
		myList.addElement(new Integer(23), myList);
		myList.addElement(new Integer(45), myList); // when I add this,  23 becomes null
		myList.addElement(new Integer(76), myList); // when I add this both previous become null
		myList.addElement(new Integer(34), myList);
		System.out.println("Original array size is " +myList.customArray.length);
		System.out.println("New array size is " +myList.copiedArray.length);
		for(int i = 0; i<myList.copiedArray.length;i++)
		{
			System.out.println(myList.copiedArray[i]);
		}



	}


}

. . .

I am please to see you have escaped the more serious of the two errors I mentioned earlier. And I haven’t yet told anybody what it is.
Still some things I would query in your code:

1: Why does it implement Cloneable when you haven’t overridden clone()?

2: Why does it implement Cloneable at all?

3: Why do you have two arrays as fields?

4: Why are you passing the list name to the add method?

There are also stylistic shortcomings, eg null ==, inconsistent indentation and spacing.

The construct null == is needed in C/C++ because they can use any type instead of a boolean (in fact C doesn’t have booleans as such at all), but is never needed in Java; always use if (xyz == null)...

[Mansukhdeep Thind]

What you are doing is replacing it with a larger array.

OK. I did a copy. I take back my words.
Here is the latest code.

package test;

// Custom Array List by Thind(with assistance from JavaRanch buddies!!)

/**
 * @author admin
 *
 */
public class CustomArrayList  {
	private Object[] customArray; // my custom array	
	private int nextIndex; // index which shall point to next index position where element is to be added
	private int initialSize; // initial size of the list


	/**
	 * Constructor to initialize a custom array list
	 */
	public CustomArrayList(){
		this.nextIndex = 0;
		this.initialSize = 10;
		this.customArray = new Object[initialSize];		
	}

	// utility method to grow the array dynamically
	/**
	 * 
	 * @return reference to a new array with increased size
	 */
	private Object[] growArray(){
		Object [] copiedArray = new Object[initialSize+nextIndex];
		for (int i=0;i<customArray.length;i++){
			copiedArray[i]=customArray[i];			
		}
		customArray = copiedArray;
		return customArray;
	}

	/**
	 * 
	 * @param object - the element being added
	 * @param list - reference to the list
	 */

	// method to add elements to the end of Custom Array List
	public void addElement(Object object, CustomArrayList list) {
		//check if there is a need to grow the array
		if(nextIndex>=customArray.length){
			// call the growArray method to copy existing contents
			list.growArray();			
		}
		customArray[nextIndex]=object;
		nextIndex++; // increment to point to next position at which to add

	}

	/**
	 * 
	 * @param indexPos
	 * @return
	 */
	public Object get(int indexPos){
		if(indexPos<customArray.length && null!=customArray[indexPos]){
			Object objectAtIndexPos = customArray[indexPos];
			return objectAtIndexPos;
		}
		else if (indexPos<0 || indexPos>customArray.length){
			throw new IndexOutOfBoundsException();
		}

		return null;

	}

	/**
	 * 
	 * @param args - command line arguments
	 */
	public static void main(String[] args){
		CustomArrayList myList = new CustomArrayList();
		myList.addElement(new Integer(23), myList);		
		myList.addElement(new String("Sunny"), myList);
		myList.addElement(new String("Bunty"), myList);
		System.out.println(myList.get(10));
		System.out.println("Original array size is " +myList.customArray.length);
		for(int i =0; i<myList.customArray.length;i++){
			System.out.println(myList.customArray[i]);
		}
	}



}

No Cloneable implemented. That was a mistake.

Why are you passing the list name to the add method?

Then how to call the growArray() method without having a reference to the myList passed to addElement(..) method? I need an instance of the class to call it on. Right?

[Campbell Ritchie]

You already have an instance of the class to call it on. Sometimes called this.

[Mansukhdeep Thind]

You already have an instance of the class to call it on. Sometimes called this.

Things sound so simple when we first learn the basic concepts. But implementing those concepts wisely and in a fruitful manner when faced with a real time scenario is a whole different ball game.

Next task--> My next objective is to make my custom list iterable i.e. I should be able to use the myList reference as a target in the for-each construct. I am thinking of implementing the java.lang.Iterable interface. The overridden method Iterator of this interface would return a reference to a CustomIterator class that will in turn implement java.util.Iterator interface for my custom collection class. It would fit in my current project like this:

public class CustomArrayList implements Iterable<Object> {
...
...
....

...

@Override
	public Iterator<Object> iterator() {
		// TODO Auto-generated method stub
		return null;
	}

	class CustomIterator implements Iterator<Object>{

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			return null;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub
			
		}
		
	}

Am I on the right track?

[Campbell Ritchie]

Mansukhdeep Thind wrote: . . . Things sound so simple when we first learn the basic concepts. . . .

Things are so simple when you implement them correctly

Am I on the right track?

Without even reading the code … no. You want to get the first part working correctly before you try any enhancements. Get one method working before you even think about the second method.

[Mansukhdeep Thind]

Hi Ritchie

I have successfully implemented hasNext() and next(). I am now able to iterate over the elements of the custom list "myList" using both iterator and enhanced for loop. I am having trouble implementing the remove() method though. It should remove the last element of the underlying custom collection. How to do that?

package test;

import java.util.Iterator;

// Custom Array List by Thind(with assistance from JavaRanch buddies!!)

/**
 * @author admin
 *
 */
public class CustomArrayList implements Iterable<Object> {
	private Object[] customArray; // my custom array	
	private int nextIndex; // index which shall point to next index position where element is to be added
	private int initialSize; // initial size of the list


	/**
	 * Constructor to initialize a custom array list
	 */
	public CustomArrayList(){
		this.nextIndex = 0;
		this.initialSize = 10;
		this.customArray = new Object[initialSize];		
	}

	// utility method to grow the array dynamically
	/**
	 * 
	 * @return reference to a new array with increased size
	 */
	private Object[] growArray(){
		Object [] copiedArray = new Object[initialSize+nextIndex];
		for (int i=0;i<customArray.length;i++){
			copiedArray[i]=customArray[i];			
		}
		customArray = copiedArray;
		return customArray;
	}

	/**
	 * 
	 * @param object - the element being added
	 * @param list - reference to the list
	 */

	// method to add elements to the end of Custom Array List
	public void addElement(Object object) {
		//check if there is a need to grow the array
		if(nextIndex>=customArray.length){
			// call the growArray method to copy existing contents
			this.growArray();			
		}
		customArray[nextIndex]=object;
		nextIndex++; // increment to point to next position at which to add

	}

	/**
	 * 
	 * @param indexPos
	 * @return
	 */
	public Object get(int indexPos){
		if(indexPos<customArray.length && null!=customArray[indexPos]){
			Object objectAtIndexPos = customArray[indexPos];
			return objectAtIndexPos;
		}
		else if (indexPos<0 || indexPos>customArray.length){
			throw new IndexOutOfBoundsException();
		}

		return null;

	}

	/**
	 * 
	 * @param args - command line arguments
	 */
	public static void main(String[] args){
		CustomArrayList myList = new CustomArrayList();
		myList.addElement(new Integer(23));		
		myList.addElement(new Integer(54));
		myList.addElement(new Integer(43));
		myList.addElement(new Integer(34));
		myList.addElement(new Integer(67));
		myList.addElement(new Integer(98));
		myList.addElement(new Integer(56));
		myList.addElement(new Integer(23));
		

		CustomIterator myIterator = (CustomIterator) myList.iterator();

		System.out.println("Printing elements using iterator");
		while(myIterator.hasNext()){		
			System.out.println(myIterator.next());			
		}
		
		System.out.println("Printing using enhanced for loop");
		for(Object obj:myList){
			System.out.println(obj.toString());
		}



		System.out.println("Size of list is " + myList.customArray.length);
		/*for(int i =0; i<myList.customArray.length;i++){
			System.out.println(myList.customArray[i]);
		}*/

	}

	@Override
	public Iterator<Object> iterator() {
		CustomIterator myIterator = new CustomIterator(this);
		return myIterator;
	}

	class CustomIterator implements Iterator<Object>{
		private Object[] iterable;
		private int currentIndex;

		public CustomIterator(CustomArrayList list) {
			iterable = list.customArray;			
		}

		@Override
		public boolean hasNext() {
			if(iterable[currentIndex]!=null){				
				return true;
			}
			return false;
		}

		@Override
		public Object next() {
			if(hasNext()){
				Object currentObject = iterable[currentIndex];
				currentIndex++;
				return currentObject;
			}
			return null;
		}

		@Override
		public void remove() {
		// a call to this method should remove the last element returned by my custom iterator. Any hints?
		}

	}


}

[Campbell Ritchie]

Getting better, but it needs a lot of improvement yet. Your get method is unnecessarily complicated. You are still using null== and null!= which shouldn’t be used in Java.
Start by implementing size(), add(E) add(int, E) get(int) set(int, E) and remove(int). Forget about the iterator until you have got all that lot working.
You will need a modificationCount field, and use that to check concurrent modification, so you can throw an Exception from the Iterator as appropriate.
I suggest you start by parameterising the class completely, so it is

public class MyList<E> implements /* List<E>, */ Iterable<E>/*, Serializable, RandomAccess */
{
   private T[] values;
   private long modificationCount = 0L;
//...
}

You will not un‑comment those interfaces until you have implemented a lot more methods.
You do not need initialSize as a field.

[Mansukhdeep Thind]

Your get method is unnecessarily complicated. You are still using null== and null!= which shouldn’t be used in Java.

I have improved it a bit. See the get method now:

public Object get(int indexPos){
		if(indexPos<customArray.length && customArray[indexPos]!=null){			
			return customArray[indexPos];
		}
		else if (indexPos<0 || indexPos>customArray.length){
			throw new IndexOutOfBoundsException();
		}

		return null;

	} 

Is this what you were expecting it to look like? I have also rectified the null!=/null== style. But could you please tell me why? What is the problem with current style? Is it just a Java convention? Or is it something more serious?

Start by implementing size(), add(E) add(int, E) get(int) set(int, E) and remove(int).

I infer these methods will do the following tasks:

a) size() : returns the number of elements(non null) in the current list.

b) add(E) : adds an element to the end of the list (already implemented)

c) add(int,E) : adds an element at a specified position in the custom list and moves the element(if present) at that position one index to right.

d) get(int) :returns the element at the specified position (already implemented)

e) set(int, E) : Replaces the element at the specified position with the one passed.

f) remove(int) : removes the element specified int value

Is that correct Ritchie?

Forget about the iterator until you have got all that lot working.

OK.

You will need a modificationCount field, and use that to check concurrent modification, so you can throw an Exception from the Iterator as appropriate.

Concurrent modification is when more than one thread is trying to access my custom ArrayList at same time. Correct? Are you hinting that I should make my class thread safe? I could not fully grasp this point. Please elaborate what do you term as "concurrent modification". Also, how will I check if that is happening using a long type field?

I suggest you start by parameterising the class completely, so it is

What is meant by parametrization of a class?

You will not un‑comment those interfaces until you have implemented a lot more methods.

OK.

You do not need initialSize as a field.

So, you want me to remove the initialSize field and directly hard code the size inside the constructor. Something like:

public class CustomArrayList implements Iterable<Object> {
	private Object[] customArray; // my custom array	
	private int nextIndex; // index which shall point to next index position where element is to be added
	//private int initialSize; // initial size of the list


	/**
	 * Constructor to initialize a custom array list
	 */
	public CustomArrayList(){
		this.nextIndex = 0;
		//this.initialSize = 10;
		this.customArray = new Object[10];		
	}
....
......
......

Correct?