java - एक पंक्ति में एक ArrayList की शुरुआत




collections initialization (20)

मैं परीक्षण उद्देश्यों के लिए विकल्पों की एक सूची बनाना चाहता हूं। सबसे पहले, मैंने यह किया:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

फिर मैंने कोड को निम्नानुसार दोहराया:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

क्या ऐसा करने के लिए इससे अच्छा तरीका है?


सरल जवाब

जावा 8 या इससे पहले में:

List<String> strings = Arrays.asList("foo", "bar", "baz");

यह आपको सरणी द्वारा समर्थित एक List देगा, इसलिए यह लंबाई नहीं बदल सकता है।
लेकिन आप List.set कॉल कर सकते हैं, इसलिए यह अभी भी परिवर्तनीय है।

जावा 9 में:

List<String> strings = List.of("foo", "bar", "baz");

यह आपको एक अपरिवर्तनीय List , इसलिए इसे बदला नहीं जा सकता है।
ज्यादातर मामलों में आप यही चाहते हैं जहां आप इसे पूर्ववत कर रहे हैं।

छोटा जवाब

आप एक स्थिर आयात के साथ Arrays.asList भी कम कर सकते हैं:

List<String> strings = asList("foo", "bar", "baz");

स्थिर आयात:

import static java.util.Arrays.asList;  

कौन सा आधुनिक आईडीई सुझाव देगा और स्वचालित रूप से आपके लिए करेगा।
उदाहरण के लिए इंटेलिजे आईडीईए में आप Alt+Enter और Static import method... चयन करें Static import method...

हालांकि, मैं Java 9 List.of विधि को छोटा करने की अनुशंसा नहीं करता, क्योंकि केवल भ्रमित हो जाता है।
List.of पहले से ही काफी छोटा है और अच्छी तरह से पढ़ता है।

Stream एस का उपयोग करना

यह एक List क्यों है?
जावा 8 के साथ या बाद में आप एक Stream उपयोग कर सकते हैं जो अधिक लचीला है:

Stream<String> strings = Stream.of("foo", "bar", "baz");

आप Stream एस को जोड़ सकते हैं:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

या आप एक Stream से एक List जा सकते हैं:

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

लेकिन अधिमानतः, किसी List एकत्र किए बिना Stream उपयोग करें।

यदि आपको वास्तव में विशेष रूप से java.util.ArrayList आवश्यकता है

(आप शायद नहीं करते हैं।)
जेईपी 26 9 (जोर मेरा) उद्धृत करने के लिए:

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

यदि आप दोनों को एक ArrayList पूर्ववत करना चाहते हैं और बाद में (क्यों?), उपयोग करें

List<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

या जावा 9 में:

List<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

या Stream का उपयोग कर:

List<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

लेकिन फिर, किसी List में एकत्रित करने के बजाय सीधे Stream उपयोग करना बेहतर होता है।

कार्यान्वयन के लिए इंटरफेस के लिए कार्यक्रम

आपने कहा है कि आपने सूची को अपने कोड में एक ArrayList रूप में घोषित कर दिया है, लेकिन आपको केवल ऐसा करना चाहिए यदि आप ArrayList कुछ सदस्य का उपयोग कर रहे हैं जो List में नहीं है।

जो आप सबसे अधिक संभावना नहीं कर रहे हैं।

आम तौर पर आपको सबसे सामान्य इंटरफ़ेस द्वारा चर को घोषित करना चाहिए जिसे आप उपयोग करने जा रहे हैं (जैसे Iterable , Collection , या List ), और उन्हें विशिष्ट कार्यान्वयन (जैसे ArrayList , LinkedList या Arrays.asList() ) के साथ प्रारंभ करें।

अन्यथा आप अपने कोड को उस विशिष्ट प्रकार से सीमित कर रहे हैं, और जब आप चाहें तो इसे बदलना मुश्किल होगा।

उदाहरण के लिए:

// Iterable if you just need iteration, for (String s : strings):
Iterable<String> strings = new ArrayList<>();   

// Collection if you also need .size() or .stream():
Collection<String> strings = new ArrayList<>(); 

