如何向數組添加新元素？

Question

我有以下代碼：

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

這兩個附加沒有編譯。 這將如何正確工作？

Answer 1

無法修改數組的大小。 如果你想要一個更大的數組，你必須實例化一個新的。

更好的解決方案是使用可以根據需要增長的ArrayList 。 如果您需要這種形式的數組，方法ArrayList.toArray( T[] a )將返回您的數組。

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

如果您需要將其轉換為一個簡單的數組...

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

但是你用數組做的大多數事情你也可以用這個 ArrayList 做：

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

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

Answer 2

使用List<String> ，例如ArrayList<String> 。 它是動態增長的，與數組不同（參見： Effective Java 2nd Edition，Item 25: Prefer lists to arrays ）。

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

如果你堅持使用數組，你可以使用java.util.Arrays.copyOf分配一個更大的數組來容納額外的元素。 不過，這確實不是最好的解決方案。

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

這是O(N)每個append 。 另一方面， ArrayList每個操作的攤銷成本為O(1) 。

也可以看看

• Java 教程/數組
  • 數組是一個容器對象，它包含固定數量的單一類型的值。 數組的長度是在創建數組時確定的。 創建后，其長度是固定的。
• Java 教程/列表界面

Answer 3

Apache Commons Lang 有

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

它返回一個新數組，但如果您出於某種原因確實在使用數組，這可能是執行此操作的理想方法。

Answer 4

還有一個我在這里沒有看到的選項，它不涉及“復雜”的對象或集合。

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

Answer 5

數組上沒有append()方法。 相反，正如已經建議的那樣，List 對象可以滿足動態插入元素的需要，例如。

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

或者，如果您真的很想使用數組：

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

但這是一個固定大小，不能添加任何元素。

Answer 6

正如 tangens 所說，數組的大小是固定的。 但是您必須先實例化它，否則它將只是一個空引用。

String[] where = new String[10];

此數組只能包含 10 個元素。 因此，您只能附加一個值 10 次。 在您的代碼中，您正在訪問一個空引用。 這就是為什么它不起作用。 為了擁有動態增長的集合，請使用 ArrayList。

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

Answer 8

我已經制作了這個代碼！ 它就像一個魅力！

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

我希望你喜歡它！！

Answer 9

您需要使用集合列表。 您不能重新調整數組的尺寸。

Answer 10

向字符串數組添加新項目。

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

Answer 11

有很多方法可以將元素添加到數組中。 您可以使用臨時List來管理元素，然后將其轉換回Array或者您可以使用java.util.Arrays.copyOf並將其與泛型結合以獲得更好的結果。

此示例將向您展示如何：

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

    return newArray;
}

要使用此方法，您只需像這樣調用它：

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

如果要合並兩個數組，可以像這樣修改以前的方法：

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

現在您可以像這樣調用該方法：

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

正如我提到的，您也可以使用List對象。 但是，它需要一點技巧才能像這樣安全地投射它：

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

現在您可以像這樣調用該方法：

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

Answer 12

如果您想將數據存儲在這樣的簡單數組中

String[] where = new String[10];

並且您想向其中添加一些元素，例如數字，請使用 StringBuilder，這比連接字符串更有效。

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

這是構建字符串並將其存儲到“where”數組中的更好方法。

Answer 13

我在 Java 方面經驗不多，但我一直被告知數組是具有預定義大小的靜態結構。 您必須使用 ArrayList 或 Vector 或任何其他動態結構。

Answer 14

您可以創建一個數組列表，並使用Collection.addAll()將字符串數組轉換為您的數組列表

Answer 15

你可以簡單地這樣做：

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

Answer 16

如果真的想調整數組的大小，您可以執行以下操作：

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]

Answer 17

數組的大小不能修改。 如果必須使用數組，可以使用：

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

Answer 18

也可以預先分配足夠大的內存大小。 這是一個簡單的堆棧實現：程序應該輸出 3 和 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]);
    }
}

Answer 19

它沒有編譯，因為數組沒有名為 append 的函數更好，正確的方法是使用 ArrayList

import java.util.ArrayList;

ArrayList where = new ArrayList<String>();

where.add(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1")
where.add(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1")