Risposte:
La dimensione di un array non può essere modificata. Se vuoi un array più grande devi istanziarne uno nuovo.
Una soluzione migliore sarebbe quella di utilizzare una ArrayList
che può crescere quando ne hai bisogno. Il metodo ArrayList.toArray( T[] a )
ti restituisce l'array se ne hai bisogno in questo modulo.
List<String> where = new ArrayList<String>();
where.add( ContactsContract.Contacts.HAS_PHONE_NUMBER+"=1" );
where.add( ContactsContract.Contacts.IN_VISIBLE_GROUP+"=1" );
Se devi convertirlo in un semplice array ...
String[] simpleArray = new String[ where.size() ];
where.toArray( simpleArray );
Ma la maggior parte delle cose che fai con un array puoi fare anche con questo ArrayList:
// iterate over the array
for( String oneItem : where ) {
...
}
// get specific items
where.get( 1 );
Usa un List<String>
, come un ArrayList<String>
. È dinamicamente coltivabile, a differenza degli array (vedi: Effective Java 2nd Edition, Item 25: Preferisci gli elenchi agli array ).
import java.util.*;
//....
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
System.out.println(list); // prints "[1, 2, 3]"
Se si insiste sull'uso di array, è possibile utilizzare java.util.Arrays.copyOf
per allocare un array più grande per accogliere l'elemento aggiuntivo. Questa non è davvero la soluzione migliore, comunque.
static <T> 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, haO(1)
ammortizzato il costo per operazione.
ArrayList
fa internamente.
Apache Commons ha Lang
T[] t = ArrayUtils.add( initialArray, newitem );
restituisce un nuovo array, ma se stai davvero lavorando con gli array per qualche motivo, questo potrebbe essere il modo ideale per farlo.
C'è un'altra opzione che non ho visto qui e che non coinvolge oggetti o collezioni "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);
Non esiste alcun metodo append()
sugli array. Invece, come già suggerito, un oggetto List può soddisfare la necessità di inserire dinamicamente elementi, ad es.
List<String> where = new ArrayList<String>();
where.add(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.add(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");
O se vuoi davvero usare un array:
String[] where = new String[]{
ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1",
ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1"
};
ma quindi questa è una dimensione fissa e non è possibile aggiungere elementi.
Come dicevano tangens, la dimensione di un array è fissa. Ma devi prima istanziarlo, altrimenti sarà solo un riferimento null.
String[] where = new String[10];
Questa matrice 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 dinamica, usa ArrayList.
Se desideri archiviare 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 creare la stringa e archiviarla nell'array 'where'.
Aggiunta di nuovi elementi all'array String.
String[] myArray = new String[] {"x", "y"};
// Convert array to list
List<String> listFromArray = Arrays.asList(myArray);
// Create new list, because, List to Array always returns a fixed-size list backed by the specified array.
List<String> tempList = new ArrayList<String>(listFromArray);
tempList.add("z");
//Convert list back to array
String[] tempArray = new String[tempList.size()];
myArray = tempList.toArray(tempArray);
<code>
tag e questo ha avuto problemi con i tipi generici. Cerca di evitare questo tag, poiché ... ha dei problemi, e indenta il tuo codice con 4 spazi bianchi per ottenere la formattazione corretta. L'ho fatto per la tua domanda :).
Esistono molti modi per aggiungere un elemento a un array. Puoi usare un temp List
per gestire l'elemento e poi riconvertirlo in Array
oppure puoi usare iljava.util.Arrays.copyOf
e combinarlo con generici per risultati migliori.
Questo esempio ti mostrerà come:
public static <T> T[] append2Array(T[] elements, T element)
{
T[] newArray = Arrays.copyOf(elements, elements.length + 1);
newArray[elements.length] = element;
return newArray;
}
Per usare questo metodo devi solo chiamarlo così:
String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, "four");
System.out.println(Arrays.toString(numbers));
Se si desidera unire due array, è possibile modificare il metodo precedente in questo modo:
public static <T> T[] append2Array(T[] elements, T[] newElements)
{
T[] newArray = Arrays.copyOf(elements, elements.length + newElements.length);
System.arraycopy(newElements, 0, newArray, elements.length, newElements.length);
return newArray;
}
Ora puoi chiamare il metodo in questo modo:
String[] numbers = new String[]{"one", "two", "three"};
String[] moreNumbers = new String[]{"four", "five", "six"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, moreNumbers);
System.out.println(Arrays.toString(numbers));
Come ho già detto, puoi anche usare List
oggetti. Tuttavia, richiederà un piccolo trucco per renderlo sicuro in questo modo:
public static <T> T[] append2Array(Class<T[]> clazz, List<T> elements, T element)
{
elements.add(element);
return clazz.cast(elements.toArray());
}
Ora puoi chiamare il metodo in questo modo:
String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(String[].class, Arrays.asList(numbers), "four");
System.out.println(Arrays.toString(numbers));
newArray[elements.length] = element;
, volevi dire newArray[elements.length - 1] = element;
?
Puoi semplicemente farlo:
System.arraycopy(initialArray, 0, newArray, 0, initialArray.length);
Se si desidera davvero ridimensionare un array, è possibile 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]
È anche possibile pre-allocare dimensioni di memoria sufficientemente grandi. Ecco una semplice implementazione dello stack: il programma dovrebbe produrre 3 e 5.
class Stk {
static public final int STKSIZ = 256;
public int[] info = new int[STKSIZ];
public int sp = 0; // stack pointer
public void push(int value) {
info[sp++] = value;
}
}
class App {
public static void main(String[] args) {
Stk stk = new Stk();
stk.push(3);
stk.push(5);
System.out.println(stk.info[0]);
System.out.println(stk.info[1]);
}
}