อะไรคือสาเหตุที่ฉันไม่สามารถสร้างประเภทอาร์เรย์ทั่วไปใน Java ได้

เหตุผลที่ Java ไม่อนุญาตให้เราทำอะไร

private T[] elements = new T[initialCapacity];

ฉันสามารถเข้าใจ. NET ไม่อนุญาตให้เราทำเช่นนั้นใน. NET คุณมีประเภทค่าที่เวลาทำงานสามารถมีขนาดแตกต่างกัน แต่ใน Java T ทุกชนิดจะเป็นการอ้างอิงวัตถุจึงมีขนาดเดียวกัน ( ช่วยแก้ให้ด้วยนะถ้าฉันผิด).

เหตุผลคืออะไร

เป็นเพราะอาร์เรย์ของ Java (ต่างจาก generics) มีข้อมูลเกี่ยวกับประเภทส่วนประกอบ ดังนั้นคุณต้องรู้ประเภทส่วนประกอบเมื่อคุณสร้างอาร์เรย์ เนื่องจากคุณไม่ทราบว่าเกิดอะไรขึ้นTตอนรันไทม์คุณไม่สามารถสร้างอาร์เรย์ได้

อ้างถึง:

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

class Box<T> {
    final T x;
    Box(T x) {
        this.x = x;
    }
}

class Loophole {
    public static void main(String[] args) {
        Box<String>[] bsa = new Box<String>[3];
        Object[] oa = bsa;
        oa[0] = new Box<Integer>(3); // error not caught by array store check
        String s = bsa[0].x; // BOOM!
    }
}

เราได้เสนอให้แก้ไขปัญหานี้โดยใช้อาร์เรย์ที่ปลอดภัยแบบคงที่ (aka Variance) bute ที่ถูกปฏิเสธสำหรับ Tiger

- gafter

(ฉันเชื่อว่านี่คือNeal Gafterแต่ไม่แน่ใจ)

ดูในบริบทที่นี่: http://forums.sun.com/thread.jspa?threadID=457033&forumID=316

เมื่อไม่สามารถให้ทางออกที่ดีคุณจะพบกับสิ่งที่เลวร้ายยิ่งกว่า IMHO

การทำงานทั่วไปมีดังนี้

T[] ts = new T[n];

ถูกแทนที่ด้วย (สมมติว่า T ขยายวัตถุและไม่ใช่คลาสอื่น)

T[] ts = (T[]) new Object[n];

ฉันชอบตัวอย่างแรก แต่มีประเภทวิชาการมากกว่าที่จะชอบอันดับที่สองหรือเพียง แต่ไม่ชอบคิด

ตัวอย่างส่วนใหญ่ของสาเหตุที่คุณไม่สามารถใช้ Object [] นำไปใช้กับรายการหรือชุดสะสม (ซึ่งได้รับการสนับสนุน) อย่างเท่าเทียมกันดังนั้นฉันจึงเห็นว่ามันเป็นอาร์กิวเมนต์ที่แย่มาก

หมายเหตุ: นี่เป็นหนึ่งในเหตุผลที่ห้องสมุด Collections ไม่ได้รวบรวมโดยไม่มีคำเตือน หากคุณไม่สามารถใช้งานเคสได้หากไม่มีคำเตือนจะมีบางอย่างเสียไปกับรุ่นทั่วไปของ IMHO

อาร์เรย์มีความแปรปรวน

อาร์เรย์จะกล่าวว่าเป็น covariant ซึ่งโดยทั่วไปหมายความว่าให้กฎ subtyping ชวาอาร์เรย์ของชนิดT[]อาจมีองค์ประกอบของประเภทหรือชนิดย่อยของT Tตัวอย่างเช่น

Number[] numbers = new Number[3];
numbers[0] = newInteger(10);
numbers[1] = newDouble(3.14);
numbers[2] = newByte(0);

แต่ไม่เพียงแค่นั้นกฎการพิมพ์ย่อยของ Java ยังระบุว่าอาเรย์S[]นั้นเป็นประเภทย่อยของอาเรย์ด้วยT[]หากSเป็นประเภทย่อยTดังนั้นบางสิ่งเช่นนี้ก็ใช้ได้เช่นกัน:

Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;