// List if you also need .get(index):
List<String> strings = new ArrayList<>();       

// Don't declare a specific list implementation
// unless you're sure you need it:
ArrayList<String> strings = new ArrayList<>();  // You don't need ArrayList

एक और उदाहरण हमेशा एक InputStream वैरिएबल घोषित करेगा, भले ही यह आमतौर पर एक FileInputStream या BufferedInputStream , क्योंकि एक दिन जल्द ही आप या कोई अन्य किसी अन्य प्रकार के InputStream का उपयोग करना चाहेगा।


(एक टिप्पणी होनी चाहिए, लेकिन बहुत लंबा, इतना नया जवाब)। जैसा कि अन्य ने उल्लेख किया है, Arrays.asList विधि निश्चित आकार है, लेकिन यह इसके साथ एकमात्र मुद्दा नहीं है। यह विरासत को बहुत अच्छी तरह से संभाल नहीं करता है। उदाहरण के लिए, मान लें कि आपके पास निम्न है:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

उपरोक्त परिणाम एक कंपाइलर त्रुटि में, क्योंकि List<B> (जो Arrays.asList द्वारा लौटाया जाता है) List<A> का उप-वर्ग नहीं है, भले ही आप किसी List<A> ऑब्जेक्ट में प्रकार बी के ऑब्जेक्ट्स जोड़ List<A> । इसे पाने के लिए, आपको कुछ ऐसा करने की ज़रूरत है:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

ऐसा करने के लिए शायद यह सबसे अच्छा तरीका है, esp। अगर आपको एक असंबद्ध सूची की आवश्यकता है या विरासत का उपयोग करने की आवश्यकता है।


आप Cactoos से StickyList उपयोग कर सकते हैं:

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

आप नीचे दिए गए कथन का उपयोग कर सकते हैं:

सांकेतिक टुकड़ा:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

इस कोड लाइन के साथ प्रयास करें:

Collections.singletonList(provider)

एक अपरिवर्तनीय सूची बनाने के लिए जावा 9 में निम्न विधि है:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

यदि आवश्यक हो तो एक म्यूटेबल सूची बनाने के लिए आसानी से अनुकूलित किया जाता है:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Set और Map लिए इसी तरह के तरीके उपलब्ध हैं।


ऐसा करने का सबसे अच्छा तरीका:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

बस एक ऐसा फ़ंक्शन बनाएं जिसमें आपके इच्छित तत्व हो सकें और इसे एक पंक्ति में जोड़ने के लिए कहें।


ऐसा करने के सबसे कॉम्पैक्ट तरीके के बारे में है:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

जावा में, आप नहीं कर सकते

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

जैसा कि बताया गया था, आपको डबल ब्रेस प्रारंभ करने की आवश्यकता होगी:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

लेकिन यह आपको एनोटेशन @SuppressWarnings("serial") जोड़ने या एक धारावाहिक @SuppressWarnings("serial") उत्पन्न करने के लिए मजबूर कर सकता है जो परेशान है। इसके अलावा अधिकांश कोड स्वरूपक इसे कई कथन / रेखाओं में खोल देंगे।

वैकल्पिक रूप से आप कर सकते हैं

List<String> places = Arrays.asList(new String[] {"x", "y" });

लेकिन फिर आप @SuppressWarnings("unchecked") करना चाह सकते हैं।

इसके अलावा जावाडोक के अनुसार आपको यह करने में सक्षम होना चाहिए:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

लेकिन मैं इसे जेडीके 1.6 के साथ संकलित करने में सक्षम नहीं हूं।


दरअसल, इसे एक पंक्ति में करना संभव है:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})

नीचे दिए गए कोड का उपयोग करें।

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

मेरे लिए Arrays.asList () सबसे अच्छा और सुविधाजनक है। मैं हमेशा उस तरह से शुरू करना पसंद करता हूं। यदि आप जावा संग्रह में शुरुआत कर रहे हैं तो मैं चाहता हूं कि आप ArrayList प्रारंभिकता को देखें


यहां एक और तरीका है:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

