मैं जावा में सरणी से ऑब्जेक्ट कैसे निकालूं?

82

N ऑब्जेक्ट्स की एक सरणी को देखते हुए , मान लीजिए कि यह स्ट्रिंग्स की एक सरणी है , और इसके निम्न मूल्य हैं:

foo[0] = "a";
foo[1] = "cc";
foo[2] = "a";
foo[3] = "dd";

सरणी में "ए" के बराबर सभी तार / वस्तुओं को हटाने / हटाने के लिए मुझे क्या करना है ?

java  arrays  data-structures  data-manipulation 
— ramayac
स्रोत
2
आप जावा में किसी सरणी का आकार परिवर्तन नहीं कर सकते। मुझे लगता है कि आप केवल तत्वों को शून्य नहीं करना चाहते हैं क्योंकि यह तुच्छ होगा। क्या आप अंतराल को हटाने के लिए अन्य तत्वों को स्थानांतरित करना चाहते हैं?
— दान डायर
1
यह तुच्छ है, अब मुझे पता है कि मैं यह कर सकता हूं। ;) धन्यवाद!
— रमैयाक

जवाबों:

112

[यदि आप कुछ रेडी-टू-यूज़ कोड चाहते हैं, तो कृपया मेरे "Edit3" (कट के बाद) पर स्क्रॉल करें। बाकी यहां पोस्टीरिटी के लिए है।]

बाहर मांस के Dustman का विचार :

List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);

संपादित करें: मैं अब Arrays.asListइसके बजाय उपयोग कर रहा हूं Collections.singleton: सिंगलटन एक प्रविष्टि तक सीमित है, जबकि asListदृष्टिकोण आपको बाद में फ़िल्टर करने के लिए अन्य तारों को जोड़ने की अनुमति देता है Arrays.asList("a", "b", "c"):।

Edit2: उपरोक्त दृष्टिकोण उसी सरणी को बनाए रखता है (इसलिए सरणी अभी भी एक ही लंबाई है); अंतिम के बाद वाला तत्व शून्य पर सेट है। यदि आप एक नया सरणी आकार चाहते हैं , तो इसके बजाय इसका उपयोग करें:

array = list.toArray(new String[0]);

Edit3: यदि आप एक ही कक्षा में इस कोड का बार-बार उपयोग करते हैं, तो आप इसे अपनी कक्षा में शामिल करने पर विचार कर सकते हैं:

private static final String[] EMPTY_STRING_ARRAY = new String[0];

तब फ़ंक्शन बन जाता है:

List<String> list = new ArrayList<>();
Collections.addAll(list, array);
list.removeAll(Arrays.asList("a"));
array = list.toArray(EMPTY_STRING_ARRAY);

यह तब बेकार खाली स्ट्रिंग सरणियों के साथ अपने ढेर को बंद करना बंद कर देगा जो अन्यथा newआपके फ़ंक्शन को कॉल किए जाने पर हर बार एड किया जाएगा ।

सिनिकलमैन का सुझाव (टिप्पणियों को देखें) ढेर कूड़े के साथ भी मदद करेगा, और निष्पक्षता के लिए मुझे इसका उल्लेख करना चाहिए:

array = list.toArray(new String[list.size()]);

मैं अपने दृष्टिकोण को पसंद करता हूं, क्योंकि स्पष्ट आकार को गलत करना आसान हो सकता है (जैसे, size()गलत सूची पर कॉल करना)।

