Tamanho da matriz dinâmica Java?

No java array length is fixed.

Pode usar uma lista para manter os valores e invocar o método toArray Se necessário Ver a seguinte amostra:

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

Como outros já disseram, Você não pode alterar o tamanho de uma matriz Java existente.

A lista é o mais próximo que o Java padrão tem de um array de tamanho dinâmico. No entanto, existem algumas coisas sobre ArrayList (na verdade a interface da lista) que não são "array like". Por exemplo:

• Não pode utilizar [ ... ] para indexar uma lista. Você tem que usar os métodos get(int) e set(int, E).
• um ArrayList é criado com zero elementos. Você não pode simplesmente criar um ArrayList com 20 elementos e, em seguida, chamar set(15, foo).
• Você não pode alterar diretamente o tamanho de um ArrayList. Você faz isso indiretamente usando os vários add, insert e métodos.

Se você quer algo mais array-like, você vai precisar de projetar sua própria API. (Talvez alguém possa entrar com uma biblioteca de terceiros existente ... Não consegui encontrar um com 2 minutos de "pesquisa" usando o Google: -))

Se você realmente precisa de uma matriz que cresce à medida que você está inicializando , então a solução é algo assim.

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

Você define o número de elementos para qualquer coisa que quiser no momento em que o cria:

xClass[] mysclass = new xClass[n];

Então você pode inicializar os elementos em um loop. Acho que é disto que precisas.

Se tiver de adicionar ou remover elementos à matriz após a sua criação, então terá de usar um ArrayList.

Pode usar o 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());

Sim, embrulhe - o e use a estrutura de colecções.

List l = new ArrayList();
l.add(new xClass());
// do stuff
l.add(new xClass());

Então use a lista.toArray () when necessary, or just iterate over said List.

Como outros usuários dizem, você provavelmente precisa de uma implementação de java.util.Lista.

Se, por alguma razão, finalmente precisares de uma matriz, podes fazer duas coisas:

• Use uma lista e, em seguida, convertê-la para um array com myList.toArray()

• Use um conjunto de certos tamanhos. Se você precisar de mais ou menos tamanho, você pode modificá-lo com java.util.Métodos de Arrays.

A melhor solução dependerá do seu problema;)

import java.util.*;

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

Para adicionar um elemento, basta usar:

v.addElement(int);

Na (5,2) o primeiro 5 é o tamanho inicial do vetor. Se você exceder o tamanho inicial, o vetor crescerá em 2 lugares. Se ele exceder novamente, então ele vai novamente aumentar em 2 lugares e assim por diante.

Arrays.copyOf() o método tem muitas opções para corrigir o problema com o tamanho do Array aumentando dinamicamente.

API Java

Onde você declara a matriz myclass[] como :

xClass myclass[] = new xClass[10]

, Basta passar como argumento o número de elementos XClass que você vai precisar. Nesse ponto você sabe quantos você vai precisar? Ao declarar o array como tendo 10 elementos, você não está declarando 10 objetos XClass, você está simplesmente criando um array com 10 elementos do tipo xClass.

É uma boa prática obter a quantidade que você precisa para armazenar primeiro, em seguida, inicializar o array.

Por exemplo, você perguntaria ao usuário quantos dados ele precisa armazenar e então inicializá-lo, ou consultar o componente ou argumento de quantos você precisa armazenar. se quiser uma matriz dinâmica, poderá usar ArrayList() e usar a função al.add(); para continuar a adicionar, então poderá transferi-la para uma matriz fixa.

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

Fazê-lo é redundante, mas só para lhe mostrar a ideia, ArrayList pode conter objectos ao contrário dos objectos outros tipos primitivos de dados e são muito fáceis de manipular, removendo qualquer coisa do meio é fácil também, completamente dinâmico.o mesmo com List e Stack

Os tamanhos dos Array Java são fixos, não é possível criar Arrays dinâmicos como os do Em C++.

Não sei se você pode mudar o tamanho em tempo de execução, mas você pode alocar o tamanho em tempo de execução. Tente usar este código:

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

Isto atribui o tamanho da sua lista como sendo o indicado no tempo de execução em X.

import java.util.Scanner;
    public class Dynamic {
        public static Scanner value;
        public static void main(String[]args){
            value=new Scanner(System.in);
            System.out.println("Enter the number of tests to calculate average\n");
            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);
        }
    }

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

Esta é a forma mais" usada", bem como a forma preferida de o fazer -

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

No código acima estamos inicializando uma nova matriz temp [], e ainda usando um laço for para inicializar o conteúdo da temperatura com o conteúdo da matriz original ie. stck[]. E então novamente copiá-lo de volta para o original, dando-nos um novo um conjunto de novos tamanhos.

Aqui está um exemplo em tempo Real baseado em pilhas dinâmicas para aumentar o tamanho da matriz em tempo de execução

Nome do ficheiro: 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();
}

}

Nome do ficheiro: Execucao.java
(com a classe principal)

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

}

}

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


}

Exemplo:

Builder builder = IntStream.builder();
int arraySize = new Random().nextInt();
for(int i = 0; i<arraySize; i++ ) {
    builder.add(i);
}
int[] array = builder.build().toArray();

Nota: disponível desde Java 8.

private  static Person []  addPersons(Person[] persons, Person personToAdd) {
    int currentLenght = persons.length;

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

    return personsArrayNew;

}