I can't just create a string array and then add as many items to it whenever I feel like it. To get around that, you do a ListArray and then convert it to a String array when you've completed the array. If I was misinformed about this, then you can answer this question by telling me how to create a dynamic String array.

In my opinion using static array implementation is not efficient, because when you resize it (the arrayList), what actually happens is to alocate in main memory twice its size and then traverse the array and update the second. The first gets carbage collected. There are java implementations provided for dynamic lists, why dont you use them?

Examples: see LinkedList

I can't just create a string array and then add as many items to it whenever I feel like it. To get around that, you do a ListArray and then convert it to a String array when you've completed the array.

You wont need to create your own dynamic list (since there are java implementations), however, I am gonna explain how they work, so you can get an idea about it. Dynamic lists are implemented with a class node that keeps the pointer of the next node, so all together are formaing a list of connected items. Moreover, the first element of the list is marked as the head of the list and the last one as the tail (If you use a java's LinkedList, there are double pointers; keeping the previous and the next node so you can move backwards if needed). The difference between the dynamic list and an array is that you do not declare a size for it, but rather add as many items as you wish and allocate only the size of those nodes in your main memory. On the other hand, static arrays require alocating the memory for its whole size eventhough you have empty indeces. In addition, the nodes are stored not sequencially in the main memory, which is the case with the static arrays because like this time complexity O(1) can be achieved when you access an index.

An example of how this works:

public class Node {
    private Object item;
    private Node next;

    public Node() {
        next = null;
    }

    public Node(Object newItem) {
        item = newItem;
        next = null;
    }

    public Node(Object newItem, Node nextNode) {
        item = newItem;
        next = nextNode;
    }

    public void setItem(Object newItem) {
        item = newItem;
    }

    public Object getItem() {
        return item;
    }

    public void setNext(ListNode nextNode) {
        next = nextNode;
    }

    public Node getNext() {
        return next;
    }
}
public class LinkedList {
    private Node head;
    private Node tail;
    int numItems;

    public LinkedList() {
        head = tail = null;
        numItems = 0;
    }

    public int size() {
        return numItems;
    }

    public boolean isEmpty() {
        return (numItems == 0);
    }

    public void removeAll() {
        head = tail = null;
        numItems = 0;
    }

    private Node find(int index) {
        ListNode curr = head;
        for (int skip = 1; skip < index; skip++)
            curr = curr.getNext();
        return curr;
    }

    // Etc for the other methods.. like add/remove/etc
}

EDIT

The above example is not the best one to be used. I am just providing it for understanding purposes, there are other things that could be used, like a binary search tree for example or a hashMap. The algorithm complexity of a balanced binary search tree is O(log n) while hashMap has algorithm complexity from O(1) to O(n) (more frequently O(1))

I quote SLaks's answer and I would like to add an answer to your comment here, as I do not have enough reputation yet. You "don't need to set the length at the declaration". The line

String[] menuArray;

actually only declares a reference to an array object, it does not create the object itself, it does not allocate the memory for the array (except the tiny bit for the reference on the stack). Remember to initialise the variable before accessing it though.

That said, I think if you are looking for an "expandable" array, then you should use ArrayList and the List interface. An ArrayList, not ListArray, is a 'Resizable-array implementation of the List interface', from the Java official docs.

Could you change the method setUpView to take a List? If not you can still convert ArrayList to array back and forth with:

List<String> menuList;
// ...
String[] arr = (String[]) menuList.toArray();
List<String> list = new ArrayList<String>(Arrays.asList(arr));