เนื่องจากตามกฎการพิมพ์ย่อยใน Java อาร์เรย์Integer[]จึงเป็นชนิดย่อยของอาร์เรย์Number[]เนื่องจากจำนวนเต็มเป็นประเภทย่อยของ Number

แต่กฎย่อยนี้สามารถนำไปสู่คำถามที่น่าสนใจ: จะเกิดอะไรขึ้นถ้าเราพยายามทำเช่นนี้?

myNumber[0] = 3.14; //attempt of heap pollution

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

ซึ่งหมายความว่าเราสามารถหลอกผู้แปล แต่เราไม่สามารถหลอกระบบประเภทเวลาทำงาน และนี่ก็เป็นเช่นนั้นเพราะอาร์เรย์เป็นสิ่งที่เราเรียกว่าชนิดที่เรียกคืนได้ ซึ่งหมายความว่าในช่วงเวลาทำงาน Java Number[]รู้ว่าอาร์เรย์นี้ที่อินสแตนซ์จริงเป็นอาร์เรย์ของจำนวนเต็มซึ่งก็เกิดขึ้นจะเข้าถึงได้ผ่านการอ้างอิงของพิมพ์

อย่างที่เราเห็นสิ่งหนึ่งคือประเภทของวัตถุจริงอีกอย่างคือประเภทของการอ้างอิงที่เราใช้เข้าถึงมันใช่ไหม?

ปัญหาเกี่ยวกับ Java Generics

ตอนนี้ปัญหาเกี่ยวกับประเภททั่วไปใน Java คือข้อมูลประเภทสำหรับพารามิเตอร์ชนิดจะถูกยกเลิกโดยคอมไพเลอร์หลังจากรวบรวมรหัสเสร็จ; ดังนั้นข้อมูลประเภทนี้จะไม่สามารถใช้ได้ในเวลาทำงาน กระบวนการนี้เรียกว่าลบออกประเภท มีเหตุผลที่ดีสำหรับการใช้งาน generics เช่นนี้ใน Java แต่นั่นเป็นเรื่องที่ยาวและเกี่ยวข้องกับความเข้ากันได้ของไบนารีกับโค้ดที่มีอยู่แล้ว

จุดสำคัญที่นี่คือตั้งแต่เวลาทำงานไม่มีข้อมูลประเภทไม่มีวิธีการตรวจสอบให้แน่ใจว่าเราไม่ได้กระทำมลพิษกอง

ลองพิจารณารหัสที่ไม่ปลอดภัยต่อไปนี้

List<Integer> myInts = newArrayList<Integer>();
myInts.add(1);
myInts.add(2);
List<Number> myNums = myInts; //compiler error
myNums.add(3.14); //heap polution

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

ดังนั้นผู้ออกแบบของ Java ทำให้แน่ใจว่าเราไม่สามารถหลอกผู้แปล ถ้าเราไม่สามารถหลอกคอมไพเลอร์ได้ (อย่างที่เราสามารถทำได้กับอาเรย์) จากนั้นเราก็ไม่สามารถหลอกระบบประเภทเวลาทำงานได้เช่นกัน

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

ฉันข้ามบางส่วนของคำตอบนี้คุณสามารถอ่านบทความเต็มได้ที่นี่: https://dzone.com/articles/covariance-and-contravariance

เหตุผลที่เป็นไปไม่ได้คือ Java ใช้ Generics ในระดับคอมไพเลอร์และมีไฟล์คลาสเดียวที่สร้างขึ้นสำหรับแต่ละคลาส นี้เรียกว่าประเภทลบ

ณ รันไทม์คลาสที่คอมไพล์ต้องจัดการกับการใช้งานทั้งหมดด้วย bytecode เดียวกัน ดังนั้นnew T[capacity]จะไม่มีความคิดแน่นอนว่าประเภทใดที่ต้องมีการยกตัวอย่าง

ได้รับคำตอบแล้ว แต่ถ้าคุณมีอินสแตนซ์ของ T อยู่แล้วคุณสามารถทำได้:

T t; //Assuming you already have this object instantiated or given by parameter.
int length;
T[] ts = (T[]) Array.newInstance(t.getClass(), length);

