如何向数组添加新元素？

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

使用a List<String>,例如ArrayList<String>.与数组不同,它是可动态增长的(参见:Effective Java 2nd Edition,Item 25:Prefer list 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

有很多方法可以将元素添加到数组中。您可以使用 tempList来管理元素，然后将其转换回，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));