ऐरे और शिफ्ट इंडेक्स में कोई तत्व कैसे जोड़ें?

Question

मुझे स्थिति और मूल्य निर्दिष्ट करने वाले ऐरे में एक तत्व जोड़ने की आवश्यकता है। उदाहरण के लिए, मैं सरणी

int []a = {1, 2, 3, 4, 5, 6}; 

लागू करने addPos (पूर्णांक 4, इंट 87) के बाद यह

int []a = {1, 2, 3, 4, 87, 5}; 

मैं समझता हूँ कि यहाँ सरणी के इंडेक्सों का एक बदलाव होना चाहिए, लेकिन ऐसा नहीं होना चाहिए कोड में इसे कार्यान्वित करने का तरीका देखें।

Answer 1

ऐसा करने का सबसे आसान तरीका ArrayList<Integer> का उपयोग करना है और add(int, T) विधि का उपयोग करना है।

List<Integer> list = new ArrayList<Integer>(); 
list.add(1); 
list.add(2); 
list.add(3); 
list.add(4); 
list.add(5); 
list.add(6); 

// Now, we will insert the number 
list.add(4, 87); 

Answer 2

मैं इसके बजाय "पाली अनुक्रमणिका" करने के लिए एक रास्ता तलाश के होमवर्क गंध, तो शायद एक ArrayList अनुमति नहीं दी जाएगी

, हो सकता है सिर्फ एक नई सरणी का निर्माण (?):

int[] b = new int[a.length +1]; 

फिर

1. प्रतिलिपि अनुक्रमित रूप सरणी एक शून्य से गिनती पदों सम्मिलित करने के लिए ऊपर n
2. ...
3. ...

// संपादित: निश्चित रूप से प्रतिलिपि मूल्यों, नहीं अनुक्रमित

Answer 3

आप एक नई सरणी बनाने के लिए, System.arraycopy का उपयोग उपसर्ग और प्रत्यय कॉपी करने के लिए चाहिए, और उस नए स्लॉट पर एक स्लॉट सेट करें।

Answer 4

इस चाल करना चाहिए:

public static int[] addPos(int[] a, int pos, int num) { 
    int[] result = new int[a.length]; 
    for(int i = 0; i < pos; i++) 
     result[i] = a[i]; 
    result[pos] = num; 
    for(int i = pos + 1; i < a.length; i++) 
     result[i] = a[i - 1]; 
    return result; 
} 

कहाँ a मूल सरणी है, pos प्रविष्टि की स्थिति है, और num संख्या डाला जा रहा है।

String[] prependedArray = new ArrayList<String>() { 
    { 
    add("newElement"); 
    addAll(Arrays.asList(originalArray)); 
    } 
}.toArray(new String[0]); 

Answer 5

यहाँ एक अर्ध oneliner कि यह करता है। यह arrayCopy() का उपयोग करता है, लेकिन इसमें अच्छा सिंटैक्स है। तत्व-दर-तत्व कोड के साथ उत्तर देने वालों के लिए: यदि यह होमवर्क नहीं है, तो यह मामूली है और दिलचस्प उत्तर वह है जो पुन: उपयोग को बढ़ावा देता है। उन लोगों के लिए जो सूचियों का प्रस्ताव देते हैं: शायद पाठकों को भी इसके बारे में पता है और प्रदर्शन मुद्दों का उल्लेख किया जाना चाहिए।

Answer 6

commons पर एक नज़र डालें:

Answer 7

प्रयास करें इस

public static int [] insertArry (int inputArray[], int index, int value){ 
    for(int i=0; i< inputArray.length-1; i++) { 

     if (i == index){ 

      for (int j = inputArray.length-1; j >= index; j--){ 
       inputArray[j]= inputArray[j-1]; 
      } 

      inputArray[index]=value; 
     } 

    } 
    return inputArray; 
} 

Answer 8

public class HelloWorld{ 

