कैसे स्वचालित रूप से सरणी

Question

की कक्षा मुझे पता है कि कैसे (यदि यह संभव है) मैं एक डेटा लेआउट Array of Class का उपयोग कर एक जावा वर्ग कार्यक्रम सकता है चाहते हैं, उदाहरण के लिए करने के लिए वर्गों का सरणी से कन्वर्ट करने के लिए:

public class X{ 

    double a; 
    double b; 
    double c; 
} 

public X array_of_x[SIZE] = new X [SIZE]; 

लेकिन आंतरिक रूप से डेटा इस तरह Class of Arrays के लेआउट के रूप में की दुकान होगा:

public class X{ 

    double a[] = new double [SIZE]; 
    double b[] = new double [SIZE]; 
    double c[] = new double [SIZE]; 
} 

public X class_x = new X(); 

मेरे उद्देश्य है कि प्रोग्रामर पहले एक तरह एक अधिक सहज शैली में programed सकता है, लेकिन आंतरिक मैं परिवर्तनों करना होगा ताकि डेटा हो सकता है स्मृति में निरंतर, और मैं चाहता था अधिक प्रदर्शन प्राप्त करें।

क्या ऐसा करने का कोई तरीका है ताकि यह किसी भी वर्ग को पहले प्रकार की संरचना के साथ स्वीकार कर सके और इसे दूसरे दृष्टिकोण में परिवर्तित करने में सक्षम हो? (या कोई ऐसा उपकरण है जो इस प्रकार के परिवर्तन को करने में सक्षम है)।

Answer 1

चलिए एक इंटरफ़ेस बनाते हैं जो उपयोग के लिए पहला लेआउट प्रदर्शित करता है, और उस इंटरफ़ेस के लिए कार्यान्वयन जो आंतरिक रूप से दूसरे लेआउट का उपयोग करता है। (एक्सेस संशोधक कोड से छीन लिया।)

interface X { 
    double getA(); 
    double getB(); 
    double getC(); 
}; 

interface ArrayOfX { 
    X get(int index); 
}; 

class ContiguousArrayOfX implements ArrayOfX { 
    class ContiguousX implements X { 
     int index; 
     ContiguousX(int index) { 
      this.index = index; } 
     double getA() { return a[index]; } 
     double getB() { return b[index]; } 
     double getC() { return c[index]; } 
    } 

    X get(int index) { 
     return new ContiguousX(index); } 

    double a[] = new double [SIZE]; 
    double b[] = new double [SIZE]; 
    double c[] = new double [SIZE]; 
}; 

आप जीसी पर बोझ को कम करना चाहते हैं, तो आप भी ContiguousX के सभी उदाहरणों को कैश कर सकते। यह जेआईटी कंपाइलर की योग्यता पर काफी निर्भर करता है यदि ContiguousX ऑब्जेक्ट्स को ढेर पर आवंटित किया जाता है - वे ढेर में अच्छी तरह से रह सकते हैं, इस मामले में ओवरहेड नगण्य है। एक अंतिम उपाय के रूप में, आप तेजी से पहुँच के लिए एक वैकल्पिक इंटरफ़ेस परिभाषित कर सकते हैं:

interface FasterArrayOfX { 
    double getA(int index); 
    double getB(int index); 
    double getC(int index); 
}; 

class FasterContiguousArrayOfX extends ContiguousArrayOfX implements FasterArrayOfX { 
    // Exercise left to the reader 
}; 

एक अंतरफलक आप बाद में कभी भी भंडारण का चयन करने के लिए स्वतंत्र हैं के खिलाफ प्रोग्रामिंग करके।

किसी दिए गए वर्ग लेआउट के लिए कोड जेनरेटर लिखना सरल है। उपरोक्त कोड का उपयोग बॉयलरप्लेट के रूप में किया जा सकता है, केवल विधि और सरणी घोषणाएं उस क्लास लेआउट पर निर्भर होती हैं जिसे आप प्राप्त करना चाहते हैं। मुझे किसी भी मौजूदा उपकरण से अवगत नहीं है।