— क्रिस जस्टर-यंग
स्रोत
खुशी है कि आपको पसंद आया। मैंने अपनी प्रविष्टि को संशोधित करते हुए "ए" के सभी उदाहरणों को हटाने का समर्थन किया , न कि केवल पहले। :-)
— क्रिस जस्टर-यंग
ओफ ... फिनिश लाइन पर नीचे गोली मार दी। जानता था कि मुझे संपादन करते रहना चाहिए। इस प्रणाली का उपयोग करने में कुछ समय लगता है। अच्छा संपादन!
— डस्टमैन
GHAD: क्या आपने मेरा Edit2 ऊपर पढ़ा है? यह वही बताता है जो आपने उल्लेख किया था, और यह आपकी पोस्ट से पहले पोस्ट किया गया था।
— क्रिस जस्टर-यंग
2
क्यों नहीं। सूची (नया स्ट्रिंग [list.size ()]) के बजाय नई स्ट्रिंग [0], क्योंकि कोड नए सरणी का उपयोग करेगा यदि यह सही आकार है?
— निंदक
हां, वह काम करता है। अन्यथा, कुछ कोड (जावा क्लास लाइब्रेरी में, मुख्य रूप से) स्ट्रिंग [0] (और अन्य समान शून्य-आकार के सरणियों) का एक स्थिर उदाहरण संग्रहीत करते हैं, और हर बार एक नया करने के बजाय स्थैतिक उदाहरणों को पास करते हैं। :-)
— क्रिस जस्टर-यंग
31

जावा 8 में एक विकल्प: 

String[] filteredArray = Arrays.stream(array)
    .filter(e -> !e.equals(foo)).toArray(String[]::new);
— विटाली फेडोरेंको
स्रोत
यह स्वीकृत उत्तर होना चाहिए। हालांकि अन्य प्रोग्रामिंग भाषाओं को देखते हुए बहुत कम और स्पष्ट कोड के साथ ऐसा नहीं किया जा सकता है ... यह सबसे अच्छा जावा है जो किसी अन्य पुस्तकालय पर निर्भर करता है।
— जेसन
7
हालांकि नीट, यह System.arraycopy की तुलना में आश्चर्यजनक रूप से अक्षम होने जा रहा है। शायद वास्तविक कोड में ऐसा नहीं करना चाहिए।
— बिल के
अगर फू डायनेमिक स्ट्रिंग वैरिएबल है, जो कंपाइल टाइम एरर फेंक रहा है, तो एनक्लोजिंग स्कोप में परिभाषित लोकल वेरिएबल फू फाइनल या इफेक्टिवली फाइनल होना चाहिए
— महेंदर रेड्डी यासा
प्रश्न में कहा गया है कि "वस्तुओं के एक सरणी को देखते हुए" - इतना Stream.of(foo).filter(s -> ! s.equals("a")).toArray()पर्याप्त होगा।
— कपलान
20

Listसरणी से बाहर करें Arrays.asList(), और remove()सभी उपयुक्त तत्वों को कॉल करें । फिर toArray()'सूची' पर कॉल करें ताकि फिर से एक सरणी में वापस आ सकें।

बहुत अच्छा प्रदर्शन नहीं है, लेकिन अगर आप इसे ठीक से एनकैप्सुलेट करते हैं, तो आप हमेशा बाद में कुछ तेज कर सकते हैं।

— dustman
स्रोत
3
अपनी टिप्पणी को पुनः भेजें: यह ठीक है, आपको जल्द ही इसकी आदत हो जाएगी। :-) मैंने अपना पोस्ट पोस्ट किया क्योंकि मैं नहीं चाहता था कि पाठकों को यह विचार आए कि तत्वों को Arrays.asList () (यह एक अपरिवर्तनीय सूची) के परिणाम से हटाया जा सकता है, इसलिए मुझे लगा कि एक उदाहरण इस बात का ध्यान रख सकता है। :-)
— क्रिस जस्टर-यंग
उह, मेरा मतलब था अन-रेसिजेबल लिस्ट (ऐड () और रिमूव) (काम नहीं करना)। :-P यह अभी भी एक प्रयोग करने योग्य सेट () विधि है। :-)
— क्रिस जस्टर-यंग
हालांकि यह अजीब लग सकता है, मेरा अनुभव यह है कि इस दृष्टिकोण का प्रदर्शन दंड न्यूनतम है।
— मार्कस डाउनिंग
8
इसके साथ क्या है? @ क्रिस ने बताया कि सूची से परिणाम का Arrays.asList()समर्थन नहीं करता है remove()। तो क्या यह जवाब पूरी तरह से अमान्य है? लगता है कि शायद कुछ टिप्पणियों को हटा दिया गया है, इसलिए मुझे नहीं पता कि क्या इस पर चर्चा की गई थी।
— लार्स
1
क्रिस और लार्स दोनों सही हैं: सरणी-समर्थित सूचियाँ (दूसरे शब्दों में, जो Arrays.asList () के साथ बनाई गई हैं) संरचनात्मक रूप से अपरिवर्तनीय हैं जो इस उत्तर को पूरी तरह से अमान्य करती हैं। फिर भी, अब तक, मैं सत्रह उत्थान देखता हूं। एक आश्चर्य की बात है ...
— इगोर Soudakevitch
15

