Java 如何向数组中添加新元素？

我有以下代码：

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

---

这两个附录没有编译。如何正确工作？

数组的大小不能修改。如果你想要一个更大的数组，你必须实例化一个新的数组

一个更好的解决方案是使用一个可以根据需要增长的系统。方法

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

但使用数组执行的大多数操作也可以使用此ArrayList执行：

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

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

使用a，例如。它是动态增长的，与数组不同（请参阅：effectivejava2ndedition，第25项：首选列表而非数组）

这是

O（N）

per

append

<另一方面，code>ArrayList具有每次操作的摊余成本

另见

• • 数组是一个容器对象，它包含固定数量的单一类型的值。数组的长度是在创建数组时确定的。创建后，其长度是固定的

---

正如tangens所说，数组的大小是固定的。但是您必须首先实例化它，否则它将只是一个空引用

String[] where = new String[10];

此数组只能包含10个元素。因此，只能附加10次值。在代码中，您正在访问空引用。这就是它不起作用的原因。为了有一个

---

动态增长的集合，使用ArrayList。

我在Java方面没有太多经验，但我总是被告知数组是具有预定义大小的静态结构。

---

您必须使用ArrayList、Vector或任何其他动态结构。

您需要使用集合列表。无法重新对数组进行尺寸标注。

数组上没有方法

append（）

。相反，正如已经建议的那样，列表对象可以满足动态插入元素的需要，例如

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[10];

您想向它添加一些元素，如数字，请使用StringBuilder，它比串联字符串更有效

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

---

这是构建字符串并将其存储到“where”数组中的更好方法。

您可以创建一个arraylist，并使用

Collection.addAll（）

将字符串数组转换为arraylist

无法修改数组的大小。如果必须使用阵列，可以使用：

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

---

还有一个我在这里没有看到的选项，它不涉及“复杂”对象或集合

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

---

向字符串数组添加新项

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

String[]myArray=新字符串[]{“x”，“y”}；
//将数组转换为列表
List listFromArray=Arrays.asList（myArray）；
//创建新列表，因为“列表到数组”始终返回由指定数组支持的固定大小的列表。
列表模板列表=新的ArrayList（listFromArray）；
添加（“z”）；
//将列表转换回数组
String[]tempArray=新字符串[templast.size（）]；
myArray=templast.toArray（tempArray）；

您只需执行以下操作：

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

---

ApacheCommonsLang拥有

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

---

它返回一个新的数组，但是如果您真的因为某种原因使用数组，这可能是实现这一点的理想方法。

我编写了这段代码！它就像一个符咒

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

---

我希望你喜欢它

如果你真的想调整数组的大小，你可以这样做：

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]

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

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

---

向数组中添加元素的方法有很多种。您可以使用临时

列表

来管理元素，然后将其转换回

数组

，也可以使用

java.util.Array.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[] 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]

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

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

正如我提到的，您还可以使用

列表

对象。然而，它需要一点小技巧才能使其安全如下：

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]

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

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

---

也可以预先分配足够大的内存大小。下面是一个简单的堆栈实现：程序应该输出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]);
    }
}

---

它不是编译，因为数组没有名为append the better的函数，正确的方法是使用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")

import java.util.ArrayList；
ArrayList，其中=新的ArrayList（）；
其中.add（Contacts contract.Contacts.HAS_PHONE_NUMBER+“=1”）
其中.add（Contacts contract.Contacts.IN_VISIBLE_GROUP+“=1”）

每次容量不足时，您都可以将阵列的大小增加一倍。这样，追加将按O（1）摊销。可能是

ArrayList

内部所做的。那么参数化查询也接受ArrayList作为selectionArgs吗？啊，我知道了，您使用了

标记，这与泛型类型有关。请尽量避免使用此标签，因为。。。它有问题，并且用4个空格缩进代码以获得正确的格式。我这样做是为了回答你的问题：）。如果你能对ArrayList做同样的事情，那么使用Array有什么意义？@tangens。我对android是新手，但你的回答帮助了我。在找到答案之前，我浪费了很多时间hours@Skoua阵列效率更高。预先定义对象大小允许编译器优化内存。对于某些应用程序，它很重要。在现代计算机上运行的一个小应用程序可能在内存出现问题之前就可以处理大量的列表。
newArray[elements.length]=element
，您的意思是
newArray[elements.length-1]=element？虽然这个问题有+10年的历史，比较列表和数组之间的差异很重要，但令人惊讶的是，我不得不深入研究如何实际生成一个添加了新元素的数组，因为OP最初问这个问题，考虑到“不使用x，使用y”不是问题的答案，这应该是公认的答案“如何使用x”但“哪些替代方案比x更好？”