Как добавить новые элементы в массив?

У меня есть следующий код:

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 list для массивов ).

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 / интерфейс List

Apache Commons Lang имеет

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

На 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];

Этот массив может содержать только 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 String[] AddToStringArray(String[] oldArray, String newString)
{
    String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1);
    newArray[oldArray.length] = newString;
    return newArray;
}

Я надеюсь тебе это понравится!!

Вам нужно использовать список сбора. Вы не можете изменить размер массива.

Если вы хотите хранить ваши данные в простом массиве, как это

String[] where = new String[10];

и вы хотите добавить к нему некоторые элементы, такие как числа, пожалуйста, используйте StringBuilder, который намного эффективнее, чем объединение строк.

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

Это гораздо лучший метод для построения вашей строки и сохранения ее в вашем массиве 'where'.

Добавление новых элементов в массив String.

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

Есть много способов добавить элемент в массив. Вы можете использовать временную схему 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));

Я не настолько опытен в Java, но мне всегда говорили, что массивы - это статические структуры, которые имеют предопределенный размер. Вы должны использовать ArrayList или Vector или любую другую динамическую структуру.

вы можете создать массив и использовать Collection.addAll()для преобразования массива строк в ваш список

Вы можете просто сделать это:

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]

Размер массива не может быть изменен. Если вам нужно использовать массив, вы можете использовать:

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

Также возможно предварительно выделить достаточно большой объем памяти. Вот простая реализация стека: программа должна выводить 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]);
    }
}