Variable length (Dynamic) Arrays in Java

Arrays in Java are of fixed size. What you'd need is an ArrayList, one of a number of extremely valuable Collections available in Java.

Instead of

Integer[] ints = new Integer[x]

you use

List<Integer> ints = new ArrayList<Integer>();

Then to change the list you use ints.add(y) and ints.remove(z) amongst many other handy methods you can find in the appropriate Javadocs.

I strongly recommend studying the Collections classes available in Java as they are very powerful and give you a lot of builtin functionality that Java-newbies tend to try to rewrite themselves unnecessarily.

Arrays are fixed size once instantiated. You can use a List instead.

Autoboxing make a List usable similar to an array, you can put simply int-values into it:

List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);

I disagree with the previous answers suggesting ArrayList, because ArrayList is not a Dynamic Array but a List backed by an array. The difference is that you cannot do the following:

ArrayList list = new ArrayList(4);
list.put(3,"Test");

It will give you an IndexOutOfBoundsException because there is no element at this position yet even though the backing array would permit such an addition. So you need to use a custom extendable Array implementation like suggested by @randy-lance

1. It is recommend to use List to deal with small scale size.

2. If you have a huge number of numbers, NEVER use List and autoboxing,

   List< Integer> list

For every single int, a new Integer is auto created. You will find it getting slow when the size of the list increase. These Integers are unnecessary objects. In this case, to use a estimated size would be better,

int[] array = new int[ESTIMATED_SIZE];

How about using a List instead? For example, ArrayList<integer>

You can't change the size of an array. You can, however, create a new array with the right size and copy the data from the old array to the new.

But your best option is to use IntList from jacarta commons. (here)

It works just like a List but takes less space and is more efficient than that, because it stores int's instead of storing wrapper objects over int's (that's what the Integer class is).

class Main {  
   
    public static void main(String[] args) {    
        int [] a={1, 0, 3, 4, 1, 2, 0, 4};    
        int count =1;  
        int [] temp = null;
        for(int r : a){
            if(r!=0){
                if(temp==null || count >= temp.length){
                    temp =dynamicincrement(count,temp);
                }
                temp[count-1] = r;
                count=count+1;
            }
        }

        System.out.println("the value"+Arrays.toString(temp));
    }

    public static  int [] dynamicincrement(int size,int [] existingdata){  
        int [] trf=new int [size];
        if(existingdata==null){
            return new int[size];
        }

        if( existingdata!=null  &&  existingdata.length>0){
            for(int i=0;i<existingdata.length;i++){
                trf[i]=existingdata[i];
            }
        }
        return trf;
    }

}