एक ऐरे (जावा)

Question

से तत्व निकालना जावा में किसी सरणी से तत्व निकालने के लिए कोई तेज़ (और अच्छा दिखने वाला) तरीका है?

Answer 1

आप कॉमन्स लैंग के ArrayUtils इस्तेमाल कर सकते हैं।

array = ArrayUtils.removeElement(array, element) 

commons.apache.org library:Javadocs

Answer 2

आप मूल जावा सरणी से कोई तत्व नहीं हटा सकते हैं। इसके बजाय विभिन्न संग्रह और ArrayList पर एक नज़र डालें।

Answer 3

ज़रूर, एक और सारिणी निर्मित :)

Answer 4

अच्छा देख समाधान पहली जगह में सरणी के बजाय एक सूची का उपयोग करने के लिए होगा।

List.remove(index) 

आप है तो सरणियों उपयोग करने के लिए, System.arraycopy करने के लिए दो कॉल सबसे अधिक संभावना सबसे तेजी से किया जाएगा।

Foo[] result = new Foo[source.length - 1]; 
System.arraycopy(source, 0, result, 0, index); 
if (source.length != index) { 
    System.arraycopy(source, index + 1, result, index, source.length - index - 1); 
} 

(Arrays.asList भी सरणियों के साथ काम करने के लिए एक अच्छे उम्मीदवार है, लेकिन यह remove समर्थन करने के लिए प्रतीत नहीं होता।)

Answer 5

एक ArrayList उपयोग:

alist.remove(1); //removes the element at position 1 

Answer 6

मुझे आशा है कि आप का उपयोग जावा संग्रह/जावा कॉमन्स संग्रह! तत्व हटा दिया जाना चाहिए के बिना किसी अन्य सरणी में

yourArrayList.remove(someObject); 

yourArrayList.add(someObject); 

Answer 7

Copy अपने मूल सरणी,:

एक java.util.ArrayList के साथ आप निम्नलिखित की तरह कर सकते हैं।

ऐसा करने का एक आसान तरीका सूची का उपयोग करना है, सेट करें ... और निकालें() विधि का उपयोग करें।

Answer 8

आइटम को अंतिम आइटम से हटाया जाना चाहिए, यदि सरणी का आकार बदलना कोई रूचि नहीं है।

Answer 9

ठीक है, THX एक बहुत अब मैं sth इस तरह का उपयोग करें:

public static String[] removeElements(String[] input, String deleteMe) { 
    if (input != null) { 
     List<String> list = new ArrayList<String>(Arrays.asList(input)); 
     for (int i = 0; i < list.size(); i++) { 
      if (list.get(i).equals(deleteMe)) { 
       list.remove(i); 
      } 
     } 
     return list.toArray(new String[0]); 
    } else { 
     return new String[0]; 
    } 
} 

Answer 10

सबसे अच्छा विकल्प एक संग्रह का उपयोग करने के होगा, लेकिन अगर वह किसी कारण से बाहर है, arraycopy का उपयोग करें। आप इसे थोड़ा अलग ऑफ़सेट पर उसी सरणी से कॉपी करने के लिए उपयोग कर सकते हैं।

उदाहरण के लिए: टिप्पणी करने के लिए

जवाब में

public void removeElement(Object[] arr, int removedIdx) { 
    System.arraycopy(arr, removedIdx + 1, arr, removedIdx, arr.length - 1 - removedIdx); 
} 

---

संपादित करें:

यह एक और अच्छा तरीका नहीं है, यह वास्तव में ही स्वीकार्य तरीका है।

संग्रह को आवंटित करने के लिए (एक नई सरणी बनाता है), फिर एक तत्व को हटाएं (जो संग्रह एरेकॉपी का उपयोग करेगा), फिर प्रत्येक डिलीट के लिए उस पर ऐरे (एक नई नई सरणी बनाता है) को कॉल करें जहां यह है एक अनुकूलन मुद्दा नहीं, यह अपराधी रूप से खराब प्रोग्रामिंग है।

मान लीजिए कि आपके पास 100 एमबी रैम कहने वाला सरणी है। अब आप इसे फिर से चालू करना चाहते हैं और 20 तत्वों को हटा देना चाहते हैं।