संग्रह अक्षर ने इसे जावा 8 में नहीं बनाया है, लेकिन एक लंबी लाइन में सूची आरंभ करने के लिए स्ट्रीम एपीआई का उपयोग करना संभव है:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

अगर आपको यह सुनिश्चित करने की ज़रूरत है कि आपकी List एक ArrayList :

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

AbacusUtil द्वारा कोड यहाँ है

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

घोषणा: मैं AbacusUtil के डेवलपर हूँ।


Guava साथ आप लिख सकते हैं:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

गुवा में अन्य उपयोगी स्थिर रचनाकार भी हैं। आप here उनके बारे में पढ़ सकते हैं।


Java 9 साथ, जैसा कि जेडीके एन्हांसमेंट प्रस्ताव - 26 Java 9 में सुझाया गया है, यह अब संग्रह साहित्य का उपयोग करके हासिल किया जा सकता है -

List<String> list = List.of("A", "B", "C");

Set<String> set = Set.of("A", "B", "C");

Map भी एक समान दृष्टिकोण लागू होगा -

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

जो @coobird द्वारा बताए गए संग्रह साहित्य प्रस्ताव के समान है। जेईपी डॉक्टर में भी स्पष्ट रूप से स्पष्ट -

वैकल्पिक

भाषा परिवर्तन कई बार माना गया है, और अस्वीकार कर दिया गया है:

परियोजना सिक्का प्रस्ताव, 2 9 मार्च 200 9

परियोजना सिक्का प्रस्ताव, 30 मार्च 200 9

जनवरी-मार्च 2014 में लैम्ब्डा-देव पर जेईपी 186 चर्चा

इस message. में संक्षेप में भाषा प्रस्तावों को लाइब्रेरी-आधारित प्रस्ताव की प्राथमिकता में अलग रखा गया था message.

आगे पढ़ें => जावा 9 में संग्रह के लिए ओवरलोडेड सुविधा फैक्टरी तरीके का बिंदु क्या है


टॉम की तरह कहा :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

लेकिन चूंकि आपने एक ऐरेलिस्ट की इच्छा रखने की शिकायत की है, इसलिए आपको सबसे पहले पता होना चाहिए कि ऐरेलिस्ट सूची का उप-वर्ग है और आप बस इस पंक्ति को जोड़ सकते हैं:

ArrayList<String> myPlaces = new ArrayList(places);

हालांकि, यह आपको 'प्रदर्शन' की शिकायत कर सकता है।

उस स्थिति में यह मुझे समझ में नहीं आता है, क्यों, क्योंकि आपकी सूची पूर्वनिर्धारित है क्योंकि इसे सरणी के रूप में परिभाषित नहीं किया गया था (क्योंकि आकार प्रारंभिक समय के समय ज्ञात है)। और यदि यह आपके लिए एक विकल्प है:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

यदि आपको मामूली प्रदर्शन मतभेदों की परवाह नहीं है तो आप सरणी को एक सरणी सूची में भी कॉपी कर सकते हैं:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

ठीक है, लेकिन भविष्य में आपको केवल स्थान के नाम से थोड़ा अधिक चाहिए, आपको देश कोड भी चाहिए। मान लीजिए कि यह अभी भी एक पूर्वनिर्धारित सूची है जो रन-टाइम के दौरान कभी नहीं बदलेगी, फिर यह एक enum सेट का उपयोग करने के लिए उपयुक्त है, अगर भविष्य में सूची को बदलने की आवश्यकता है तो पुन: संकलन की आवश्यकता होगी।

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

बन जाएगा:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

एनम के पास स्थिर values विधि है जो एनर को सभी क्रम में घोषित किए गए क्रम में आवंटित करती है, उदाहरण के लिए:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

उस मामले में मुझे लगता है कि आपको अपने ऐरेलिस्ट की आवश्यकता नहीं होगी।

पीएस रंद्या ने स्थिर उपयोगिता विधि Collections.addAll का उपयोग करके एक और अच्छा तरीका प्रदर्शित किया .addAll ।


List<String> names = Arrays.asList("2","@2234","21","11");

import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");






initialization