आप हमेशा ऐसा कर सकते हैं:

int i, j;
for (i = j = 0; j < foo.length; ++j)
  if (!"a".equals(foo[j])) foo[i++] = foo[j];
foo = Arrays.copyOf(foo, i);
6

आप बाहरी पुस्तकालय का उपयोग कर सकते हैं:

org.apache.commons.lang.ArrayUtils.remove(java.lang.Object[] array, int index)

यह अपाचे कॉमन्स लैंग http://commons.apache.org/lang/ प्रोजेक्ट में है

— bugs_
स्रोत
ArrayUtils.removeElement(boolean[] array, boolean element)भी बहुत उपयोगी है।
— स्काइ
5

नीचे कोड देखें

ArrayList<String> a = new ArrayList<>(Arrays.asList(strings));
a.remove(i);
strings = new String[a.size()];
a.toArray(strings);
— अली
स्रोत
4

यदि आपको कई तत्वों को सरणी से हटाने की Listआवश्यकता है, तो इसे न तो अतिरिक्त सरणी बनाए बिना , आप इसे O (n) में कर सकते हैं, हटाने के लिए मदों की गिनती पर निर्भर नहीं।

यहां, aप्रारंभिक सरणी, int... rहटाने के लिए तत्वों के विशिष्ट आदेश सूचक (पद) हैं:

public int removeItems(Object[] a, int... r) {
    int shift = 0;                             
    for (int i = 0; i < a.length; i++) {       
        if (shift < r.length && i == r[shift])  // i-th item needs to be removed
            shift++;                            // increment `shift`
        else 
            a[i - shift] = a[i];                // move i-th item `shift` positions left
    }
    for (int i = a.length - shift; i < a.length; i++)
        a[i] = null;                            // replace remaining items by nulls

    return a.length - shift;                    // return new "length"
}

छोटा परीक्षण:

String[] a = {"0", "1", "2", "3", "4"};
removeItems(a, 0, 3, 4);                     // remove 0-th, 3-rd and 4-th items
System.out.println(Arrays.asList(a));        // [1, 2, null, null, null]

अपने कार्य में, आप पहले "a" की स्थिति लेने के लिए सरणी स्कैन कर सकते हैं, फिर कॉल कर सकते हैं removeItems()।

— एलेक्स सलायौ
स्रोत
1
कृपया ऐसा न करें। यह भ्रामक, धीमा और त्रुटि-प्रवण है। बस System.arraycopy () का उपयोग करें - हालांकि इस तथ्य के लिए बोनस अंक कि अगर आप किसी सरणी में हेरफेर करने जा रहे हैं तो आपको लंबाई ट्रैक करनी होगी।
— बिल के
4

यहाँ बहुत सारे उत्तर हैं - जैसा कि मैंने देखा कि समस्या यह है कि आपने यह नहीं कहा कि आप एक संग्रह के बजाय एक सरणी का उपयोग क्यों कर रहे हैं, इसलिए मुझे कुछ कारण बताएं और कौन से समाधान लागू होंगे (अधिकांश समाधान) यहाँ पहले से ही अन्य सवालों के जवाब दिए गए हैं, इसलिए मैं बहुत विस्तार में नहीं जाऊंगा):