หวังว่าฉันจะช่วยได้ Ferdi265

สาเหตุหลักเกิดจากความจริงที่ว่าอาร์เรย์ใน Java นั้นแปรปรวน

มีภาพรวมที่ดีเป็นที่นี่

ผมชอบคำตอบที่ได้รับทางอ้อมโดยGafter อย่างไรก็ตามฉันเสนอว่ามันผิด ฉันเปลี่ยนรหัสของ Gafter เล็กน้อย มันรวบรวมและวิ่งไปชั่วขณะหนึ่งแล้วมันก็จะระเบิดซึ่งหลังจากนั้นก็ทำนายว่ามันจะ

class Box<T> {

    final T x;

    Box(T x) {
        this.x = x;
    }
}

class Loophole {

    public static <T> T[] array(final T... values) {
        return (values);
    }

    public static void main(String[] args) {

        Box<String> a = new Box("Hello");
        Box<String> b = new Box("World");
        Box<String> c = new Box("!!!!!!!!!!!");
        Box<String>[] bsa = array(a, b, c);
        System.out.println("I created an array of generics.");

        Object[] oa = bsa;
        oa[0] = new Box<Integer>(3);
        System.out.println("error not caught by array store check");

        try {
            String s = bsa[0].x;
        } catch (ClassCastException cause) {
            System.out.println("BOOM!");
            cause.printStackTrace();
        }
    }
}

ผลลัพธ์คือ

I created an array of generics.
error not caught by array store check
BOOM!
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at Loophole.main(Box.java:26)

ดังนั้นสำหรับฉันคุณสามารถสร้างประเภทอาร์เรย์ทั่วไปใน java ได้ ฉันเข้าใจผิดคำถามหรือไม่?

ฉันรู้ว่าฉันมางานปาร์ตี้ช้านิดหน่อย แต่ฉันคิดว่าฉันอาจจะสามารถช่วยเหลือชาว Google ในอนาคตได้เนื่องจากไม่มีคำตอบใด ๆ เหล่านี้ที่สามารถแก้ไขปัญหาของฉันได้ คำตอบของ Ferdi265 ช่วยได้มาก

ฉันกำลังพยายามสร้างรายการที่เชื่อมโยงของตัวเองดังนั้นรหัสต่อไปนี้เป็นสิ่งที่ใช้ได้กับฉัน:

package myList;
import java.lang.reflect.Array;

public class MyList<TYPE>  {

    private Node<TYPE> header = null;

    public void clear() {   header = null;  }

    public void add(TYPE t) {   header = new Node<TYPE>(t,header);    }

    public TYPE get(int position) {  return getNode(position).getObject();  }

    @SuppressWarnings("unchecked")
    public TYPE[] toArray() {       
        TYPE[] result = (TYPE[])Array.newInstance(header.getObject().getClass(),size());        
        for(int i=0 ; i<size() ; i++)   result[i] = get(i); 
        return result;
    }


