Wie füge ich einem Array neue Elemente hinzu?

Ich habe folgenden Code:

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

Diese beiden Anhänge werden nicht kompiliert. Wie würde das richtig funktionieren?

Die Größe eines Arrays kann nicht geändert werden. Wenn Sie ein größeres Array wünschen, müssen Sie ein neues instanziieren.

Eine bessere Lösung wäre die Verwendung eines, ArrayListdas nach Bedarf wachsen kann. Die Methode ArrayList.toArray( T[] a )gibt Ihnen Ihr Array zurück, wenn Sie es in dieser Form benötigen.

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

Wenn Sie es in ein einfaches Array konvertieren müssen ...

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

Aber die meisten Dinge, die Sie mit einem Array tun, können Sie auch mit dieser ArrayList tun:

// iterate over the array
for( String oneItem : where ) {
    ...
}

// get specific items
where.get( 1 );

Verwenden Sie ein List<String>, wie z ArrayList<String>. Im Gegensatz zu Arrays ist es dynamisch erweiterbar (siehe: Effektive Java 2nd Edition, Punkt 25: Listen Arrays vorziehen ).

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

Wenn Sie auf der Verwendung von Arrays bestehen, können Sie java.util.Arrays.copyOfein größeres Array zuweisen, um das zusätzliche Element aufzunehmen. Dies ist jedoch nicht die beste Lösung.

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

Dies ist O(N)per append. ArrayListhat andererseits die O(1)Kosten pro Operation amortisiert.

Siehe auch

• Java Tutorials / Arrays
  • Ein Array ist ein Containerobjekt, das eine feste Anzahl von Werten eines einzelnen Typs enthält. Die Länge eines Arrays wird beim Erstellen des Arrays festgelegt. Nach der Erstellung ist die Länge festgelegt.
• Java Tutorials / Die List-Oberfläche

Apache Commons Lang hat

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

Es wird ein neues Array zurückgegeben. Wenn Sie jedoch aus irgendeinem Grund wirklich mit Arrays arbeiten, ist dies möglicherweise der ideale Weg, dies zu tun.

Es gibt eine andere Option, die ich hier nicht gesehen habe und die keine "komplexen" Objekte oder Sammlungen beinhaltet.

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

Es gibt keine Methode append() für Arrays. Stattdessen kann ein List-Objekt, wie bereits vorgeschlagen, die Notwendigkeit des dynamischen Einfügens von Elementen, z.

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

Oder wenn Sie wirklich ein Array verwenden möchten:

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

Dies ist jedoch eine feste Größe, und es können keine Elemente hinzugefügt werden.

Wie Tangens sagte, ist die Größe eines Arrays festgelegt. Aber Sie müssen es zuerst instanziieren, sonst ist es nur eine Nullreferenz.

String[] where = new String[10];

Dieses Array kann nur 10 Elemente enthalten. Sie können einen Wert also nur 10 Mal anhängen. In Ihrem Code greifen Sie auf eine Nullreferenz zu. Deshalb funktioniert es nicht. Verwenden Sie die ArrayList, um eine dynamisch wachsende Sammlung zu erhalten.

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

Ich habe diesen Code gemacht! Es wirkt wie ein Zauber!

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

Ich hoffe du magst es!!

Sie müssen eine Sammlungsliste verwenden. Sie können ein Array nicht neu dimensionieren.

Wenn Sie Ihre Daten in einem einfachen Array wie diesem speichern möchten

String[] where = new String[10];

und Sie möchten einige Elemente wie Zahlen hinzufügen, bitte verwenden Sie uns StringBuilder, der viel effizienter ist als das Verketten von Strings.

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

Dies ist eine viel bessere Methode, um Ihren String zu erstellen und in Ihrem 'where'-Array zu speichern.

Hinzufügen neuer Elemente zum String-Array.

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

Es gibt viele Möglichkeiten, einem Array ein Element hinzuzufügen. Sie können ein temporäres ListElement verwenden , um das Element zu verwalten und es dann wieder zu konvertieren, Arrayoder Sie können das verwenden java.util.Arrays.copyOfund es mit Generika kombinieren, um bessere Ergebnisse zu erzielen.

Dieses Beispiel zeigt Ihnen, wie:

public static <T> T[] append2Array(T[] elements, T element)
{
    T[] newArray = Arrays.copyOf(elements, elements.length + 1);
    newArray[elements.length] = element;

    return newArray;
}

Um diese Methode zu verwenden, müssen Sie sie nur so aufrufen:

String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, "four");
System.out.println(Arrays.toString(numbers));

Wenn Sie zwei Arrays zusammenführen möchten, können Sie die vorherige Methode folgendermaßen ändern:

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

Jetzt können Sie die Methode folgendermaßen aufrufen:

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

Wie bereits erwähnt, können Sie auch ListObjekte verwenden. Es wird jedoch einen kleinen Hack erfordern, um es so sicher zu machen:

public static <T> T[] append2Array(Class<T[]> clazz, List<T> elements, T element)
{
    elements.add(element);
    return clazz.cast(elements.toArray());
}

Jetzt können Sie die Methode folgendermaßen aufrufen:

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

Ich bin nicht so erfahren in Java, aber mir wurde immer gesagt, dass Arrays statische Strukturen sind, die eine vordefinierte Größe haben. Sie müssen eine ArrayList oder einen Vektor oder eine andere dynamische Struktur verwenden.

Sie können eine Arrayliste erstellen und Collection.addAll()das String-Array in Ihre Arrayliste konvertieren

Sie können dies einfach tun:

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

Wenn Sie die Größe eines Arrays wirklich ändern möchten, können Sie Folgendes tun:

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]

Die Größe des Arrays kann nicht geändert werden. Wenn Sie ein Array verwenden müssen, können Sie Folgendes verwenden:

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

Es ist auch möglich, ausreichend großen Speicher vorab zuzuweisen. Hier ist eine einfache Stapelimplementierung: Das Programm soll 3 und 5 ausgeben.

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