Wsrtjtyk

In java array length is fixed.

You can use a List to hold the values and invoke the toArray method if needed
See the following sample:

import java.util.List;

import java.util.ArrayList;

import java.util.Random;



public class A  {



    public static void main( String  args ) {

        // dynamically hold the instances

        List<xClass> list = new ArrayList<xClass>();



        // fill it with a random number between 0 and 100

        int elements = new Random().nextInt(100);  

        for( int i = 0 ; i < elements ; i++ ) {

            list.add( new xClass() );

        }



        // convert it to array

        xClass  array = list.toArray( new xClass[ list.size() ] );





        System.out.println( "size of array = " + array.length );

    }

}

class xClass {}

As others have said, you cannot change the size of an existing Java array.

ArrayList is the closest that standard Java has to a dynamic sized array. However, there are some things about ArrayList (actually the List interface) that are not "array like". For example:

• You cannot use [ ... ] to index a list. You have to use the get(int) and set(int, E) methods.


• An ArrayList is created with zero elements. You cannot simple create an ArrayList with 20 elements and then call set(15, foo).


• You cannot directly change the size of an ArrayList. You do it indirectly using the various add, insert and remove methods.

If you want something more array-like, you will need to design your own API. (Maybe someone could chime in with an existing third party library ... I couldn't find one with 2 minutes "research" using Google :-) )

If you only really need an array that grows as you are initializing it, then the solution is something like this.

ArrayList<T> tmp = new ArrayList<T>();

while (...) {

    tmp.add(new T(...));

}

// This creates a new array and copies the element of 'tmp' to it.

T array = tmp.toArray(new T[tmp.size()]);

You set the number of elements to anything you want at the time you create it:

xClass mysclass = new xClass[n];

Then you can initialize the elements in a loop. I am guessing that this is what you need.

If you need to add or remove elements to the array after you create it, then you would have to use an ArrayList.

You can use ArrayList:

import java.util.ArrayList;

import java.util.Iterator;

...

ArrayList<String> arr = new ArrayList<String>();

arr.add("neo");

arr.add("morpheus");

arr.add("trinity");

Iterator<String> foreach = arr.iterator();

while (foreach.hasNext()) System.out.println(foreach.next());

Arrays.copyOf() method has many options to fix the problem with Array length increasing dynamically.

Java API

Yes, wrap it and use the Collections framework.

List l = new ArrayList();

l.add(new xClass());

// do stuff

l.add(new xClass());

Then use List.toArray() when necessary, or just iterate over said List.

As other users say, you probably need an implementation of java.util.List.

If, for some reason, you finally need an array, you can do two things:

• Use a List and then convert it to an array with myList.toArray()




• Use an array of certain size. If you need more or less size, you can modify it with java.util.Arrays methods.

Best solution will depend on your problem ;)

I recommend using vectors instead. Very easy to use and has many predefined methods for implementation.

import java.util.*;



Vector<Integer> v=new Vector<Integer>(5,2);

to add an element simply use:

v.addElement(int);

In the (5,2) the first 5 is the initial size of the vector. If you exceed the initial size,the vector will grow by 2 places. If it exceeds again, then it will again increase by 2 places and so on.

Where you declare the myclass array as :

xClass myclass = new xClass[10]

, simply pass in as an argument the number of XClass elements you'll need. At that point do you know how many you will need? By declaring the array as having 10 elements, you are not declaring 10 XClass objects, you're simply creating an array with 10 elements of type xClass.

It is a good practice get the amount you need to store first then initialize the array.

for example, you would ask the user how many data he need to store and then initialize it, or query the component or argument of how many you need to store.
if you want a dynamic array you could use ArrayList() and use al.add(); function to keep adding, then you can transfer it to a fixed array.

//Initialize ArrayList and cast string so ArrayList accepts strings (or anything

ArrayList<string> al = new ArrayList(); 

//add a certain amount of data

for(int i=0;i<x;i++)

{

  al.add("data "+i); 

}



//get size of data inside

int size = al.size(); 

//initialize String array with the size you have

String strArray = new String[size]; 

//insert data from ArrayList to String array

for(int i=0;i<size;i++)

{

  strArray[i] = al.get(i);

}

doing so is redundant but just to show you the idea, ArrayList can hold objects unlike other primitive data types and are very easy to manipulate, removing anything from the middle is easy as well, completely dynamic.same with List and Stack

Java Array sizes are fixed , You cannot make dynamic Arrays as that of in C++.

I don't know if you can change the size at runtime but you can allocate the size at runtime. Try using this code:

class MyClass {

    void myFunction () {

        Scanner s = new Scanner (System.in);

        int myArray ;

        int x;



        System.out.print ("Enter the size of the array: ");

        x = s.nextInt();



        myArray = new int[x];

    }

}

this assigns your array size to be the one entered at run time into x.

Here's a method that doesn't use ArrayList. The user specifies the size and you can add a do-while loop for recursion.

