Come aggiungere nuovi elementi a un array?

Ho il codice seguente:

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

Queste due annesse non stanno compilando. Come funzionerebbe correttamente?

La dimensione di un array non può essere modificata. Se vuoi un array più grande devi istanziarne uno nuovo.

Una soluzione migliore sarebbe usare un ArrayList che può crescere quando ne hai bisogno. Il metodo ArrayList.toArray( T[] a ) restituisce l’array se necessario in questo modulo.

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

Se hai bisogno di convertirlo in un array semplice …

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

Ma la maggior parte delle cose che fai con un array che puoi fare con questo ArrayList:

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

Utilizzare un List , ad esempio ArrayList . È dynamicmente coltivabile, a differenza degli array (vedere: Seconda edizione Java efficace, elemento 25: Preferisci elenchi agli array ).

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

Se si insiste sull’utilizzo degli array, è ansible utilizzare java.util.Arrays.copyOf per allocare un array più grande per l’elemento aggiuntivo. Questa però non è la soluzione migliore.

 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]" 

Questo è O(N) per append . ArrayList , d’altra parte, ha O(1) costo ammortizzato per operazione.

Guarda anche

  • Esercitazioni / matrici Java
    • Un array è un object contenitore che contiene un numero fisso di valori di un singolo tipo. La lunghezza di un array viene stabilita al momento della creazione dell’array. Dopo la creazione, la sua lunghezza è fissa.
  • Esercitazioni Java / L’interfaccia Elenco

C’è un’altra opzione che non ho visto qui e che non coinvolge oggetti o raccolte “complessi”.

 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 ha

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

restituisce un nuovo array, ma se si sta davvero lavorando con gli array per qualche motivo, questo potrebbe essere il modo ideale per farlo.

Non c’è alcun metodo append() sugli array. Invece come già suggerito un object List può servire la necessità di inserire dynamicmente gli elementi ad es.

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

O se sei davvero desideroso di usare un array:

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

ma allora questa è una dimensione fissa e nessun elemento può essere aggiunto.

Come detto tangens, la dimensione di un array è fissa. Ma devi prima istanziarlo, altrimenti sarà solo un riferimento nullo.

 String[] where = new String[10]; 

Questo array può contenere solo 10 elementi. Quindi puoi aggiungere un valore solo 10 volte. Nel tuo codice stai accedendo a un riferimento null. Ecco perché non funziona. Per avere una collezione in crescita dynamic, usa 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); } 

È necessario utilizzare un elenco di raccolta. Non è ansible ridimensionare un array.

Se desideri memorizzare i tuoi dati in un array semplice come questo

 String[] where = new String[10]; 

e vuoi aggiungere alcuni elementi come numeri per favore StringBuilder che è molto più efficiente della concatenazione di stringhe.

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

Questo è un metodo molto migliore per build la stringa e memorizzarla nella matrice ‘where’.

Aggiunta di nuovi elementi all’array di stringhe.

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

Ho fatto questo codice! Esso funziona magicamente!

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

Spero vi piaccia!!

Non sono così esperto in Java, ma mi è sempre stato detto che gli array sono strutture statiche con dimensioni predefinite. Devi usare un ArrayList o un vettore o qualsiasi altra struttura dynamic.

puoi creare un arraylist e usare Collection.addAll() per convertire l’array di stringhe nel tuo arraylist

Puoi semplicemente fare questo:

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

La dimensione della matrice non può essere modificata. Se devi usare un array, puoi usare System.arraycopy (src, srcpos, dest, destpos, length);

Se si vuole veramente ridimensionare un array, si può fare qualcosa del genere:

 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]