У меня есть следующий код:
String[] where;
where.append(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.append(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=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 );
Используйте 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)
амортизированную стоимость за операцию.
Апач Викискладе Ланг
T[] t = ArrayUtils.add( initialArray, newitem );
он возвращает новый массив, но если вы'вновь действительно работать с массивами по какой-то причине, это может быть идеальный способ сделать это.
Есть еще один вариант, который я еще'т видели здесь, и который не'т привлекать "в комплексе„ объекты или коллекции.
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);
Нет метод присоеденить () на массивы. Вместо этого, как уже предложили список объектов может обслуживать нужно динамически вставлять элементы, например.
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"
};
но тогда это фиксированный размер и элементы не могут быть добавлены.
Как сказал tangens, размер массива фиксирован. Но вы должны сначала инстанцировать его, иначе это будет только нулевая ссылка.
String[] where = new String[10];
Этот массив может содержать только 10 элементов. Поэтому вы можете добавить значение только 10 раз. В вашем коде вы обращаетесь к нулевой ссылке. Вот почему это не работает. Для того чтобы иметь динамически растущую коллекцию, используйте ArrayList.
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);
}
Есть много способов, чтобы добавить элемент в массив. Вы можете использовать "темп" список
, чтобы управлять элементом и затем преобразовать его обратно в массив
или вы можете использовать `Ява.утиль.Массивы.копию и объединить его с дженерики для улучшения результатов.
Этот пример покажет вам, как:
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));
Как я уже говорил, вы также можете использовать "список" объекты. Однако, это потребует немного рубить, чтобы бросить его безопасным такой:
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[] where = new String[10];
и вы хотите добавить некоторые элементы к нему, как цифры, пожалуйста, нам то StringBuilder, который является гораздо более эффективным, чем конкатенация строк.
StringBuilder phoneNumber = new StringBuilder();
phoneNumber.append("1");
phoneNumber.append("2");
where[0] = phoneNumber.toString();
Это гораздо лучше, способ построить вашу строку и хранить его в свой ', где' массив.
Добавление новых элементов в массив строк.
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);
Я'вэ сделал этот код! Он работает как шарм!
public String[] AddToStringArray(String[] oldArray, String newString)
{
String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1);
newArray[oldArray.length] = newString;
return newArray;
}
Я надеюсь, вам понравится!!
Я'м не то, что опытный в Java, но я всегда говорил, что массивы являются статическими структурами, которые имеют предопределенный размер. Вы должны использовать ArrayList и Л;строка>, или вектор или любой другой динамической структурой.
Вы можете просто сделать это:
System.arraycopy(initialArray, 0, newArray, 0, initialArray.length);
Если действительно хотите изменить размер массива, вы могли бы сделать что-то вроде этого:
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]
Размер массива не может быть изменен. Если вы должны использовать массив, вы можете использовать:
Системы.arraycopy(ГКЗ, srcpos, дест, destpos, длина);