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

【问题标题】：How to add new elements to an array?如何向数组中添加新元素？
【发布时间】：2011-02-20 01:32:54
【问题描述】：

我有以下代码：

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

这两个附加没有编译。这将如何正常工作？

【问题讨论】：

虽然这个问题已经有 10 年了，而且比较列表和数组之间的差异很重要，但令人惊讶的是，我必须滚动多深才能找到实际添加新元素的结果数组，正如 OP 最初要求的那样

标签： java arrays string

【解决方案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 );

【讨论】：

如果你可以用 ArrayList 做同样的事情，那么使用 Array 有什么意义呢？
@tangens。我是 android 新手，但你的回答帮助了我。在找到答案之前我浪费了很多时间
@Skoua 数组更有效。预定义对象大小允许编译器优化内存。对于某些应用程序，这很重要。在现代计算机上运行的小型应用程序可能会在内存成为问题之前摆脱大量列表。
关于区别：这是一个不同的问题Array or List in Java. Which is faster? - Stack Overflow

【解决方案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 Tutorials/Arrays
- 数组是一个容器对象，它包含固定数量的单一类型值。数组的长度是在创建数组时确定的。创建后，它的长度是固定的。
Java Tutorials/The List interface

【讨论】：

每次容量不够时可以将数组大小加倍。这样 append 将被摊销 O(1)。可能是ArrayList 在内部所做的。

【解决方案3】：

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

String[] where = new String[10];

这个数组只能包含 10 个元素。因此，您只能附加一个值 10 次。在您的代码中，您正在访问一个空引用。这就是为什么它不起作用。为了拥有一个动态增长的集合，使用 ArrayList。

【讨论】：

【解决方案4】：

我在 Java 方面的经验并不多，但我一直被告知数组是具有预定义大小的静态结构。您必须使用 ArrayList 或 Vector 或任何其他动态结构。

【讨论】：

【解决方案5】：

您需要使用收藏列表。您不能重新调整数组的尺寸。

【讨论】：

【解决方案6】：

数组上没有方法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"
};

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

【讨论】：

那么参数化查询也接受 ArrayList 作为 selectionArgs 吗？

【解决方案7】：

如果您想将数据存储在这样的简单数组中

String[] where = new String[10];

如果您想向其中添加一些元素，例如数字，请使用 StringBuilder，它比连接字符串更有效。

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

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

【讨论】：

【解决方案8】：

您可以创建一个数组列表，并使用Collection.addAll() 将字符串数组转换为您的数组列表

【讨论】：

【解决方案9】：

数组的大小不能修改。如果必须使用数组，可以使用：

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

【讨论】：

【解决方案10】：

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

【讨论】：

【解决方案11】：

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

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

【讨论】：

这应该是公认的答案，考虑到“不要使用 x，使用 y”不是“如何使用 x”的答案，而是“哪些替代品比 x 更好？”

【解决方案12】：

向字符串数组添加新项目。

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

【讨论】：

啊，我明白了，您使用了<code> 标签，这对泛型类型有问题。请尽量避免使用这个标签，因为......它有问题，并用 4 个空格缩进你的代码以获得正确的格式。我是为你的问题这样做的:)。

【解决方案13】：

你可以这样做：

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

【讨论】：

【解决方案14】：

Apache Commons Lang 有

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

它返回一个新数组，但如果您出于某种原因真的在使用数组，这可能是执行此操作的理想方法。

【讨论】：

【解决方案15】：

我已经编写了这段代码！它就像一个魅力！

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

希望你喜欢！！

【讨论】：

【解决方案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]

【讨论】：

【解决方案17】：

有很多方法可以将元素添加到数组中。您可以使用临时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));

【讨论】：

newArray[elements.length] = element;，你的意思是newArray[elements.length - 1] = element; 吗？

【解决方案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]);
    }
}

【讨论】：

【解决方案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")

【讨论】：