2010-07-20 12 views
87

मान लें कि हमारे पास Collection<Foo> है। Foo[] में बदलने के लिए सबसे अच्छा (वर्तमान संदर्भ में एलओसी में सबसे छोटा) तरीका क्या है? कोई भी प्रसिद्ध पुस्तकालयों की अनुमति है।संग्रह को सरणी में बदलने का सबसे आसान तरीका?

युपीडी: (एक और मामला इस खंड में, टिप्पणी छोड़ने अगर आपको लगता है कि यह इसके लिए एक और धागा बनाने के लिए लायक है): क्या बदलने के बारे में Collection<Foo>Bar[] के लिए जहां Bar है प्रकार Foo अर्थात public Bar(Foo foo){ ... } का 1 पैरामीटर के साथ निर्माता?

उत्तर

205

कहाँ x संग्रह है:

Foo[] foos = x.toArray(new Foo[x.size()]); 
+24

** सरल ** (आसान), लेकिन नहीं सबसे अच्छा (स्मृति): 'x.toArray (नई फू [0])' --- ** प्रलेखन **: पढ़ने के लिए कोई समय नहीं ... –

+0

सरलता कुंजी है ... सोचें कि कुछ लोग खुद को लात मारेंगे – David

+5

@ कार्लोस वास्तव में, यह '(नया फू [0]) 'से बेहतर स्मृति का उपयोग करता है। Collection.toArray दस्तावेज़ीकरण के अनुसार, '@param एक सरणी जिसमें इस संग्रह के तत्व संग्रहीत किए जाने हैं, यदि यह काफी बड़ा है' जिसका अर्थ है कि यह उन्हें सीधे उस नई सरणी में संग्रहीत करेगा। यदि आप इसे आकार 0 सरणी देते हैं, तो यह एक नई सरणी बना देगा, जिसका अर्थ है कि आपके पास एक छोटी सी सरणी है और जब यह अनावश्यक है तो एक बड़ी सरणी बनाई जा रही है। – corsiKa

10

आप इसे एक बार या एक पाश में अधिक से अधिक उपयोग करते हैं, आप एक निरंतर

public static final Foo[] FOO = new Foo[]{}; 

को परिभाषित करने और

तरह रूपांतरण यह कर सकता है
Foo[] foos = fooCollection.toArray(FOO); 

toArray विधि निर्धारित करने के लिए खाली सरणी ले जाएगी ई लक्ष्य सरणी का सही प्रकार और आपके लिए एक नई सरणी बनाएं।

Foo[] a = x.toArray(new Foo[x.size()]); 

अद्यतन के लिए के रूप में::

int i = 0; 
Bar[] bars = new Bar[fooCollection.size()]; 
for(Foo foo : fooCollection) { // where fooCollection is Collection<Foo> 
    bars[i++] = new Bar(foo); 
}  
+1

अप, 'const' जावा नहीं है! 'सार्वजनिक स्थिर अंतिम फू [] FOO = {} ' –

+1

यह सार्वजनिक क्यों होगा? –

+0

@ ज़ोलटन - क्यों नहीं? यह अपरिवर्तनीय है, इसलिए सुरक्षा समस्या नहीं पेश करता है। यह अव्यवस्था का थोड़ा सा है, लेकिन अन्य कोड में उपयोगी हो सकता है, इसलिए आमतौर पर हानिरहित होता है। हो सकता है कि इन सभी स्थिरांकों के साथ एक केंद्रीय वर्ग भी बनाएं, और फिर उन पर पहुंचने के लिए 'आयात स्थिर' का उपयोग करें। – Jules

1

:


यहाँ अद्यतन के लिए मेरे प्रस्ताव है अद्यतन संप्रदाय में मामले के लिए समाधान आयन (गूगल संग्रह की मदद से):

Collections2.transform (fooCollection, new Function<Foo, Bar>() { 
    public Bar apply (Foo foo) { 
     return new Bar (foo); 
    } 
}).toArray (new Bar[fooCollection.size()]); 

लेकिन, महत्वपूर्ण दृष्टिकोण यहाँ the doublep's answer में उल्लेख किया गया था (मैं toArray विधि के लिए भूल गया)।

3

यहाँ अंतिम है मूल को देखने के doublep जवाब के लिए

Collection<Foo> foos = new ArrayList<Foo>(); 
Collection<Bar> temp = new ArrayList<Bar>(); 
for (Foo foo:foos) 
    temp.add(new Bar(foo)); 
Bar[] bars = temp.toArray(new Bar[]{}); 
+1

बदला जा सकता है, थ्रेड सुरक्षा के बारे में डबलप के उत्तर पर मेरी टिप्पणी देखें, जो इस समाधान पर भी लागू होता है। 'नया बार [0]' इस मुद्दे से बचाता है। – Jules

26

अद्यतन प्रश्न जावा 8 का उपयोग करने के लिए वैकल्पिक समाधान:

Bar[] result = foos.stream() 
    .map(x -> new Bar(x)) 
    .toArray(size -> new Bar[size]); 
+25

इसे 'बार [] परिणाम = foos.stream() मानचित्र (बार :: नया) .toArray (बार [] :: नया);' – lpandzic

+0

सिंटेक्स के अनुसार मैं स्वीकृत उत्तर को अधिक पसंद करूंगा । मेरी इच्छा है कि लोग सभी पाइथन पर स्विच कर सकें। –