कारण: आपको पता नहीं था कि संग्रह पैकेज मौजूद था या उस पर भरोसा नहीं था

समाधान: एक संग्रह का उपयोग करें।

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

कारण: आप आकार के बारे में चिंतित हैं या स्मृति आवंटन पर नियंत्रण चाहते हैं

समाधान: एक विशिष्ट प्रारंभिक आकार के साथ एक ArrayList का उपयोग करें।

एक ArrayList केवल एक सरणी है जो स्वयं का विस्तार कर सकती है, लेकिन इसे हमेशा ऐसा करने की आवश्यकता नहीं है। यह आइटम जोड़ने / हटाने के बारे में बहुत स्मार्ट होगा, लेकिन फिर से यदि आप बीच से एक बहुत कुछ सम्मिलित / निकाल रहे हैं, तो एक LinkList का उपयोग करें।

कारण: आपके पास एक सरणी आ रही है और एक सरणी बाहर जा रही है - इसलिए आप एक सरणी पर काम करना चाहते हैं

समाधान: इसे एक ArrayList में कनवर्ट करें, आइटम हटाएं और इसे वापस कन्वर्ट करें

कारण: आपको लगता है कि यदि आप इसे स्वयं करते हैं तो आप बेहतर कोड लिख सकते हैं

समाधान: आप एक ऐरे या लिंक्ड सूची का उपयोग नहीं कर सकते।

कारण: यह एक क्लास असाइनमेंट है और आपको अनुमति नहीं है या आपके पास किसी कारण से संग्रह एपिस तक पहुंच नहीं है

धारणा: आपको सही "आकार" के लिए नए सरणी की आवश्यकता है

समाधान: आइटम मिलान के लिए सरणी स्कैन करें और उन्हें गिनें। सही आकार का एक नया सरणी बनाएं (मूल आकार - मैचों की संख्या)। System.arraycopy का उपयोग बार-बार उन वस्तुओं के प्रत्येक समूह को कॉपी करने के लिए करें जिन्हें आप अपने नए Array में बनाए रखना चाहते हैं। यदि यह एक क्लास असाइनमेंट है और आप System.arraycopy का उपयोग नहीं कर सकते हैं, तो बस उन्हें एक बार एक लूप में हाथ से कॉपी करें लेकिन कभी भी उत्पादन कोड में ऐसा न करें क्योंकि यह बहुत धीमा है। (ये समाधान दोनों अन्य उत्तरों में विस्तृत हैं)

कारण: आपको नंगे धातु चलाने की आवश्यकता है

धारणा: आप अनावश्यक रूप से स्थान आवंटित नहीं करते हैं या बहुत लंबा समय नहीं लेते हैं

धारणा: आप सरणी (लंबाई) में उपयोग किए गए आकार को अलग-अलग ट्रैक कर रहे हैं क्योंकि अन्यथा आपको हटाए जाने या आवेषण के लिए अपने सरणी को पुनः लोड करना होगा।

आप ऐसा क्यों करना चाहते हैं इसका एक उदाहरण: आदिमों का एक एकल सरणी (मान मान लीजिए) आपके राम का एक महत्वपूर्ण हिस्सा ले रहा है - जैसे 50%! एक ArrayList इन्टर्गर ऑब्जेक्ट्स की ओर इशारा करता है जो मेमोरी की मात्रा का कुछ गुना उपयोग करेगा।

समाधान: अपने एरे पर फेरबदल करें और जब भी आपको हटाने के लिए कोई तत्व मिले (चलो इसे तत्व n कहते हैं), "डिलीट" एलिमेंट के एरे की पूंछ को कॉपी करने के लिए System.arraycopy का उपयोग करें (स्रोत और गंतव्य समान एरे हैं) - यह स्मार्ट कॉपी को सही दिशा में करने के लिए पर्याप्त है ताकि मेमोरी स्वयं को अधिलेखित न करे:

 System.arraycopy (एरी, एन + 1, एरी, एन, लंबाई-एन) 
 length--;

