Como posso adicionar itens dinamicamente a um array Java?

Em PHP, você pode adicionar elementos dinamicamente a matrizes da seguinte maneira:

$x = new Array();
$x[] = 1;
$x[] = 2;

Depois disso, $xseria uma matriz como este: {1,2}.

Existe uma maneira de fazer algo semelhante em Java?

Olhe para java.util.LinkedList ou java.util.ArrayList

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

Os arrays em Java têm um tamanho fixo, portanto você não pode "adicionar algo no final" como faria em PHP.

Um pouco semelhante ao comportamento do PHP é este:

int[] addElement(int[] org, int added) {
    int[] result = Arrays.copyOf(org, org.length +1);
    result[org.length] = added;
    return result;
}

Então você pode escrever:

x = new int[0];
x = addElement(x, 1);
x = addElement(x, 2);

System.out.println(Arrays.toString(x));

Mas esse esquema é terrivelmente ineficiente para arrays maiores , pois faz uma cópia de todo o array a cada vez. (E na verdade não é completamente equivalente ao PHP, já que seus arrays antigos permanecem os mesmos).

Os arrays PHP são na verdade exatamente iguais a um HashMap Java com uma "chave máxima" adicionada, então ele saberia qual chave usar a seguir e uma ordem de iteração estranha (e uma estranha relação de equivalência entre chaves inteiras e algumas Strings). Mas para coleções indexadas simples, é melhor usar uma lista em Java, como os outros respondentes propostos.

Se você quiser evitar o uso Listdevido à sobrecarga de agrupar cada int em um inteiro, considere o uso de reimplementações de coleções para tipos primitivos, que usam arrays internamente, mas não farão uma cópia em cada mudança, apenas quando o array interno estiver cheio ( assim como ArrayList). (Um exemplo pesquisado rapidamente é esta classe IntList .)

Goiaba contém métodos de criação de tais embalagens em Ints.asList, Longs.asListetc.

O Apache Commons tem uma implementação ArrayUtils para adicionar um elemento no final da nova matriz:

/** Copies the given array and adds the given element at the end of the new array. */
public static <T> T[] add(T[] array, T element)

Tenho visto essa pergunta muitas vezes na web e, em minha opinião, muitas pessoas com grande reputação não responderam a essas perguntas corretamente. Portanto, gostaria de expressar minha própria resposta aqui.

Primeiro, devemos considerar que há uma diferença entre arraye arraylist.

A questão pede para adicionar um elemento a uma matriz , e não ArrayList

A resposta é bem simples. Isso pode ser feito em 3 etapas.

1. Converter array em arraylist
2. Adicionar elemento a arrayList
3. Converta de volta a nova arrayList para a matriz

Aqui está uma imagem simples disso

E finalmente aqui está o código:

Passo 1:

public List<String> convertArrayToList(String[] array){
        List<String> stringList = new ArrayList<String>(Arrays.asList(array));
        return stringList;
    }

Passo 2:

public  List<String> addToList(String element,List<String> list){

            list.add(element);
            return list;
    }

Etapa 3:

public String[] convertListToArray(List<String> list){
           String[] ins = (String[])list.toArray(new String[list.size()]);
           return ins;
    } 

Passo 4

public String[] addNewItemToArray(String element,String [] array){
        List<String> list = convertArrayToList(array);
        list= addToList(element,list);
        return  convertListToArray(list);
}

Você pode usar um ArrayListe, em seguida, usar o toArray()método. Mas dependendo do que você está fazendo, pode nem mesmo precisar de um array. Procure ver se Listsé mais o que você deseja.

Veja: Tutorial da Lista Java

Você provavelmente deseja usar um ArrayList para isso - para uma estrutura semelhante a um array de tamanho dinâmico.

Você pode adicionar elementos dinamicamente a uma matriz usando Collection Frameworks em JAVA. O framework de coleção não funciona em tipos de dados primitivos.

Esta estrutura de coleção estará disponível no pacote "java.util. *"

Por exemplo, se você usar ArrayList,

Crie um objeto para ele e, em seguida, adicione o número de elementos (qualquer tipo como String, Integer ... etc)

ArrayList a = new ArrayList();
a.add("suman");
a.add(new Integer(3));
a.add("gurram");

Agora você adicionou 3 elementos a um array.

se você deseja remover qualquer um dos elementos adicionados

a.remove("suman");

novamente se você quiser adicionar qualquer elemento

a.add("Gurram");

Portanto, o tamanho da matriz está aumentando / diminuindo dinamicamente ..

Use um ArrayList ou juggle para arrays para incrementar automaticamente o tamanho do array.

mantenha uma contagem de onde você está na matriz primitiva

class recordStuff extends Thread
{
    double[] aListOfDoubles;
    int i = 0;

    void run()
    {
        double newData;
        newData = getNewData(); // gets data from somewhere

        aListofDoubles[i] = newData; // adds it to the primitive array of doubles
        i++ // increments the counter for the next pass

        System.out.println("mode: " + doStuff());
    }

    void doStuff()
    {
        // Calculate the mode of the double[] array

        for (int i = 0; i < aListOfDoubles.length; i++) 
        {
            int count = 0;
            for (int j = 0; j < aListOfDoubles.length; j++)
            {
                if (a[j] == a[i]) count++;
            }
            if (count > maxCount) 
            {
                maxCount = count;
                maxValue = aListOfDoubles[i];
            }
        }
        return maxValue;
    }
}

Esta é uma maneira simples de adicionar a um array em java. Usei uma segunda matriz para armazenar minha matriz original e, em seguida, adicionei mais um elemento a ela. Depois disso, passei aquele array de volta ao original.

    int [] test = {12,22,33};
    int [] test2= new int[test.length+1];
    int m=5;int mz=0;
    for ( int test3: test)        
    {          
    test2[mz]=test3; mz++;        
    } 
    test2[mz++]=m;
    test=test2;

    for ( int test3: test)

    {
      System.out.println(test3);
    }

Em Java, o tamanho do array é fixo, mas você pode adicionar elementos dinamicamente a um array de tamanho fixo usando seu índice e loop for. Por favor, encontre o exemplo abaixo.

package simplejava;

import java.util.Arrays;

/**
 *
 * @author sashant
 */
public class SimpleJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        try{
            String[] transactions;
            transactions = new String[10];

            for(int i = 0; i < transactions.length; i++){
                transactions[i] = "transaction - "+Integer.toString(i);            
            }

            System.out.println(Arrays.toString(transactions));

        }catch(Exception exc){
            System.out.println(exc.getMessage());
            System.out.println(Arrays.toString(exc.getStackTrace()));
        }
    }

}