¿Cómo puedo agregar elementos dinámicamente a una matriz de Java?

En PHP, puede agregar elementos dinámicamente a las matrices de la siguiente manera:

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

Después de esto, $xsería una matriz de esta manera: {1,2}.

¿Hay alguna forma de hacer algo similar en Java?

Mira java.util.LinkedList o java.util.ArrayList

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

Las matrices en Java tienen un tamaño fijo, por lo que no puede "agregar algo al final" como podría hacer en PHP.

Un poco similar al comportamiento de PHP es este:

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

Entonces puedes escribir:

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

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

Pero este esquema es terriblemente ineficaz para matrices más grandes , ya que hace una copia de toda la matriz cada vez. (Y de hecho, no es completamente equivalente a PHP, ya que sus antiguas matrices siguen siendo las mismas).

Las matrices PHP son de hecho bastante iguales a un Java HashMap con una "clave máxima" agregada, por lo que sabría qué clave usar a continuación y un extraño orden de iteración (y una extraña relación de equivalencia entre claves Integer y algunas cadenas). Pero para colecciones indexadas simples, es mejor usar una Lista en Java, como las otras respuestas propuestas.

Si quieres evitar usar List debido a la sobrecarga de envolver cada int en un Integer, considere usar reimplementaciones de colecciones para tipos primitivos, que usan matrices internamente, pero no harán una copia en cada cambio, solo cuando la matriz interna esté llena ( como ArrayList). (Un ejemplo rápidamente buscado en Google es esta clase IntList ).

Guayaba contiene métodos que crean tales envolturas en Ints.asList, Longs.asList, etc.

Apache Commons tiene una implementación ArrayUtils para agregar un elemento al final de la nueva 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)

He visto esta pregunta con mucha frecuencia en la web y, en mi opinión, muchas personas con alta reputación no respondieron estas preguntas correctamente. Así que me gustaría expresar mi propia respuesta aquí.

Primero debemos considerar que hay una diferencia entre arrayy arraylist.

La pregunta pide agregar un elemento a una matriz. , y no ArrayList

La respuesta es bastante simple. Se puede realizar en 3 pasos.

1. Convertir matriz en una lista de matrices
2. Agregar elemento a arrayList
3. Convierta de nuevo la nueva lista de matrices en la matriz

Aquí está la imagen simple

Y finalmente aquí está el código:

Paso 1:

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

Paso 2:

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

            list.add(element);
            return list;
    }

Paso 3:

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

Paso 4

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

Puede usar un ArrayListy luego usar el toArray()método. Pero dependiendo de lo que esté haciendo, es posible que ni siquiera necesite una matriz. Mire para ver si Listses más lo que quiere.

Ver: Tutorial de lista de Java

Probablemente desee usar una ArrayList para esto, para una estructura similar a una matriz de tamaño dinámico.

Puede agregar elementos dinámicamente a una matriz utilizando Collection Frameworks en JAVA. Collection Framework no funciona en tipos de datos primitivos.

Este marco de la colección estará disponible en el paquete "java.util. *"

Por ejemplo, si usa ArrayList,

Cree un objeto y luego agregue una cantidad de elementos (cualquier tipo como String, Integer ... etc.)

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

Ahora se le agregaron 3 elementos a una matriz.

si desea eliminar alguno de los elementos agregados

a.remove("suman");

de nuevo si quieres agregar cualquier elemento

a.add("Gurram");

Entonces, el tamaño de la matriz aumenta / disminuye dinámicamente.

Utilice una ArrayList o haga malabares con las matrices para incrementar automáticamente el tamaño de la matriz.

Mantenga un recuento de dónde se encuentra en la 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 es una forma sencilla de agregar a una matriz en java. Usé una segunda matriz para almacenar mi matriz original y luego le agregué un elemento más. Después de eso, pasé esa matriz a la 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);
    }

En Java, el tamaño de la matriz es fijo, pero puede agregar elementos dinámicamente a una matriz de tamaño fijo usando su índice y bucle for. Encuentre un ejemplo a continuación.

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

}