क्या रिटर्न प्रकार का उपयोग किये बिना दो int arrays को सम्मिलित करना संभव है?

Question

इस विशेष समस्या पर मैं काम कर रहा हूं जैसे कि

ConcatArrays (int [] listA, int [] listB, int [] listC) कोई वापसी प्रकार नहीं है। 1. विधि औपचारिक सरणी पैरामीटर सूची ए और listB पास करती है, फिर concatenated सरणी सूची सी वापस। 2. सूचीसी के पहले भाग में ऐसे तत्व होते हैं जो सूची ए के संबंधित तत्वों के समान होते हैं और दूसरे भाग में सूची बी के समान तत्व होते हैं। ListC की लंबाई सूची ए। लम्बाई + सूची बी। लम्बाई है।

यह मेरे पास है और जाहिर है कि यह काम नहीं करेगा। क्या यह तीसरे पैरामीटर के रूप में वापसी प्रकार/सूची सी को हटाने के बिना भी करना संभव है?

public static void ConcatArray(int[] listA, int[] listB, int[] listC) 
    { 
     int aLen = listA.length ; 
     int bLen = listB.length; 
     int cLen = listC[aLen + bLen]; 
    } 

संपादित करें: मैं सभी उत्तरों के सभी की सराहना करता हूं, मैंने उन सभी को वोट दिया। यह एक होमवर्क असाइनमेंट था और इसे फिर से पढ़ने के बाद मेरा मानना ​​है कि कोई वापसी प्रकार एक त्रुटि नहीं था क्योंकि उसने प्रश्न 1 में कहा था। मूल रूप से पैरामीटर सूची बी और लिस्टा का उपयोग करके सूची सी वापस करने के लिए कह रहा है। इससे पहले कि उन्होंने सही किया है, वहां कई अन्य टाइपो थे। उन्होंने हमें हमारे टेस्ट क्लास के मूल्यों के साथ सरणी 1 और सरणी 2 भी दिया, लेकिन कोई सरणी नहीं 3.

Answer 1

जावा सरणी बनने के बाद, आप इसका आकार बदल नहीं सकते हैं। आपका कोड काम नहीं करता है क्योंकि एक सरणी संदर्भ मान द्वारा पारित किया जाता है, और जावा संदर्भ द्वारा गुजरता नहीं है।

सरणी रिटर्निंग जावा में इस के हल के लिए मुहावरेदार तरीका है:

public static int[] ConcatArray(int[] listA, int[] listB) { 
    int[] res = new int[listA.length + listB.length]; 
    ... 
    return res; 
} 

आप कर सकते हैं एक परिवर्तनशील प्रकार इच्छित प्रकार के एक क्षेत्र, इस तरह है कि के माध्यम से संदर्भ द्वारा नकली गुजर:

class IntArrayRef { 
    int[] array; 
} 

अब तुम इस तरह अपने void विधि लिख सकते हैं:

public static void ConcatArray(int[] listA, int[] listB, IntArrayRef res) { 
    res.array = new int[listA.length + listB.length]; 
    ... 
} 

हालांकि, अगर आप ऐसा करने में परेशानी से गुजरते हैं, तो आप सरणी को भी वापस कर सकते हैं।

Answer 2

चाल यह जानती है कि एक सरणी की सामग्री विधि को पारित नहीं होती है। एक सरणी की सामग्री को पढ़ और लिखा जा सकता है लेकिन एक को लिखना मूल को बदल देता है। जब तक आप स्वयं को नया नहीं करते हैं तब तक जावा आपके लिए एक नई प्रतिलिपि नहीं बनाता है। इसका मतलब यह है कि आप जो पास हुए थे उसमें बस डूडलिंग करके जानकारी वापस भेज सकते हैं। जब तक आप व्यवहार को दस्तावेज करते हैं तब तक यह ठीक है, इसलिए जब कोई डेटा अलविदा जाता है तो विधि का उपयोग करने वाला कोई आश्चर्यचकित नहीं होता है।