import java.util.Scanner;

    public class Dynamic {

        public static Scanner value;

        public static void main(Stringargs){

            value=new Scanner(System.in);

            System.out.println("Enter the number of tests to calculate averagen");

            int limit=value.nextInt();

            int index=0;

            int  marks=new int[limit];

            float sum,ave;

            sum=0;      

            while(index<limit)

            {

                int test=index+1;

                System.out.println("Enter the marks on test " +test);

                marks[index]=value.nextInt();

                sum+=marks[index];

                index++;

            }

            ave=sum/limit;

            System.out.println("The average is: " + ave);

        }

    }

In Java Array Sizes are always of Fixed Length But there is way in which you can Dynamically increase the Size of the Array at Runtime Itself

This is the most "used" as well as preferred way to do it-

    int temp=new int[stck.length+1];

    for(int i=0;i<stck.length;i++)temp[i]=stck[i];

    stck=temp;

In the above code we are initializing a new temp array, and further using a for loop to initialize the contents of the temp with the contents of the original array ie. stck. And then again copying it back to the original one, giving us a new array of new SIZE.

No doubt it generates a CPU Overhead due to reinitializing an array using for loop repeatedly. But you can still use and implement it in your code.
For the best practice use "Linked List" instead of Array, if you want the data to be stored dynamically in the memory, of variable length.

Here's a Real-Time Example based on Dynamic Stacks to INCREASE ARRAY SIZE at Run-Time

File-name: DStack.java

public class DStack {

private int stck;

int tos;



void Init_Stck(int size) {

    stck=new int[size];

    tos=-1;

}

int Change_Stck(int size){

    return stck[size];

}



public void push(int item){

    if(tos==stck.length-1){

        int temp=new int[stck.length+1];

        for(int i=0;i<stck.length;i++)temp[i]=stck[i];

        stck=temp;

        stck[++tos]=item;

    }

    else

        stck[++tos]=item;

}

public int pop(){

    if(tos<0){

        System.out.println("Stack Underflow");

        return 0;

    }

    else return stck[tos--];

}



public void display(){

    for(int x=0;x<stck.length;x++){

        System.out.print(stck[x]+" ");

    }

    System.out.println();

}



}

File-name: Exec.java

(with the main class)

import java.util.*;

public class Exec {



private static Scanner in;



public static void main(String args) {

    in = new Scanner(System.in);

    int option,item,i=1;

    DStack obj=new DStack();

    obj.Init_Stck(1);

    do{

        System.out.println();

        System.out.println("--MENU--");

        System.out.println("1. Push a Value in The Stack");

        System.out.println("2. Pop a Value from the Stack");

        System.out.println("3. Display Stack");

        System.out.println("4. Exit");

        option=in.nextInt();

        switch(option){

        case 1:

            System.out.println("Enter the Value to be Pushed");

            item=in.nextInt();

            obj.push(item);

            break;

        case 2:

            System.out.println("Popped Item: "+obj.pop());

            obj.Change_Stck(obj.tos);

            break;

        case 3:

            System.out.println("Displaying...");

            obj.display();

            break;

        case 4:

            System.out.println("Exiting...");

            i=0;

            break;

        default:

            System.out.println("Enter a Valid Value");



        }

    }while(i==1);



}



}

Hope this solves your query.

Yes, we can do this way.

import java.util.Scanner;



public class Collection_Basic {



    private static Scanner sc;



    public static void main(String args) {



        Object obj=new Object[4];

        sc = new Scanner(System.in);





        //Storing element

        System.out.println("enter your element");

        for(int i=0;i<4;i++){

            obj[i]=sc.nextInt();

        }



        /*

         * here, size reaches with its maximum capacity so u can not store more element,

         * 

         * for storing more element we have to create new array Object with required size

         */



        Object tempObj=new Object[10];



        //copying old array to new Array



        int oldArraySize=obj.length;

        int i=0;

        for(;i<oldArraySize;i++){



            tempObj[i]=obj[i];

        }



        /*

         * storing new element to the end of new Array objebt

         */

        tempObj[i]=90;



        //assigning new array Object refeence to the old one



        obj=tempObj;



        for(int j=0;j<obj.length;j++){

            System.out.println("obj["+j+"] -"+obj[j]);

        }

    }





}

Since ArrayList takes to much memory when I need array of primitive types, I prefer using IntStream.builder() for creating int array (You can also use LongStream and DoubleStream builders).

Example:

Builder builder = IntStream.builder();

int arraySize = new Random().nextInt();

for(int i = 0; i<arraySize; i++ ) {

    builder.add(i);

}

int array = builder.build().toArray();

Note: available since Java 8.

You can do some thing

private  static Person   addPersons(Person persons, Person personToAdd) {

    int currentLenght = persons.length;



    Person  personsArrayNew = Arrays.copyOf(persons, currentLenght +1);

    personsArrayNew[currentLenght]  = personToAdd;



    return personsArrayNew;



}