我有以下代码：
String[] where;
where.append(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.append(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");
这两个附件没有编译。这怎么会正常工作？
答案 0 :(得分：360)
无法修改数组的大小。如果你想要一个更大的数组，你必须实例化一个新数组。
更好的解决方案是使用可以根据需要增长的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 );
答案 1 :(得分：92)
使用List<String>，例如ArrayList<String>。与数组不同，它是可动态增长的（参见： Effective Java 2nd Edition，第25项：首选列表到数组）。
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)。
答案 2 :(得分：20)
Apache Commons Lang
T[] t = ArrayUtils.add( initialArray, newitem );
它返回一个新数组，但是如果你因为某种原因真的在使用数组，这可能是理想的方法。
答案 3 :(得分：20)
还有另一个选项，我在这里看不到，并且没有涉及＆＃34;复杂的＆＃34;对象或集合。
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);
答案 4 :(得分：12)
数组上没有方法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"
};
但是这是一个固定的大小，不能添加任何元素。
答案 5 :(得分：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);
}
答案 6 :(得分：6)
正如tangens所说，阵列的大小是固定的。但是你必须首先实例化它，否则它只是一个空引用。
String[] where = new String[10];
此数组只能包含10个元素。所以你只能追加一个值10次。在您的代码中，您正在访问空引用。这就是为什么它不起作用。为了拥有一个 动态增长集合，使用ArrayList。
答案 7 :(得分：5)
您需要使用收藏清单。您无法重新标注数组。
答案 8 :(得分：4)
如果您想将数据存储在这样的简单数组中
String[] where = new String[10];
并且你想为它添加一些元素，比如数字，请使用StringBuilder，它比连接字符串更有效。
StringBuilder phoneNumber = new StringBuilder();
phoneNumber.append("1");
phoneNumber.append("2");
where[0] = phoneNumber.toString();
这是构建字符串并将其存储到“where”数组中的更好方法。
答案 9 :(得分：4)
向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);
答案 10 :(得分：4)
我已经制作了这段代码！它就像一个魅力！
public String[] AddToStringArray(String[] oldArray, String newString)
{
String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1);
newArray[oldArray.length] = newString;
return newArray;
}
我希望你喜欢!!
答案 11 :(得分：4)
有很多方法可以将元素添加到数组中。您可以使用临时AppDelegate来管理元素，然后将其转换回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());
}
答案 12 :(得分：3)
我不是那种Java经验，但我总是被告知数组是具有预定义大小的静态结构。 您必须使用ArrayList或Vector或任何其他动态结构。
答案 13 :(得分：2)
你可以创建一个arraylist，并使用Collection.addAll()将字符串数组转换为你的arraylist
答案 14 :(得分：2)
你可以这样做：
System.arraycopy(initialArray, 0, newArray, 0, initialArray.length);
答案 15 :(得分：2)
如果真的想要调整数组的大小，你可以这样做：
{{1}}
答案 16 :(得分：1)
无法修改数组的大小。如果必须使用数组，可以使用System.arraycopy（src，srcpos，dest，destpos，length）;
答案 17 :(得分：0)
还可以预分配足够大的内存大小。这是一个简单的堆栈实现：该程序应该输出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]);
}
}
答案 18 :(得分：0)
它不是编译，因为数组没有名为 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")