इसे आज़मा कर देखें ...

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

Answer 11

आपका प्रश्न बहुत स्पष्ट नहीं है। अपने उत्तर से, मैं बेहतर बता सकता हूं कि आप क्या करने का प्रयास कर रहे हैं:

public static String[] removeElements(String[] input, String deleteMe) { 
    List result = new LinkedList(); 

    for(String item : input) 
     if(!deleteMe.equals(item)) 
      result.add(item); 

    return result.toArray(input); 
} 

एनबी: यह अनचाहे है। त्रुटि जांच पाठक के लिए एक अभ्यास के रूप में छोड़ी गई है (अगर मैं इनपुट या हटा देता हूं तो मैं अवैध अवैध त्रुटि को फेंक दूंगा। शून्य शून्य सूची इनपुट पर एक खाली सूची समझ में नहीं आती है। सरणी को हटाने से सरणी से स्ट्रिंग्स समझ में आ सकते हैं, लेकिन मैं ' भी एक व्यायाम के रूप में छोड़ देंगे कि, जब यह कॉल करने के लिए कोशिश करता है deleteMe पर बराबर होती है अगर deleteMe रिक्त है वर्तमान में, यह एक एनपीई फेंक होगा)

विकल्प मैं यहाँ बनाया:

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

Answer 12

आप इसे "अच्छे दिखने वाले तरीके" में हटाने के लिए ArrayUtils API का उपयोग कर सकते हैं। यह Arrays पर कई संचालन (हटाने, खोजने, जोड़ने, शामिल, आदि) लागू करता है।
एक नज़र डालें। इसने मेरा जीवन आसान बना दिया है।

Answer 13

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

निम्न स्तर की प्रदर्शन सामग्री के लिए, यह आमतौर पर लूप के लिए त्वरित और गंदे अनिवार्य राज्य-मिलिंग द्वारा अप्रचलित होता है। उस मामले में संग्रह और सरणी के बीच आगे और पीछे परिवर्तित करना बोझिल, अपठनीय, और यहां तक ​​कि संसाधन गहन भी।

वैसे, टॉपकोडर, कोई भी? हमेशा उन सरणी पैरामीटर! तो अखाड़ा में उन्हें संभालने में सक्षम होने के लिए तैयार रहें।

नीचे समस्या की मेरी व्याख्या है, और एक समाधान है। यह बिल के और जेलोवर्ट द्वारा दी गई दोनों की कार्यक्षमता में भिन्न है। साथ ही, जब यह तत्व सरणी में नहीं होता है तो यह गहराई से केस को संभालता है।

आशा है कि मदद करता है!

public char[] remove(char[] symbols, char c) 
{ 
    for (int i = 0; i < symbols.length; i++) 
    { 
     if (symbols[i] == c) 
     { 
      char[] copy = new char[symbols.length-1]; 
      System.arraycopy(symbols, 0, copy, 0, i); 
      System.arraycopy(symbols, i+1, copy, i, symbols.length-i-1); 
      return copy; 
     } 
    } 
    return symbols; 
} 

Answer 14

कुछ और पूर्व की स्थिति विधेयक कश्मीर द्वारा लिखित लोगों के लिए की जरूरत है और dadinn

Object[] newArray = new Object[src.length - 1]; 
if (i > 0){ 
    System.arraycopy(src, 0, newArray, 0, i); 
    } 

if (newArray.length > i){ 
     System.arraycopy(src, i + 1, newArray, i, newArray.length - i); 
    } 

    return newArray; 

Answer 15

आप एक सरणी की लंबाई को बदल नहीं सकते हैं, लेकिन आप मूल्यों सूचकांक द्वारा धारण बदल सकते हैं नए मानों की प्रतिलिपि बनाना और उन्हें मौजूदा इंडेक्स नंबर पर स्टोर करना। 1 = माइक, 2 = जेफ // 10 = जॉर्ज 11 1 ओवरराइटिंग माइक पर जाता है।

Object[] array = new Object[10]; 
    int count=-1; 

    public void myFunction(String string) { 
     count++; 
     if(count == array.length) { 
      count = 0; // overwrite first 
     } 
     array[count] = string;  
    }