In Java an array has a fixed size (after initialisation), meaning that you can't add or remove items from an array.

int[] i = new int[10];

The above snippet mean that the array of integers has a length of 10. It's not possible add an eleventh integer, without re-assign the reference to a new array, like the following:

int[] i = new int[11];

In Java the package java.util contains all kinds of data structures that can handle adding and removing items from array-like collections. The classic data structure Stack has methods for push and pop.

ArrayList is unique in its naming standards. Here are the equivalencies:

Array.push    -> ArrayList.add(Object o); // Append the list
Array.pop     -> ArrayList.remove(int index); // Remove list[index]
Array.shift   -> ArrayList.remove(0); // Remove first element
Array.unshift -> ArrayList.add(int index, Object o); // Prepend the list

Note that unshift does not remove an element, but instead adds one to the list. Also note that corner-case behaviors are likely to be different between Java and JS, since they each have their own standards.

We can only guess why the JCF looks today like it does, but one lesson learned in design is what Antoine de Saint-Exupery once said:

A designer knows he has achieved perfection not when there is nothing left to add, but when there is nothing left to take away.

In my experience, this applies to software design as well. A component like an ArrayList does not become necessarily "better" by supporting as many different data type interfaces as possible (even if it could). The smaller the interface of a component is, the less do we we have to learn and remember how it looks like, and the less functions are there which we confuse for each other. (Of course, an interface should not be smaller than it needs to be to form a coherent abstraction.)

How "small" an interface of a container should be ideally is definitely a question of the designers experience, taste and what they have learned at school or university. The usual CS books about stacks, lists, vectors, queues and arrays treat them as distinct abstract data types, so following that tradition and implementing them as different classes seemed to be quite natural.

Hence, for some reason we do not know for sure, the JCF designers seemed to have thought peek and pop are negligible for ArrayList. But when you think peek and pop would be a great addition to your ArrayLists, feel free to implement your own component ExtArrayList which provides the whole ArrayList together with peek and pop.

Terminology

This is going to be confusing. What you call size() is conventionally called the "capacity". You got the terminology mostly right in the parameter to the constructor. There's no point in calling it initialCapacity instead of just capacity, though, since the data structure's capacity cannot be changed once it is created.

You don't offer a way for users to fetch the size (i.e. the number of pushes minus the number of pops). That's what the size() method should be for. In addition, there should be a way to find out how many elements are available to be popped (that haven't been discarded).

I don't know what you mean by bottomElem — it is never used.

Style

Your block comments would be much more valuable if you wrote them as standard JavaDoc, like in the interface file.

The DEFAULT_CAPACITY is only discoverable by reading the source code or by decompiling the bytecode. Furthermore, I don't see any obvious reason for picking 100. You should either explain what the default constructor does in JavaDoc or drop the default constructor altogether.

Omitting braces is a filthy habit. You will contribute to a future coding accident, and it will be squarely your fault.

Code should compile without warnings. You should write @SuppressWarnings("unchecked") to suppress this warning:

CircularArrayStack.java:50: warning: [unchecked] unchecked cast
          stack = (T[])(new Object[initialCapacity]);
                       ^
  required: T[]
  found:    Object[]
  where T is a type-variable:
    T extends Object declared in class CircularArrayStack
1 warning

Behaviour

This is a weird data structure. I can't imagine any practical application for it. Note the following undesirable properties:

• Once you push() one element, you can call pop() as many times as you want, and it will never be empty.
• If you push() more elements than the capacity, it will silently overwrite earlier entries.
• If you push() more elements than the capacity, toString() won't show all of the stored entries.

First of all, you are using a static variable (growthmultipler) inside the instance of a class. This is fatal if you have more than one instance of this class. Because you always use 2*growthmultipler, you don't need it. Use +=2 instead.

You don't need to prealloc data in the constructor. It will be done if it's needed.

You don't need to handle "size == 0" separately. You only have to handle "size >= length".

You don't have to create a new class if you want to grow data.

In pop() you should test to not get negative (and throw an exception). And normally a pop function returns the value.

In summary it might look like this:

public class stackAlist{
    int[] data;
    int size;

    public stackAlist(){
        size = 0;
        data = new int[size];
    }

    public void push(int value){
        if(size>=data.length) {
            int [] ndata = new int[data.length+2];
            System.arraycopy(data, 0, ndata, 0, size);
            data = ndata;
        }
        data[size] = value;
        size += 1;
    }

    public int pop() {
        int ret=0;
        if(size>0) {
            size -= 1;
            ret = data[size];
            data[size] = 0;
        }
        return ret;
    }
    .....