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, $x
sería una matriz de esta manera: {1,2}
.
¿Hay alguna forma de hacer algo similar en 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, $x
sería una matriz de esta manera: {1,2}
.
¿Hay alguna forma de hacer algo similar en Java?
Respuestas:
Mira java.util.LinkedList o java.util.ArrayList
List<Integer> x = new ArrayList<Integer>();
x.add(1);
x.add(2);
int[]
) simplemente use el toArray()
método en List. Utilice el código anterior pero úselo x.toArray()
para obtener una matriz primitiva.
ARRAY
objetos de Oracle o alguna tontería como esa, es mucho mejor evitar las matrices primitivas.
List
referencia nos permite patear ArrayList
la acera en cualquier momento que queramos. Si alguien publica una lista mejor, como SuperDuperAwesomeList
, podríamos tener mucho trabajo por hacer si hiciéramos nuestra referencia como ArrayList
. ArrayList tiene cosas que List no tiene. Si confiamos en esas cosas en nuestro código, se vuelve mucho más difícil intercambiar.
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.
ArrayList
hace, excepto que en lugar de cambiar el tamaño en cada adición, cuando se queda sin espacio, duplica su tamaño para que no tenga que cambiar de tamaño tan a menudo.
org
es uno más corto que result
.
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 array
y arraylist
.
La pregunta pide agregar un elemento a una matriz. , y no ArrayList
La respuesta es bastante simple. Se puede realizar en 3 pasos.
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 ArrayList
y 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 Lists
es más lo que quiere.
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()));
}
}
}