यदि आप एक बार में एक से अधिक तत्वों को हटा रहे हैं, तो आप शायद इससे अधिक स्मार्ट बनना चाहेंगे। आप केवल एक "मैच" और पूरी पूंछ के बजाय अगले के बीच के क्षेत्र को स्थानांतरित करेंगे और हमेशा की तरह, किसी भी चंक को दो बार स्थानांतरित करने से बचें।

इस अंतिम स्थिति में, आपको पूरी तरह से स्वयं कार्य करना होगा, और System.arraycopy का उपयोग करना वास्तव में इसे करने का एकमात्र तरीका है क्योंकि यह आपके कंप्यूटर आर्किटेक्चर के लिए मेमोरी को स्थानांतरित करने का सबसे अच्छा तरीका चुनने जा रहा है - यह कई गुना तेज होना चाहिए किसी भी कोड से आप यथोचित अपने आप को लिख सकते हैं।

— बिल के
स्रोत
3

इसके बारे में एक सूची बनाने के बारे में कुछ तो फिर एक सरणी में वापस मुझे गलत के रूप में हमलों को हटा दें। परीक्षण नहीं किया गया है, लेकिन मुझे लगता है कि निम्नलिखित बेहतर प्रदर्शन करेंगे। हां, मैं शायद पूर्व-अनुकूलन को पूर्ववत् कर रहा हूं।

boolean [] deleteItem = new boolean[arr.length];
int size=0;
for(int i=0;i<arr.length;i==){
   if(arr[i].equals("a")){
      deleteItem[i]=true;
   }
   else{
      deleteItem[i]=false;
      size++;
   }
}
String[] newArr=new String[size];
int index=0;
for(int i=0;i<arr.length;i++){
   if(!deleteItem[i]){
      newArr[index++]=arr[i];
   }
}
— shsteimer
स्रोत
3

मुझे लगता है कि यह एक बहुत पुरानी पोस्ट है, लेकिन यहाँ कुछ जवाबों ने मेरी मदद की है, इसलिए यहाँ मेरी 't'pence' की हैप्पीनेस है!

जब तक ArrayListकि सूची को वापस आकार में बदलने की आवश्यकता नहीं है, तब तक मुझे टहलने से पहले काफी समय तक काम करने के लिए संघर्ष करना पड़ा, जब तक कि सूची के आकार में परिवर्तन नहीं हुआ।

तो ArrayListयह है कि आप अधिक से अधिक ऊपर या इससे कम तत्वों की तुलना में यह के साथ शुरू के साथ समाप्त होता है संशोधित कर रहे हैं, लाइन List.toArray()एक अपवाद है ताकि आप की तरह कुछ की जरूरत का कारण होगा, List.toArray(new String[] {})या List.toArray(new String[0])नए (सही) के आकार के साथ एक सरणी बनाने के लिए।

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

— DDSports
स्रोत
मुझे यह पोस्ट करने की आवश्यकता महसूस हुई, क्योंकि मैं अक्सर कोड के स्निपेट का उपयोग करता हूं जो काम नहीं करते हैं क्योंकि मुझे कुछ याद आया जो अन्य कोडर्स ने दिए थे। ग्राड ने ऐरे आकार के बारे में बात की, जिससे मेरा कोड काम कर गया (धन्यवाद कि स्पष्ट करने के लिए)। सामान की कोशिश करना सीखने का तरीका है, और अगर इसका मतलब है कि मैं सभी को एसओ से कोड लेने के लायक हूं और यह समझने की कोशिश कर रहा हूं कि यह कैसे / क्यों काम करता है, तो ऐसा हो। एक अवैतनिक शौकिया के रूप में, मैं जावा प्रतिभा नहीं हूं कि कुछ लोग सोचते हैं कि वे हैं! शुक्र है, एसओ योगदानकर्ताओं में से अधिकांश सवालों का जवाब देते हैं ताकि दूसरों को बेहतर कोड लिखने में मदद मिल सके: इसके लिए, आप धन्यवाद के पात्र हैं!
— DDSports
2

