¿Cómo agregar nuevos elementos a una matriz?

Tengo el siguiente código:

String[] where; where.append(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1"); where.append(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1"); 

Esos dos anexos no están comstackndo. ¿Cómo funcionaría eso correctamente?

El tamaño de una matriz no se puede modificar. Si desea una matriz más grande, debe instanciar una nueva.

Una mejor solución sería usar una ArrayList que pueda crecer a medida que la necesite. El método ArrayList.toArray( T[] a ) le devuelve su matriz si la necesita de esta forma.

 List where = new ArrayList(); where.add( ContactsContract.Contacts.HAS_PHONE_NUMBER+"=1" ); where.add( ContactsContract.Contacts.IN_VISIBLE_GROUP+"=1" ); 

Si necesita convertirlo a una matriz simple …

 String[] simpleArray = new String[ where.size() ]; where.toArray( simpleArray ); 

Pero la mayoría de las cosas que haces con una matriz también puedes hacer con esta ArrayList:

 // iterate over the array for( String oneItem : where ) { ... } // get specific items where.get( 1 ); 

Use una List , como una ArrayList . Es dinámicamente cultivable, a diferencia de las matrices (ver: Effective Java 2nd Edition, Item 25: Prefer listas a matrices ).

 import java.util.*; //.... List list = new ArrayList(); list.add("1"); list.add("2"); list.add("3"); System.out.println(list); // prints "[1, 2, 3]" 

Si insiste en usar matrices, puede usar java.util.Arrays.copyOf para asignar una matriz más grande para acomodar el elemento adicional. Sin embargo, esta no es la mejor solución.

 static  T[] append(T[] arr, T element) { final int N = arr.length; arr = Arrays.copyOf(arr, N + 1); arr[N] = element; return arr; } String[] arr = { "1", "2", "3" }; System.out.println(Arrays.toString(arr)); // prints "[1, 2, 3]" arr = append(arr, "4"); System.out.println(Arrays.toString(arr)); // prints "[1, 2, 3, 4]" 

Esto es O(N) por append . ArrayList , por otro lado, tiene O(1) costo amortizado por operación.

Ver también

  • Tutoriales / Arrays de Java
    • Una matriz es un objeto contenedor que contiene un número fijo de valores de un solo tipo. La longitud de una matriz se establece cuando se crea la matriz. Después de la creación, su longitud es fija.
  • Tutoriales de Java / La interfaz de la lista

Hay otra opción que no he visto aquí y que no involucra Objetos o Colecciones “complejos”.

 String[] array1 = new String[]{"one", "two"}; String[] array2 = new String[]{"three"}; String[] array = new String[array1.length + array2.length]; System.arraycopy(array1, 0, array, 0, array1.length); System.arraycopy(array2, 0, array, array1.length, array2.length); 

Apache Commons Lang tiene

 T[] t = ArrayUtils.add( initialArray, newitem ); 

devuelve una nueva matriz, pero si realmente está trabajando con matrices por alguna razón, esta puede ser la forma ideal de hacerlo.

No hay método append() en matrices. En cambio, como ya se ha sugerido, un objeto List puede servir la necesidad de insertar elementos dinámicamente, por ejemplo.

 List where = new ArrayList(); where.add(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1"); where.add(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1"); 

O si está realmente interesado en usar una matriz:

 String[] where = new String[]{ ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1", ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1" }; 

pero este es un tamaño fijo y no se pueden agregar elementos.

Como dijeron los tangentes, el tamaño de una matriz es fijo. Pero primero debe crear una instancia, de lo contrario será solo una referencia nula.

 String[] where = new String[10]; 

Esta matriz puede contener solo 10 elementos. Entonces puede agregar un valor solo 10 veces. En su código está accediendo a una referencia nula. Es por eso que no funciona. Para tener una colección de crecimiento dynamic, use ArrayList.

 String[] source = new String[] { "a", "b", "c", "d" }; String[] destination = new String[source.length + 2]; destination[0] = "/bin/sh"; destination[1] = "-c"; System.arraycopy(source, 0, destination, 2, source.length); for (String parts : destination) { System.out.println(parts); } 

Necesitas usar una lista de colecciones. No puede redimensionar una matriz.

Si desea almacenar sus datos en una matriz simple como esta

 String[] where = new String[10]; 

y quiere agregarle algunos elementos como números, por favor use StringBuilder, que es mucho más eficiente que concatenar la cadena.

 StringBuilder phoneNumber = new StringBuilder(); phoneNumber.append("1"); phoneNumber.append("2"); where[0] = phoneNumber.toString(); 

Este es un método mucho mejor para construir su cadena y almacenarla en su array ‘where’.

Agregar nuevos elementos a la matriz de cadenas.

 String[] myArray = new String[] {"x", "y"}; // Convert array to list List listFromArray = Arrays.asList(myArray); // Create new list, because, List to Array always returns a fixed-size list backed by the specified array. List tempList = new ArrayList(listFromArray); tempList.add("z"); //Convert list back to array String[] tempArray = new String[tempList.size()]; myArray = tempList.toArray(tempArray); 

¡He hecho este código! ¡Funciona a las mil maravillas!

 public String[] AddToStringArray(String[] oldArray, String newString) { String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1); newArray[oldArray.length] = newString; return newArray; } 

¡¡Espero que te guste!!

No soy tan experimentado en Java, pero siempre me han dicho que las matrices son estructuras estáticas que tienen un tamaño predefinido. Debe usar una ArrayList o un Vector o cualquier otra estructura dinámica.

puede crear una lista de arrays y usar Collection.addAll() para convertir la matriz de cadenas a su lista de arrays

Simplemente puede hacer esto:

 System.arraycopy(initialArray, 0, newArray, 0, initialArray.length); 

El tamaño de la matriz no se puede modificar. Si tiene que usar una matriz, puede usar System.arraycopy (src, srcpos, dest, destpos, length);

Si realmente quieres cambiar el tamaño de una matriz, puedes hacer algo como esto:

 String[] arr = {"a", "b", "c"}; System.out.println(Arrays.toString(arr)); // Output is: [a, b, c] arr = Arrays.copyOf(arr, 10); // new size will be 10 elements arr[3] = "d"; arr[4] = "e"; arr[5] = "f"; System.out.println(Arrays.toString(arr)); // Output is: [a, b, c, d, e, f, null, null, null, null]