อาร์เรย์ไม่เปลี่ยนรูปใน Java

มีทางเลือกที่ไม่เปลี่ยนรูปแบบไปยังอาร์เรย์ดั้งเดิมใน Java หรือไม่? การสร้างอาร์เรย์แบบดั้งเดิมfinalนั้นไม่ได้ขัดขวางการทำสิ่งที่ต้องการ

final int[] array = new int[] {0, 1, 2, 3};
array[0] = 42;

ฉันต้องการให้องค์ประกอบของอาร์เรย์ไม่สามารถเปลี่ยนแปลงได้

ไม่ได้อยู่กับอาร์เรย์ดั้งเดิม คุณจะต้องใช้รายการหรือโครงสร้างข้อมูลอื่น:

List<Integer> items = Collections.unmodifiableList(Arrays.asList(0,1,2,3));

คำแนะนำของฉันคือการไม่ใช้อาร์เรย์หรือunmodifiableListแต่ใช้งานฝรั่ง 's ImmutableListซึ่งมีอยู่เพื่อการนี้

ImmutableList<Integer> values = ImmutableList.of(0, 1, 2, 3);

ดังที่คนอื่น ๆ สังเกตคุณไม่สามารถมีอาร์เรย์ที่ไม่เปลี่ยนรูปแบบใน Java

หากคุณต้องการวิธีที่คืนค่าอาร์เรย์ที่ไม่ส่งผลกระทบต่ออาร์เรย์เดิมคุณต้องทำการโคลนอาร์เรย์ทุกครั้ง:

public int[] getFooArray() {
  return fooArray == null ? null : fooArray.clone();
}

เห็นได้ชัดว่านี่ค่อนข้างแพง (เพราะคุณจะสร้างสำเนาฉบับเต็มทุกครั้งที่คุณโทรหาผู้ทะเยอทะยาน) แต่ถ้าคุณไม่สามารถเปลี่ยนอินเทอร์เฟซ (ให้ใช้ Listตัวอย่าง) และไม่สามารถเสี่ยงต่อการเปลี่ยนไคลเอนต์ของคุณได้ มันอาจจำเป็น

เทคนิคนี้เรียกว่าการทำสำเนาป้องกัน

มีวิธีหนึ่งในการสร้างอาร์เรย์ที่ไม่เปลี่ยนรูปแบบใน Java:

final String[] IMMUTABLE = new String[0];

อาร์เรย์ที่มีองค์ประกอบ 0 (ชัด) ไม่สามารถกลายพันธุ์ได้

วิธีนี้มีประโยชน์จริง ๆ ถ้าคุณใช้List.toArrayวิธีการแปลงเป็นListอาร์เรย์ เนื่องจากแม้แต่อาเรย์ที่ว่างก็ใช้หน่วยความจำบางส่วนคุณสามารถบันทึกการจัดสรรหน่วยความจำนั้นโดยการสร้างอาเรย์ที่ว่างคงที่และส่งผ่านไปยังtoArrayเมธอดเสมอ วิธีการที่จะจัดสรรอาร์เรย์ใหม่หากอาร์เรย์คุณผ่านไม่ได้มีพื้นที่เพียงพอ แต่ถ้ามันไม่ (รายการว่างเปล่า) ก็จะกลับอาร์เรย์ที่คุณผ่านช่วยให้คุณสามารถนำมาใช้อาร์เรย์ว่าทุกครั้งที่คุณโทรtoArrayบน Listว่างเปล่า

final static String[] EMPTY_STRING_ARRAY = new String[0];

List<String> emptyList = new ArrayList<String>();
return emptyList.toArray(EMPTY_STRING_ARRAY); // returns EMPTY_STRING_ARRAY

อีกหนึ่งคำตอบ

static class ImmutableArray<T> {
    private final T[] array;

    private ImmutableArray(T[] a){
        array = Arrays.copyOf(a, a.length);
    }

    public static <T> ImmutableArray<T> from(T[] a){
        return new ImmutableArray<T>(a);
    }

    public T get(int index){
        return array[index];
    }
}

{
    final ImmutableArray<String> sample = ImmutableArray.from(new String[]{"a", "b", "c"});
}

ในฐานะของ Java 9 คุณสามารถใช้List.of(...), JavaDoc JavaDoc

วิธีนี้จะส่งกลับไม่เปลี่ยนรูปListและมีประสิทธิภาพมาก

หากคุณต้องการ (สำหรับเหตุผลด้านประสิทธิภาพหรือเพื่อบันทึกหน่วยความจำ) เนทีฟ 'int' แทน 'java.lang.Integer' คุณอาจต้องเขียนคลาส wrapper ของคุณเอง มีการใช้งาน IntArray ต่างๆในสุทธิไม่มี (ผมพบว่า) เป็นไม่เปลี่ยนรูปมี แต่: Koders IntArray , Lucene IntArray อาจมีคนอื่น ๆ

