Bir diziye yeni öğeler nasıl eklenir?

Takip koduna sahibim:

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

Bu iki ek derlenmemektedir. Bu nasıl düzgün çalışır?

Bir dizinin boyutu değiştirilemez. Daha büyük bir dizi istiyorsanız, yeni bir dizi oluşturmalısınız.

Daha iyi bir çözüm, ArrayListihtiyaç duyduğunuzda büyüyebilecek olanı kullanmak olacaktır . Yöntem ArrayList.toArray( T[] a ), bu formda ihtiyacınız varsa dizinizi geri verir.

List<String> where = new ArrayList<String>();
where.add( ContactsContract.Contacts.HAS_PHONE_NUMBER+"=1" );
where.add( ContactsContract.Contacts.IN_VISIBLE_GROUP+"=1" );

Basit bir diziye dönüştürmeniz gerekiyorsa ...

String[] simpleArray = new String[ where.size() ];
where.toArray( simpleArray );

Ancak bu ArrayList ile yapabileceğiniz bir dizi ile yaptığınız çoğu şey:

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

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

List<String>Gibi a kullanın ArrayList<String>. Dizilerden farklı olarak dinamik olarak büyütülebilir (bkz: Etkili Java 2.Baskı, Madde 25: Dizileri listeler tercih edin ).

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]"

Dizileri kullanmakta ısrar ederseniz java.util.Arrays.copyOf, ek öğeyi karşılamak için daha büyük bir dizi ayırmak için kullanabilirsiniz . Bu gerçekten en iyi çözüm değil.

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]"

Bu O(N)başına append. ArrayListÖte yandan, O(1)işletme başına amortismana tabi tutulmuştur.

Ayrıca bakınız

• Java Eğiticileri / Dizileri
  • Dizi, tek bir türün sabit sayıda değerini tutan bir konteyner nesnesidir. Dizi oluşturulduğunda bir dizinin uzunluğu belirlenir. Oluşturulduktan sonra uzunluğu sabittir.
• Java Eğiticileri / Liste arayüzü

Apache Commons Lang

T[] t = ArrayUtils.add( initialArray, newitem );

yeni bir dizi döndürür, ancak bir nedenden dolayı dizilerle gerçekten çalışıyorsanız, bunu yapmanın ideal yolu olabilir.

Burada görmediğim ve "karmaşık" Nesneler veya Koleksiyonlar içermeyen başka bir seçenek var.

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()Dizilerde yöntem yoktur . Bunun yerine, daha önce önerildiği gibi, bir List nesnesi dinamik olarak eleman ekleme ihtiyacına hizmet edebilir.

List<String> where = new ArrayList<String>();
where.add(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.add(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");

Veya bir dizi kullanmaya gerçekten hevesliyseniz:

String[] where = new String[]{
    ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1",
    ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1"
};

ancak bu sabit bir boyuttur ve hiçbir öğe eklenemez.

Teğetlerin dediği gibi, bir dizinin boyutu sabittir. Ama önce onu başlatmalısınız, aksi takdirde sadece boş bir referans olacaktır.

String[] where = new String[10];

Bu dizi yalnızca 10 öğe içerebilir. Böylece sadece 10 kez bir değer ekleyebilirsiniz. Kodunuzda boş bir referansa erişiyorsunuz. Bu yüzden çalışmıyor. Dinamik olarak büyüyen bir koleksiyona sahip olmak için ArrayList'i kullanın.

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

Bu kodu ben yaptım! Mucizevi şekilde çalışır!

public String[] AddToStringArray(String[] oldArray, String newString)
{
    String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1);
    newArray[oldArray.length] = newString;
    return newArray;
}

Umarım beğenmişsindir!!

Bir Koleksiyon Listesi kullanmanız gerekir. Bir diziyi yeniden boyutlandıramazsınız.

Verilerinizi böyle basit bir dizide saklamak istiyorsanız

String[] where = new String[10];

ve sayılar gibi bazı öğeler eklemek istiyorsanız lütfen bize StringBuilder olan dizeyi birleştirmekten çok daha verimlidir.

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

Bu, dizenizi oluşturmak ve 'nerede' dizinize kaydetmek için çok daha iyi bir yöntemdir.

Dize dizisine yeni öğeler ekleme.

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

Bir diziye öğe eklemenin birçok yolu vardır. Bir temp kullanabilirsiniz Listelemanı yönetmek ve daha sonra geri dönüştürmek için Arrayya da kullanabilirsinizjava.util.Arrays.copyOf daha iyi sonuçlar elde etmek için öğesini ve jeneriklerle birleştirebilirsiniz.

Bu örnek size nasıl olduğunu gösterecektir:

public static <T> T[] append2Array(T[] elements, T element)
{
    T[] newArray = Arrays.copyOf(elements, elements.length + 1);
    newArray[elements.length] = element;

    return newArray;
}

Bu yöntemi kullanmak için sadece şöyle çağırmanız gerekir:

String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, "four");
System.out.println(Arrays.toString(numbers));

İki diziyi birleştirmek istiyorsanız, önceki yöntemi şu şekilde değiştirebilirsiniz:

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

Şimdi böyle yöntemi çağırabilirsiniz:

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

Bahsettiğim gibi Listnesneleri de kullanabilirsiniz . Ancak, bunu güvenli bir şekilde yayınlamak için küçük bir kesmek gerekir:

public static <T> T[] append2Array(Class<T[]> clazz, List<T> elements, T element)
{
    elements.add(element);
    return clazz.cast(elements.toArray());
}

Şimdi böyle yöntemi çağırabilirsiniz:

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

Ben Java'da deneyimli değilim ama her zaman dizilerin önceden tanımlanmış bir boyuta sahip statik yapılar olduğu söylendi. Bir ArrayList veya Vector veya başka bir dinamik yapı kullanmanız gerekir.

bir arraylist oluşturabilir ve Collection.addAll()dize dizisini arraylistinize dönüştürmek için kullanabilirsiniz

Bunu basitçe yapabilirsiniz:

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

Bir dizi gerçekten yeniden boyutlandırmak istiyorsanız, böyle bir şey yapabilirsiniz:

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]

Dizi boyutu değiştirilemez. Bir dizi kullanmanız gerekiyorsa şunları kullanabilirsiniz:

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

Yeterince büyük bellek boyutu önceden tahsis etmek de mümkündür. İşte basit bir yığın uygulaması: programın çıktı 3 ve 5 olması gerekiyor.

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