Bagaimana cara menambahkan elemen baru ke array?

Saya memiliki kode berikut:

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

Dua tambahan itu tidak dikompilasi. Bagaimana cara kerjanya dengan benar?

Ukuran array tidak dapat dimodifikasi. Jika Anda ingin array yang lebih besar Anda harus instantiate yang baru.

Solusi yang lebih baik adalah menggunakan ArrayListyang dapat tumbuh sesuai kebutuhan Anda. Metode ArrayList.toArray( T[] a )memberi Anda kembali array Anda jika Anda membutuhkannya dalam formulir ini.

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

Jika Anda perlu mengonversinya menjadi array sederhana ...

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

Tetapi sebagian besar hal yang Anda lakukan dengan sebuah array dapat Anda lakukan dengan ArrayList ini, juga:

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

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

Gunakan a List<String>, seperti a ArrayList<String>. Ini dapat ditumbuhkan secara dinamis, tidak seperti array (lihat: Java Edisi 2 yang Efektif, Butir 25: Lebih suka daftar dari 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]"

Jika Anda bersikeras menggunakan array, Anda dapat menggunakan java.util.Arrays.copyOfuntuk mengalokasikan array yang lebih besar untuk mengakomodasi elemen tambahan. Ini sebenarnya bukan solusi terbaik.

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

Ini O(N)per append. ArrayListDi lain pihak, O(1)biaya perolehan diamortisasi per operasi.

Lihat juga

• Tutorial / Array Java
  • Array adalah objek kontainer yang menyimpan sejumlah nilai tetap dari satu tipe. Panjang array ditetapkan saat array dibuat. Setelah dibuat, panjangnya tetap.
• Tutorial Java / Antarmuka Daftar

Apache Commons Lang miliki

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

ia mengembalikan array baru, tetapi jika Anda benar-benar bekerja dengan array karena suatu alasan, ini mungkin cara yang ideal untuk melakukan ini.

Ada opsi lain yang belum saya lihat di sini dan yang tidak melibatkan Objek atau Koleksi "kompleks".

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

Tidak ada metode append()pada array. Alih-alih seperti yang sudah disarankan objek Daftar dapat melayani kebutuhan untuk memasukkan elemen secara dinamis misalnya.

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

Atau jika Anda benar-benar ingin menggunakan array:

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

tapi kemudian ini adalah ukuran tetap dan tidak ada elemen yang bisa ditambahkan.

Seperti kata tangens, ukuran array adalah tetap. Tapi Anda harus instantiate dulu, kalau tidak hanya referensi nol.

String[] where = new String[10];

Array ini hanya dapat berisi 10 elemen. Jadi Anda dapat menambahkan nilai hanya 10 kali. Dalam kode Anda, Anda sedang mengakses referensi nol. Itu sebabnya tidak bekerja. Untuk memiliki koleksi yang tumbuh secara dinamis, gunakan 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);
}

Saya sudah membuat kode ini! Itu bekerja seperti pesona!

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

Saya harap Anda menyukainya!!

Anda perlu menggunakan Daftar Koleksi. Anda tidak dapat mengubah dimensi array.

Jika Anda ingin menyimpan data Anda dalam array sederhana seperti ini

String[] where = new String[10];

dan Anda ingin menambahkan beberapa elemen ke dalamnya seperti angka, silakan kami StringBuilder yang jauh lebih efisien daripada string penggabung.

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

Ini adalah metode yang jauh lebih baik untuk membangun string Anda dan menyimpannya ke dalam array 'where' Anda.

Menambahkan item baru ke 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);

Ada banyak cara untuk menambahkan elemen ke array. Anda dapat menggunakan temp Listuntuk mengelola elemen dan kemudian mengubahnya kembali Arrayatau Anda dapat menggunakan java.util.Arrays.copyOfdan menggabungkannya dengan obat generik untuk hasil yang lebih baik.

Contoh ini akan menunjukkan caranya:

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

    return newArray;
}

Untuk menggunakan metode ini, Anda hanya perlu menyebutnya seperti ini:

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

Jika Anda ingin menggabungkan dua array, Anda dapat memodifikasi metode sebelumnya seperti ini:

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

Sekarang Anda dapat memanggil metode seperti ini:

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

Seperti yang saya sebutkan, Anda juga dapat menggunakan Listobjek. Namun, perlu sedikit retasan agar aman seperti ini:

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

Sekarang Anda dapat memanggil metode seperti ini:

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

Saya tidak berpengalaman di Jawa tetapi saya selalu diberitahu bahwa array adalah struktur statis yang memiliki ukuran yang telah ditentukan. Anda harus menggunakan ArrayList atau Vektor atau struktur dinamis lainnya.

Anda dapat membuat daftar Collection.addAll()array , dan gunakan untuk mengubah array string ke daftar array Anda

Anda cukup melakukan ini:

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

Jika seseorang benar-benar ingin mengubah ukuran array, Anda dapat melakukan sesuatu seperti ini:

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]

Ukuran array tidak dapat dimodifikasi. Jika Anda harus menggunakan array, Anda dapat menggunakan:

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

Anda juga dapat mengalokasikan ukuran memori yang cukup besar. Berikut ini adalah implementasi tumpukan sederhana: program seharusnya menghasilkan 3 dan 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]);
    }
}