จะเพิ่มองค์ประกอบใหม่ลงในอาร์เรย์ได้อย่างไร?

ฉันมีรหัสต่อไปนี้:

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 2nd Edition, รายการ 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) ในทางกลับกันมีการตัดจำหน่ายต้นทุนต่อการดำเนินงานappendArrayListO(1)

ดูสิ่งนี้ด้วย

• Java Tutorials / Arrays
  • อาร์เรย์เป็นวัตถุคอนเทนเนอร์ที่เก็บค่าคงที่ประเภทเดียว ความยาวของอาร์เรย์จะถูกสร้างขึ้นเมื่อสร้างอาร์เรย์แล้ว หลังจากการสร้างความยาวของมันจะคงที่
• Java Tutorials / ส่วนต่อประสานรายการ

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

แต่นี่เป็นขนาดที่แน่นอนและไม่สามารถเพิ่มองค์ประกอบใด ๆ ได้

ตามที่ Tangen กล่าวไว้ขนาดของอาเรย์จะถูกแก้ไข แต่คุณต้องยกตัวอย่างก่อนอื่นไม่เช่นนั้นจะเป็นเพียงการอ้างอิงที่ไม่มีค่า

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

นี่เป็นวิธีที่ดีกว่าในการสร้างสตริงของคุณและเก็บไว้ในอาร์เรย์ 'ที่' ของคุณ

การเพิ่มรายการใหม่ไปยังอาร์เรย์สตริง

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 หรือโครงสร้างแบบไดนามิกอื่น ๆ

คุณสามารถสร้าง arraylist และใช้Collection.addAll()เพื่อแปลง array string เป็น 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]

ขนาดของอาร์เรย์ไม่สามารถแก้ไขได้ หากคุณต้องใช้อาร์เรย์คุณสามารถใช้:

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