    public static void main(String[] args){ 
     int[] LA = {1,2,4,5}; 
     int k = 2; 
     int item = 3; 
     int j = LA.length; 
     int[] LA_NEW = new int[LA.length+1]; 


     while(j >k){ 
      LA_NEW[j] = LA[j-1]; 
      j = j-1; 
     } 
     LA_NEW[k] = item; 
     for(int i = 0;i<k;i++){ 
      LA_NEW[i] = LA[i]; 
     } 
     for(int i : LA_NEW){ 
      System.out.println(i); 
     } 
    } 
} 

Answer 9

int[] b = new int[a.length +1]; 
System.arraycopy(a,0,b,0,4); 
//System.arraycopy(srcArray, srcPosition, destnArray, destnPosition, length) 
b[4]=87; 
System.arraycopy(a,4,b,5,2); 

ख सरणी के रूप में बनाया किया जाएगा {1, 2, 3, 4, 87, 5,6};

Answer 10

System.arraycopy अधिक प्रदर्शनकारी है लेकिन सूचकांक गणनाओं के कारण सही होने के लिए मुश्किल है। यदि आपके पास प्रदर्शन आवश्यकताओं की आवश्यकता नहीं है तो jrad उत्तर या ArrayList के साथ बेहतर छड़ी।

public static int[] insert(
    int[] array, int elementToInsert, int index) { 
    int[] result = new int[array.length + 1]; 
    // copies first part of the array from the start up until the index 
    System.arraycopy(
     array /* src */, 
     0 /* srcPos */, 
     result /* dest */, 
     0 /* destPos */, 
     index /* length */); 
    // copies second part from the index up until the end shifting by 1 to the right 
    System.arraycopy(
     array /* src */, 
     index /* srcPos */, 
     result /* dest */, 
     index + 1 /* destPos */, 
     array.length - index /* length */); 
    result[index] = elementToInsert; 
    return result; 
} 

और यह जांचने के लिए JUnit4 परीक्षण अपेक्षित कार्य करता है।

@Test 
public void shouldInsertCorrectly() { 
    Assert.assertArrayEquals(
     new int[]{1, 2, 3}, insert(new int[]{1, 3}, 2, 1)); 
    Assert.assertArrayEquals(
     new int[]{1}, insert(new int[]{}, 1, 0)); 
    Assert.assertArrayEquals(
     new int[]{1, 2, 3}, insert(new int[]{2, 3}, 1, 0)); 
    Assert.assertArrayEquals(
     new int[]{1, 2, 3}, insert(new int[]{1, 2}, 3, 2)); 
} 

Answer 11

जेड समाधान अच्छा है लेकिन मुझे यह पसंद नहीं है कि वह सरणी प्रति का उपयोग नहीं करता है। आंतरिक रूप से System.arraycopy() एक मूल कॉल करता है ताकि आपको तेजी से परिणाम मिल सकें।

public static int[] addPos(int[] a, int index, int num) { 
    int[] result = new int[a.length]; 
    System.arraycopy(a, 0, result, 0, index); 
    System.arraycopy(a, index, result, index + 1, a.length - index - 1); 
    result[index] = num; 
    return result; 
} 

Answer 12

org.apache.commons.lang3.ArrayUtils#add(T[], int, T) नवीनतम कॉमन्स lang3 में हटाई गई है, आप org.apache.commons.lang3.ArrayUtils#insert(int, T[], T...) बजाय उपयोग कर सकते हैं।

बहिष्कृत इस विधि को डालने (int, टी [], टी ...) द्वारा हटा दिया गया है और भविष्य में रिलीज में हटाया जा सकता है। कृपया ध्यान दें अशक्त इनपुट सरणियों की हैंडलिंग नई विधि में अंतर होता है: अशक्त में एक अशक्त सरणी परिणामों में डालने एक्स नहीं एक्स

नमूना कोड:

Assert.assertArrayEquals 
      (org.apache.commons.lang3.ArrayUtils.insert 
      (4, new int[]{1, 2, 3, 4, 5, 6}, 87), new int[]{1, 2, 3, 4, 87, 5, 6});