प्रारंभिक सरणी 

   int[] array = {5,6,51,4,3,2};

यदि आप चाहते हैं कि 51 को हटा दें जो कि अनुक्रमणिका 2 है, निम्नलिखित का उपयोग करें

 for(int i = 2; i < array.length -1; i++){
    array[i] = array[i + 1];
  }
— ईबिन जॉय
स्रोत
1

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

सरणी में नल के साथ बिंदु को साफ कर दिया गया है। मेरी टिप्पणियों के लिए क्षमा करें।

मूल:

एहम ... रेखा

array = list.toArray(array);

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

यदि आप इससे बचना चाहते हैं, तो ऐरे () के लिए एक नए ऐरे को पैरामीटर के रूप में उपयोग करें। यदि आप removeAll का उपयोग नहीं करना चाहते हैं, तो एक सेट एक विकल्प होगा:

        String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

        System.out.println(Arrays.toString(array));

        Set<String> asSet = new HashSet<String>(Arrays.asList(array));
        asSet.remove("a");
        array = asSet.toArray(new String[] {});

        System.out.println(Arrays.toString(array));

देता है:

[a, bc, dc, a, ef]
[dc, ef, bc]

जहां क्रिस यस्टर यंग आउटपुट से वर्तमान स्वीकृत उत्तर के रूप में:

[a, bc, dc, a, ef]
[bc, dc, ef, null, ef]

कोड के साथ

    String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

    System.out.println(Arrays.toString(array));

    List<String> list = new ArrayList<String>(Arrays.asList(array));
    list.removeAll(Arrays.asList("a"));
    array = list.toArray(array);        

    System.out.println(Arrays.toString(array));

बिना किसी अशक्त मूल्य के पीछे छोड़ दिया।

— GHad
स्रोत
अच्छा प्रयास है, लेकिन कोई सिगार नहीं। आपके पोस्ट करने से पहले मैंने ठीक इसी तरह से इस विषय पर एक एडिट पोस्ट किया था। इसलिए, यद्यपि आप "तकनीकी रूप से सही हैं", मैं लोगों को मेरी पोस्ट को विस्थापित करने के लिए आपकी कोशिश की सराहना नहीं करता। मुझे लगा कि आपको पता होना चाहिए।
— क्रिस जस्टर-यंग
यह पोस्ट विस्थापन के बारे में नहीं है, बल्कि त्रुटियों और खतरनाक कोड से बचने के बारे में है। ग्रीटज़ ग्राड
— GHAD
यदि लोग मेरी पूरी पोस्ट (दोनों एडेंडा सहित) पढ़ते हैं तो त्रुटियों से बचा जा सकता है। अगर लोग बिना सोचे-समझे सिर्फ कोड को काटते और चिपकाते हैं, तो उन्हें मिलने वाली हर चीज के लायक हैं। प्रोग्रामर को भुगतान किया जाता है कि वे क्या करते हैं क्योंकि वे अपने दिमाग का व्यायाम करते हैं ... मुझे उम्मीद है। [जारी है]
— क्रिस जेस्टर-यंग
1
[जारी] आपका कोड "खतरनाक" है, भले ही लोग इस तथ्य से परिचित न हों कि एक हैश का उपयोग करके, आइटम अव्यवस्थित हो जाते हैं। बेशक, सोचने वाले प्रोग्रामर्स को इसका एहसास है, लेकिन अगर आप मेरे कोड को खतरनाक कहते हैं, क्योंकि लोग बिना सोचे-समझे काटते और चिपकाते हैं, तो आपका वही कहना उचित है।
— क्रिस जस्टर-यंग
ज़रूर, आप हैश के बारे में सही हैं। और जैसा कि बिंदु आपके दूसरे संपादन से स्पष्ट है, मुझे इस पर ध्यान देना चाहिए। जैसा कि कहा गया है, बस अशक्त मूल्यों और दोहराव के साथ एक सरणी से बचना चाहता था। आप अपने 2 के संपादन के आधार पर अपना कोड बदल सकते हैं और सरणी के बारे में Edit3 में एक टिप्पणी छोड़ सकते हैं। आप पर हमला नहीं करना चाहता था
— GHAD
1

