CODEWITHSUNDEEP
javaarraysarraylist
ms87
ms87

Reputation: 17492

Variable length (Dynamic) Arrays in Java

I was wondering how to initialise an integer array such that it's size and values change through out the execution of my program, any suggestions?

Upvotes: 123

Views: 477477

Answers (8)

Rakesh yash k s
Rakesh yash k s

Reputation: 11

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;
    }

}

Upvotes: 0

Hao Deng
Hao Deng

Reputation: 643

  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];

Upvotes: 7

MattGrommes
MattGrommes

Reputation: 12354

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.

Upvotes: 43

Pops
Pops

Reputation: 30828

Yes: use ArrayList.

In Java, "normal" arrays are fixed-size. You have to give them a size and can't expand them or contract them. To change the size, you have to make a new array and copy the data you want - which is inefficient and a pain for you.

Fortunately, there are all kinds of built-in classes that implement common data structures, and other useful tools too. You'll want to check the Java 6 API for a full list of them.

One caveat: ArrayList can only hold objects (e.g. Integers), not primitives (e.g. ints). In MOST cases, autoboxing/autounboxing will take care of this for you silently, but you could get some weird behavior depending on what you're doing.

Upvotes: 134

cspann
cspann

Reputation: 193

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

Upvotes: 12

Thiago Chaves
Thiago Chaves

Reputation: 9453

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).

Upvotes: 4

Mnementh
Mnementh

Reputation: 51311

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);

Upvotes: 27

Konrad Garus
Konrad Garus

Reputation: 54005

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

Upvotes: 4

Related Questions