ตั้งแต่ฝรั่ง 22 จากแพคเกจที่คุณสามารถใช้สามชั้นเรียนใหม่ซึ่งมีรอยความทรงจำที่ต่ำกว่าเมื่อเทียบกับcom.google.common.primitivesImmutableList

• ImmutableIntArray
• ImmutableLongArray
• ImmutableDoubleArray

พวกเขายังมีผู้สร้าง ตัวอย่าง:

int size = 2;
ImmutableLongArray longArray = ImmutableLongArray.builder(size)
  .add(1L)
  .add(2L)
  .build();

หรือถ้าขนาดเป็นที่รู้จักกันในเวลารวบรวม:

ImmutableLongArray longArray = ImmutableLongArray.of(1L, 2L);

นี่เป็นอีกวิธีหนึ่งในการรับมุมมองที่ไม่เปลี่ยนรูปของอาเรย์สำหรับจาวาแบบดั้งเดิม

ไม่เป็นไปไม่ได้ อย่างไรก็ตามเราสามารถทำสิ่งนี้:

List<Integer> temp = new ArrayList<Integer>();
temp.add(Integer.valueOf(0));
temp.add(Integer.valueOf(2));
temp.add(Integer.valueOf(3));
temp.add(Integer.valueOf(4));
List<Integer> immutable = Collections.unmodifiableList(temp);

สิ่งนี้ต้องการการใช้ wrappers และเป็นรายการไม่ใช่อาร์เรย์ แต่เป็นสิ่งที่ใกล้เคียงที่สุดที่คุณจะได้รับ

ในบางสถานการณ์มันจะมีน้ำหนักเบากว่าในการใช้วิธีการคงที่จากห้องสมุด Google Guava: List<Integer> Ints.asList(int... backingArray)

ตัวอย่าง:

• List<Integer> x1 = Ints.asList(0, 1, 2, 3)
• List<Integer> x1 = Ints.asList(new int[] { 0, 1, 2, 3})

หากคุณต้องการหลีกเลี่ยงทั้งความไม่แน่นอนและการชกมวยไม่มีวิธีออกจากกล่อง แต่คุณสามารถสร้างคลาสที่เก็บอาเรย์ดั้งเดิมไว้ภายในและให้การเข้าถึงองค์ประกอบแบบอ่านอย่างเดียวผ่านวิธีการ

วิธีการขององค์ประกอบ (E ... )ในJava9สามารถใช้ในการสร้างรายการที่ไม่เปลี่ยนรูปโดยใช้เพียงบรรทัด:

List<Integer> items = List.of(1,2,3,4,5);

วิธีการข้างต้นส่งกลับรายการที่ไม่เปลี่ยนรูปที่มีจำนวนองค์ประกอบโดยพลการ และการเพิ่มจำนวนเต็มใด ๆ ในรายการนี้จะส่งผลให้เกิดjava.lang.UnsupportedOperationExceptionข้อยกเว้น วิธีนี้ยังยอมรับอาร์เรย์เดียวเป็นอาร์กิวเมนต์

String[] array = ... ;
List<String[]> list = List.<String[]>of(array);

ในขณะที่มันเป็นความจริงที่ใช้Collections.unmodifiableList()งานได้บางครั้งคุณอาจมีห้องสมุดขนาดใหญ่ที่มีวิธีการที่กำหนดไว้แล้วเพื่อส่งกลับอาร์เรย์ (เช่นString[]) เพื่อป้องกันไม่ให้แตกคุณสามารถกำหนดอาร์เรย์เสริมที่จะเก็บค่า:

public class Test {
    private final String[] original;
    private final String[] auxiliary;
    /** constructor */
    public Test(String[] _values) {
        original = new String[_values.length];
        // Pre-allocated array.
        auxiliary = new String[_values.length];
        System.arraycopy(_values, 0, original, 0, _values.length);
    }
    /** Get array values. */
    public String[] getValues() {
        // No need to call clone() - we pre-allocated auxiliary.
        System.arraycopy(original, 0, auxiliary, 0, original.length);
        return auxiliary;
    }
}

ทดสอบ:

    Test test = new Test(new String[]{"a", "b", "C"});
    System.out.println(Arrays.asList(test.getValues()));
    String[] values = test.getValues();
    values[0] = "foobar";
    // At this point, "foobar" exist in "auxiliary" but since we are 
    // copying "original" to "auxiliary" for each call, the next line
    // will print the original values "a", "b", "c".
    System.out.println(Arrays.asList(test.getValues()));

ไม่สมบูรณ์แบบ แต่อย่างน้อยคุณมี "อาร์เรย์ที่ไม่เปลี่ยนรูปแบบหลอก" (จากมุมมองของชั้นเรียน) และสิ่งนี้จะไม่ทำลายรหัสที่เกี่ยวข้อง

ดี .. อาร์เรย์มีประโยชน์ในการผ่านเป็นค่าคงที่ (ถ้าพวกเขา) เป็นพารามิเตอร์ตัวแปร