public static void main(String[] args) 
{ 
    int[] a = {0, 1}; 
    int[] b = {2, 3}; 
    int[] c = new int[a.length + b.length]; 

    concatArray(a, b, c); 

    for (int i : c) 
    { 
     System.out.println(i); 
    } 
} 

/** Concatenates prefix and suffix into result which must be as large as both */ 
public static void concatArray(int[] prefix, int[] suffix, int[] result) 
{ 
    int prefixLength = prefix.length; 
    int suffixLength = suffix.length; 

    if(result.length < prefixLength + suffixLength) 
    { 
     throw new IllegalArgumentException(); 
    } 

    for (int i = 0; i< prefixLength; i++) 
    { 
     result[i] = prefix[i]; 
    } 

    for (int i = 0; i< prefixLength; i++) 
    { 
     result[i+prefixLength] = suffix[i]; 
    } 
} 

उत्पादन:

0 
1 
2 
3 

यह वही चाल जब तक वे अपरिवर्तनीय नहीं हैं वस्तुओं के साथ काम करता है। अगर कोई आपको बीन सौंपता है तो आप इसके सेटर्स के साथ खेलने के लिए स्वतंत्र हैं और यदि आपको ऐसा नहीं करना था, तो सभी तरह के विनाश का कारण बनता है।

यही कारण है कि एक सरणी या ऑब्जेक्ट के पहचानकर्ता को अंतिम होने के लिए अपरिवर्तनीयता की गारंटी नहीं है। कोई भी सेटिंग सेटिंग (यदि वे ऑब्जेक्ट पर मौजूद हैं) को कॉल कर सकते हैं या सरणी में नए असाइनमेंट कर सकते हैं। सभी अंतिम करता है पहचानकर्ता को ऑब्जेक्ट या सरणी हैंडकफ। यह 'ब्रीफकेस' को लॉक नहीं करता है। सेटर्स से छुटकारा पाने से ब्रीफकेस लॉक हो जाता है।

यही वह है जिसे हम अपरिवर्तनीय कहते हैं।स्ट्रिंग्स अपरिवर्तनीय हैं और यही कारण है कि यह चाल स्ट्रिंग्स के साथ काम नहीं करेगी।

जब आप किसी विधि से गुजरते हैं तो ऐसा लगता है कि आपने पहचानकर्ता को अंतिम बनाया है। आप कॉलिंग संदर्भ के बिना सरणी या ऑब्जेक्ट को बदल नहीं सकते हैं जिसके साथ आप खेल रहे हैं इसका ट्रैक खोना। यदि आप एक ही सरणी या ऑब्जेक्ट से चिपके रहते हैं तो आप इसके साथ जितना अधिक अनुमति दे सकते हैं और कॉलिंग संदर्भ जो कुछ भी आपने किया है उसे देखेंगे।

वास्तव में, जब भी आप वास्तव में लौट रहे हैं, उसके अलावा आप कुछ भी वापस लौटते हैं, तो यह एक नया स्थान है और कह रहा है: "मैंने जो बनाया है उसे देखें"। यह चाल बस पूर्व ज्ञात स्थानों से चिपके हुए काम करती है।

Answer 3

वास्तव में, कोई भी सरल ऐरे का उपयोग नहीं करता है क्योंकि आप इसका आकार बदल नहीं सकते हैं, या जोड़/हटा सकते हैं। अधिकांश प्रोग्रामर ArrayList क्लास का उपयोग करते हैं क्योंकि यह अधिक लचीला और शक्तिशाली है।

करने वाली अपने ArrayList में एक चर स्थिति हो रही है -किसी अपने ArrayList

 cities.add("Alexandria"); 

करने के लिए एक चर जोड़ने -किसी ArrayList वर्ग

 java.util.ArrayList<String> cities = new java.util.ArrayList<String>(); 

का एक उदाहरण बनाने

 cities.indexOf("Cairo")); 

- अपनी सरणीसूची से पहले चर को हटाने के लिए (यह शून्य सरणी की तरह शून्य है)

 cities.remove(0); 

-किसी अपने ArrayList की लंबाई हो रही

 cities.size(); 

ArrayList वर्ग के बारे में अधिक के लिए जावा प्रलेखन पर एक नज़र रखना http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html