इस समस्या में मेरा थोड़ा योगदान है।

public class DeleteElementFromArray {
public static String foo[] = {"a","cc","a","dd"};
public static String search = "a";


public static void main(String[] args) {
    long stop = 0;
    long time = 0;
    long start = 0;
    System.out.println("Searched value in Array is: "+search);
    System.out.println("foo length before is: "+foo.length);
    for(int i=0;i<foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
    System.out.println("==============================================================");
    start = System.nanoTime();
    foo = removeElementfromArray(search, foo);
    stop = System.nanoTime();
    time = stop - start;
    System.out.println("Equal search took in nano seconds = "+time);
    System.out.println("==========================================================");
    for(int i=0;i<foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
}
public static String[] removeElementfromArray( String toSearchfor, String arr[] ){
     int i = 0;
     int t = 0;
     String tmp1[] = new String[arr.length];     
         for(;i<arr.length;i++){
              if(arr[i] == toSearchfor){     
              i++;
              }
             tmp1[t] = arr[i];
             t++;
     }   
     String tmp2[] = new String[arr.length-t];   
     System.arraycopy(tmp1, 0, tmp2, 0, tmp2.length);
     arr = tmp2; tmp1 = null; tmp2 = null;
    return arr;
}

}

— आंद्रे
स्रोत
यह वास्तव में अच्छा जवाब है, हालांकि आपका महान परीक्षण कोड इसे वास्तव में की तुलना में बहुत बड़ा दिखता है। संपूर्ण समाधान एक ही लाइन एरेस्कोपी हो सकता है (यह मानते हुए कि आप उसी सरणी का उपयोग करते हैं जो आप करना चाहते हैं यदि आप धातु के इतने करीब काम कर रहे थे जो आप संग्रह के बजाय एरे का उपयोग कर रहे थे)।
— बिल के
धन्यवाद, मैंने इसे लिखा इसलिए पाठकों ने थोड़ा देखा कि हुड के नीचे क्या हो सकता है और इसका परीक्षण करें, अब मैं इसे फिर से देखता हूं System.arraycopy (tmp1, 0, tmp2, 0, tmp2.length); (i = 0; i <(arr.length - t); i ++) {tmp2 [i] = tmp1 [i] के लिए किसी चीज़ को हटाया और प्रतिस्थापित किया जा सकता है; } आप अतिरिक्त कॉपी प्रदर्शन हासिल करने के लिए 64 बिट मशीन पर एक बार में एक बाइट बफर और 8 बाइट्स कॉपी कर सकते हैं
— आंद्रे
0

यह इस बात पर निर्भर करता है कि "हटाने" से आपका क्या मतलब है? एक सरणी एक निश्चित आकार का निर्माण है - आप इसमें तत्वों की संख्या नहीं बदल सकते। तो आप या तो) उन तत्वों के बिना एक नया, छोटा, सरणी बना सकते हैं, जिन्हें आप नहीं चाहते हैं या ख) उन प्रविष्टियों को असाइन करें जिन्हें आप ऐसा कुछ नहीं चाहते हैं जो उनकी 'खाली' स्थिति को इंगित करता है; आमतौर पर अशक्त अगर आप आदिम के साथ काम नहीं कर रहे हैं।

