배열에 새로운 요소를 추가하는 방법?

다음 코드가 있습니다.

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>. 배열과 달리 동적으로 확장 가능합니다 ( 유효한 Java 2 판, 항목 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)작업 당 비용 이 상각되었습니다.

또한보십시오

• 자바 튜토리얼 / 배열
  • 배열은 단일 유형의 고정 된 수의 값을 보유하는 컨테이너 객체입니다. 배열의 길이는 배열을 만들 때 설정됩니다. 생성 후에는 길이가 고정됩니다.
• 자바 튜토리얼 /리스트 인터페이스

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"
};

그러나 이것은 고정 크기이며 요소를 추가 할 수 없습니다.

tangens가 말했듯이 배열의 크기는 고정되어 있습니다. 그러나 먼저 인스턴스화해야합니다. 그렇지 않으면 null 참조 일뿐입니다.

String[] where = new String[10];

이 배열은 10 개의 요소 만 포함 할 수 있습니다. 따라서 값을 10 회만 추가 할 수 있습니다. 귀하의 코드에서 null 참조에 액세스하고 있습니다. 그것이 작동하지 않는 이유입니다. 동적으로 증가하는 컬렉션을 가지려면 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[] 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);

배열에 요소를 추가하는 방법에는 여러 가지가 있습니다. temp 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]);
    }
}