If you never gonna change the size of the array, always have the same number of elements, you could make a ring buffer.

What you would do is initialize the array, to a defined size, like you have in your first line of code.

Then you make to integers, which hold the index to what you consider to be the first, and the last element, and then adjust them as you add or remove stuff.

1. String[] words = new String[maxWords];
2. int read = 0;
3. int write = 0;

When you add an element you'd do something like:

1. words[write] = "Some string";
2. write++;
3. if(write >= maxWords) write = 0;

And when you want to read the first element you'd do:

1. System.out.println(words[read]);
2. read++;
3. if(read >= maxWords) read = 0;

This is very basic, and can lead to overwriting of values you haven't read, or read where nothing is written yet, but this'll work as long as you always do at least one write before the first read, and start reading before write is back to 0;

A way to modify it a bit, for better usability could be to do this when reading and writing:

1. // Write an element
2. if(write >= read)
   
3. {
4.       words[write%maxWords] = "some string";
5.       write++;
   
6. }
   
7. else println("writing now till overwrite unread word");
8. // Read an element
9. if(write > read)
10. {
11.       println(words[read%maxWords]);
12.       read++;
    
13. }
14. else
15. {
16.       println("Nothing unread");
    
17. }
    

An array is just a data structure just as the Java collections are data structures - the main differences between the data structures are how the data elements are organised (sequential, tree etc) and how the data is accessed (sequential, randon, hash etc).

The trick here is to pick the data structures that best suits your needs and in this situation I would recommend a LinkedList which allows addition and removal of data elements at either end.

If you must use an array whose length is to match the number of elements (i.e. increases and decreases) then one way would be to create methods to do this

1. String[] removeFirst(String[] array)
2. {
3.       String[] temp = new String[array.length - 1];
4.       arrayCopy(array, 1, temp, 0, temp.length);
5.       return temp;
6. }

and to add a word

1. String[] addLast(String[] array, String word)
2. {
3.       String[] temp = new String[array.length + 1];
4.       arrayCopy(array, 0, temp, 0, array.length);
5.              temp[temp.length - 1] = word;
6.       return temp;
7. }

if the array is called myWords then the syntax to use these are

1. myWords = removeFirst(myWords();
2. myWords = addLast(myWords, "processing");

Both thanks,
I think greger's method is a litle harder to read.
Quarks, what will be the advantage of LinkedList instand of the code you have written above?

The advantage of the linked list is that addition and removal of elements from the ends is done in constant time i.e. is not depndant on the number of elements in the list.

With an array you have to create a new array and copy the elements from the old to the new array so the time taken is proportional to the number of the elements in the array. It also means that at one point you will have two arrays in existance at the same time so there are memory implications if it is a very, very large array. If the array is small then you will not notice any real difference and the arrayCopy method calls the System.arraycopy method which is a method in the JVM so uses native (fast) code to implement.

i will look at List then, just for learning.

It would be worth looking at all the Java collections including trees, maps and sets etc choosing the right collection to suit your program design can simplify the programming.

I should point out that arrays are better than lists if you want to iterate over all the elements or want to access a particular element in the collection.