पहले मामले में सरणी से एक सूची बनाएं, तत्वों को हटा दें, और सूची से एक नया सरणी बनाएं। यदि प्रदर्शन किसी भी तत्व को असाइन करने वाले सरणी पर महत्वपूर्ण पुनरावृति है जिसे किसी सूची में नहीं हटाया जाना चाहिए, और फिर सूची से एक नया सरणी बनाएं। दूसरे मामले में बस के माध्यम से जाना और सरणी प्रविष्टियों को शून्य असाइन करें।

— DJClayworth
स्रोत
0

अर्घ, मुझे सही तरीके से दिखाने के लिए कोड नहीं मिल सकता है। क्षमा करें, मुझे यह काम मिल गया। क्षमा करें, मुझे नहीं लगता कि मैंने प्रश्न को ठीक से पढ़ा है।

String  foo[] = {"a","cc","a","dd"},
remove = "a";
boolean gaps[] = new boolean[foo.length];
int newlength = 0;

for (int c = 0; c<foo.length; c++)
{
    if (foo[c].equals(remove))
    {
        gaps[c] = true;
        newlength++;
    }
    else 
        gaps[c] = false;

    System.out.println(foo[c]);
}

String newString[] = new String[newlength];

System.out.println("");

for (int c1=0, c2=0; c1<foo.length; c1++)
{
    if (!gaps[c1])
    {
        newString[c2] = foo[c1];
        System.out.println(newString[c2]);
        c2++;
    }
}
— AngelOfCake
स्रोत
0

सूचकांक I वाले को छोड़कर सभी तत्वों को कॉपी करेगा:

if(i == 0){
                System.arraycopy(edges, 1, copyEdge, 0, edges.length -1 );
            }else{
                System.arraycopy(edges, 0, copyEdge, 0, i );
                System.arraycopy(edges, i+1, copyEdge, i, edges.length - (i+1) );
            }
— पॉली
स्रोत
0

जैसे स्ट्रिंग्स की एक सरणी में

स्ट्रिंग नाम = 'abcdeafbde' // स्ट्रिंग नाम की तरह हो सकता है

मैं निम्न वर्ग का निर्माण करता हूं

class clearname{
def parts
def tv
public def str = ''
String name
clearname(String name){
    this.name = name
    this.parts = this.name.split(" ")
    this.tv = this.parts.size()
}
public String cleared(){

        int i
        int k
        int j=0        
    for(i=0;i<tv;i++){
        for(k=0;k<tv;k++){
            if(this.parts[k] == this.parts[i] && k!=i){
               this.parts[k] = '';
                j++
            }
        }
    }
    def str = ''
    for(i=0;i<tv;i++){
        if(this.parts[i]!='')

           this.str += this.parts[i].trim()+' '
    } 
    return this.str    
}}



return new clearname(name).cleared()

यह परिणाम मिल रहा है

abcdef

उम्मीद है कि यह कोड किसी को भी सादर मदद करेगा

— ऑरलैंडो रेयेस
स्रोत
0

यदि यह तत्वों के क्रम से कोई फर्क नहीं पड़ता। आप तत्वों फू [x] और फू [0] के बीच स्वैप कर सकते हैं, फिर foo.drop (1) को कॉल करें।

foo.drop(n) सरणी से पहले (n) तत्वों को निकालता है।

मुझे लगता है कि यह सबसे सरल और संसाधन कुशल तरीका है।

पुनश्च : indexOfकई मायनों में लागू किया जा सकता है, यह मेरा संस्करण है।

Integer indexOf(String[] arr, String value){
    for(Integer i = 0 ; i < arr.length; i++ )
        if(arr[i] == value)
            return i;         // return the index of the element
    return -1                 // otherwise -1
}

while (true) {
   Integer i;
   i = indexOf(foo,"a")
   if (i == -1) break;
   foo[i] = foo[0];           // preserve foo[0]
   foo.drop(1);
}
— milevyo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.