如何向数组中添加新元素?

我有以下代码:

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

这两个追加没有编译。这是如何正确工作的?

1576966 次浏览
小开
最佳答案

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

更好的解决方案是使用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 );

但你用数组做的大多数事情，你也可以用这个数组列表做:

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


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

使用List<String>，例如ArrayList<String>。它是动态增长的，不像数组(参见:Effective Java 2nd Edition, Item 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)。

另请参阅

  • Java教程/数组
    • 数组是一个容器对象，它包含固定数量的单一类型的值。数组的长度是在创建数组时建立的。在创建之后，它的长度是固定的。
      • 李< / ul > < / >
    • Java教程/The List interface .
小开

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

String[] where = new String[10];

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

小开
我在Java方面不是很有经验，但我总是被告知数组是具有预定义大小的静态结构。 你必须使用一个数组列表或向量或任何其他动态结构
小开

您需要使用收集列表。不能重新定义数组的维数。

小开

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

但这是一个固定的大小，没有元素可以添加。

小开

如果你想把数据存储在这样一个简单的数组中

String[] where = new String[10];

你想要添加一些元素，比如数字StringBuilder，这比连接字符串要有效得多。

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

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

小开

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

小开

数组大小不可修改。如果你必须使用数组，你可以使用:

System.arraycopy(src, srcpos, dest, destpos, length);
小开 
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);
}
小开

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

String[] array1 = new String[]{"one", "two"};
String[] array2 = new String[]{"three"};


// declare a new array with enough space for all elements
String[] combinedArray = new String[array1.length + array2.length];


// copy the separate arrays into the combined array
System.arraycopy(array1, 0, combinedArray, 0, array1.length);
System.arraycopy(array2, 0, combinedArray, 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);
小开

你可以简单地这样做:

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

Apache Commons Lang有

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]
小开

向数组中添加元素的方法有很多种。您可以使用临时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对象。然而，它将需要一个小hack来安全地转换它，像这样:

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的函数更好，正确的方法是使用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")

提交答案