Come aggiungere nuovi elementi a un array?


291

Ho il codice seguente:

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

Questi due allegati non si stanno compilando. Come funzionerebbe correttamente?

Risposte:


395

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

9
Che senso ha usare Array se puoi fare lo stesso con ArrayList?
Skoua,

@ tangens.Io sono nuovo per Android ma la tua risposta mi ha aiutato.Prima di trovare la risposta ho perso molte ore
scott

1
Le matrici @Skoua sono più efficienti. La pre-definizione della dimensione dell'oggetto consente al compilatore di ottimizzare la memoria. Per alcune applicazioni, è importante. Una piccola app in esecuzione su un computer moderno può probabilmente cavarsela con un sacco di elenchi prima che la memoria diventi un problema.
DraxDomax,

102

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.copyOfper 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.

Guarda anche


È possibile raddoppiare le dimensioni dell'array ogni volta che la capacità non è sufficiente. In questo modo append sarà ammortizzato O (1). Probabilmente cosa ArrayListfa internamente.
Siyuan Ren,

32

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.


23

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

14

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.


Quindi una query con parametri accetta anche ArrayList come selectionArgs?
Skynet,

7

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.


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

6

Ho creato 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!!


5

È necessario utilizzare un elenco di raccolte. Non è possibile ridimensionare un array.


4

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'.


4

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

1
Ah, vedo, hai usato il <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 :).
Tom,

4

Esistono molti modi per aggiungere un elemento a un array. Puoi usare un temp Listper gestire l'elemento e poi riconvertirlo in Arrayoppure 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 Listoggetti. 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;?
David Riccitelli,

3

Non sono così esperto in Java, ma mi è sempre stato detto che le matrici sono strutture statiche con dimensioni predefinite. Devi usare una ArrayList o un Vector o qualsiasi altra struttura dinamica.


2

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


2

Puoi semplicemente farlo:

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

2

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]

1

La dimensione dell'array non può essere modificata. Se devi usare un array, puoi usare:

System.arraycopy(src, srcpos, dest, destpos, length); 

0

È 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]);
    }
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.