    public int size(){
         int i = 0;   
         Node<TYPE> current = header;
         while(current != null) {   
           current = current.getNext();
           i++;
        }
        return i;
    }  

ในเมธอด toArray () เป็นวิธีสร้างอาร์เรย์ของประเภททั่วไปสำหรับฉัน:

TYPE[] result = (TYPE[])Array.newInstance(header.getObject().getClass(),size());    

ในกรณีของฉันฉันแค่ต้องการชุดของสแต็คดังนี้:

Stack<SomeType>[] stacks = new Stack<SomeType>[2];

เนื่องจากสิ่งนี้เป็นไปไม่ได้ฉันจึงใช้วิธีการต่อไปนี้เป็นวิธีแก้ปัญหา:

1. สร้างคลาส wrapper ที่ไม่ใช่แบบทั่วไปรอบ ๆ สแต็ก (พูด MyStack)
2. MyStack [] stacks = ใหม่ MyStack [2] ทำงานได้ดีอย่างสมบูรณ์

น่าเกลียด แต่ Java มีความสุข

หมายเหตุ: ดังกล่าวโดย BrainSlugs83 ในความคิดเห็นคำถามมันเป็นไปได้โดยสิ้นเชิงที่จะมีอาร์เรย์ของ generics ใน. NET

จากบทช่วยสอนของ Oracle :

คุณไม่สามารถสร้างอาร์เรย์ของประเภทพารามิเตอร์ ตัวอย่างเช่นรหัสต่อไปนี้ไม่ได้รวบรวม:

List<Integer>[] arrayOfLists = new List<Integer>[2];  // compile-time error

รหัสต่อไปนี้แสดงให้เห็นถึงสิ่งที่เกิดขึ้นเมื่อใส่ประเภทที่แตกต่างกันลงในอาร์เรย์:

Object[] strings = new String[2];
strings[0] = "hi";   // OK
strings[1] = 100;    // An ArrayStoreException is thrown.

หากคุณลองทำสิ่งเดียวกันกับรายการทั่วไปจะมีปัญหา:

Object[] stringLists = new List<String>[];  // compiler error, but pretend it's allowed
stringLists[0] = new ArrayList<String>();   // OK
stringLists[1] = new ArrayList<Integer>();  // An ArrayStoreException should be thrown,
                                            // but the runtime can't detect it.

หากอนุญาตให้ใช้อาร์เรย์ของรายการที่กำหนดพารามิเตอร์รหัสก่อนหน้านี้จะล้มเหลวในการโยน ArrayStoreException ที่ต้องการ

สำหรับฉันมันฟังดูอ่อนแอมาก ฉันคิดว่าทุกคนที่มีความเข้าใจอย่างเพียงพอเกี่ยวกับยาชื่อสามัญจะดีอย่างสมบูรณ์และยังคาดหวังว่า ArrayStoredException จะไม่ถูกโยนในกรณีดังกล่าว

ต้องมีวิธีที่ดีรอบ ๆ (อาจใช้การสะท้อน) เพราะฉันคิดว่านั่นเป็นสิ่งที่ArrayList.toArray(T[] a)ทำ ฉันพูด:

public <T> T[] toArray(T[] a)

ส่งคืนอาร์เรย์ที่มีองค์ประกอบทั้งหมดในรายการนี้ตามลำดับที่ถูกต้อง ชนิดรันไทม์ของอาร์เรย์ที่ส่งคืนคือของอาร์เรย์ที่ระบุ หากรายการเหมาะสมกับอาร์เรย์ที่ระบุรายการนั้นจะถูกส่งคืน มิฉะนั้นอาร์เรย์ใหม่จะถูกจัดสรรด้วยประเภทรันไทม์ของอาร์เรย์ที่ระบุและขนาดของรายการนี้

ดังนั้นวิธีหนึ่งก็คือการใช้ฟังก์ชั่นนี้เช่นสร้างArrayListวัตถุที่คุณต้องการในอาร์เรย์จากนั้นใช้toArray(T[] a)เพื่อสร้างอาร์เรย์จริง มันจะไม่เร็ว แต่คุณไม่ได้พูดถึงความต้องการของคุณ

ดังนั้นไม่มีใครรู้วิธีtoArray(T[] a)การใช้งาน?

มันเป็นเพราะยาชื่อสามัญถูกเพิ่มลงในจาวาหลังจากที่พวกเขาทำมันดังนั้นจึงเป็นเรื่องที่ไม่น่าสนใจเพราะผู้ผลิตจาวาดั้งเดิมคิดว่าเมื่อสร้างอาร์เรย์ประเภทจะถูกระบุในการสร้างมัน ดังนั้นมันจึงไม่ทำงานกับยาชื่อสามัญดังนั้นคุณต้องทำ E [] array = (E []) วัตถุใหม่ [15]; คอมไพล์นี้ แต่มันให้คำเตือน

หากเราไม่สามารถยกตัวอย่างอาร์เรย์ทั่วไปทำไมภาษามีประเภทอาร์เรย์ทั่วไป? จุดที่มีประเภทไม่มีวัตถุคืออะไร?

เหตุผลเดียวที่ฉันสามารถคิดเป็น varargs foo(T...)- มิฉะนั้นพวกเขาอาจมีประเภทอาร์เรย์ทั่วไปที่ขัดอย่างสมบูรณ์ (พวกเขาไม่จำเป็นต้องใช้อาร์เรย์สำหรับ varargs เนื่องจาก varargs ไม่มีอยู่ก่อน1.5นั่นอาจเป็นความผิดพลาดอีกครั้ง)

ดังนั้นจึงเป็นเรื่องโกหกคุณสามารถยกตัวอย่างอาร์เรย์ทั่วไปผ่าน varargs!

แน่นอนปัญหาเกี่ยวกับอาร์เรย์ทั่วไปยังคงเป็นจริงเช่น

static <T> T[] foo(T... args){
    return args;
}
static <T> T[] foo2(T a1, T a2){
    return foo(a1, a2);
}

public static void main(String[] args){
    String[] x2 = foo2("a", "b"); // heap pollution!
}

เราสามารถใช้ตัวอย่างนี้เพื่อแสดงให้เห็นถึงอันตรายของอาร์เรย์ทั่วไป

ในทางกลับกันเราได้ใช้วาร์argsทั่วไปมาสิบปีแล้วและท้องฟ้ายังไม่ตกลง ดังนั้นเราสามารถยืนยันได้ว่าปัญหามีการพูดเกินจริง มันไม่ได้เป็นเรื่องใหญ่. หากอนุญาตให้สร้างอาร์เรย์ทั่วไปอย่างชัดเจนเราจะมีจุดบกพร่องที่นี่และที่นั่น แต่เราคุ้นเคยกับปัญหาของการลบและเราสามารถอยู่กับมันได้

และเราสามารถชี้ไปที่foo2การหักล้างข้อเรียกร้องที่สเป็คทำให้เราไม่ได้รับจากปัญหาที่พวกเขาอ้างว่าปกป้องเราจาก ถ้าซอนมีเวลาและทรัพยากรมากขึ้นสำหรับ1.5ฉันเชื่อว่าพวกเขาจะได้รับการแก้ไขที่น่าพอใจมากขึ้น

เป็นคนอื่น ๆ ที่กล่าวถึงแล้วคุณแน่นอนสามารถสร้างทางเทคนิคบางอย่าง

แต่ไม่แนะนำ

เพราะการลบประเภทและที่สำคัญกว่าคือcovarianceในอาเรย์ที่เพิ่งอนุญาตให้อาเรย์ย่อยสามารถกำหนดให้กับอาเรย์แบบ Supertype ซึ่งบังคับให้คุณใช้การพิมพ์แบบชัดแจ้งเมื่อพยายามรับค่ากลับมาClassCastExceptionซึ่งเป็นหนึ่งในวัตถุประสงค์หลัก ที่ generics พยายามที่จะกำจัด: Stronger การตรวจสอบชนิดที่รวบรวมเวลา

Object[] stringArray = { "hi", "me" };
stringArray[1] = 1;
String aString = (String) stringArray[1]; // boom! the TypeCastException

ตัวอย่างโดยตรงมากขึ้นสามารถพบได้ในที่มีประสิทธิภาพ Java: รายการที่ 25

ความแปรปรวนร่วม : อาร์เรย์ของประเภท S [] เป็นประเภทย่อยของ T [] ถ้า S เป็นประเภทย่อยของ T

หากคลาสใช้เป็นชนิดที่กำหนดพารามิเตอร์จะสามารถประกาศอาร์เรย์ประเภท T [] แต่ไม่สามารถสร้างอินสแตนซ์ของอาร์เรย์นั้นได้โดยตรง แต่วิธีการทั่วไปคือการสร้างอาเรย์ของประเภทวัตถุ [] จากนั้นจึงทำการร่ายแบบแคบ ๆ เพื่อพิมพ์ T [] ดังที่แสดงในรายการต่อไปนี้:

  public class Portfolio<T> {
  T[] data;
 public Portfolio(int capacity) {
   data = new T[capacity];                 // illegal; compiler error
   data = (T[]) new Object[capacity];      // legal, but compiler warning
 }
 public T get(int index) { return data[index]; }
 public void set(int index, T element) { data[index] = element; }
}

ลองสิ่งนี้:

List<?>[] arrayOfLists = new List<?>[4];