जावा 8 स्ट्रीम को ऐरे में कैसे बदलें?

Question

एक जावा 8 Streamको एक सरणी में बदलने का सबसे आसान / सबसे छोटा तरीका क्या है ?

Comments

मैं आपको सुझाव दूंगा कि रोलबैक वापस करें क्योंकि प्रश्न अधिक पूर्ण था और आपने कुछ करने की कोशिश की थी।

— स्किवी

@skiwi धन्यवाद! लेकिन मुझे लगा कि प्रयास कोड वास्तव में प्रश्न के लिए अधिक जानकारी नहीं जोड़ता है, और किसी ने चिल्लाया नहीं है "हमें आपका प्रयास दिखाओ" अभी तक =)

@skiwi: हालाँकि, मैं आमतौर पर डू-माय-होमवर्क-ऑफ-ऑफ़-मी-मेरे सवालों पर चिल्लाता हूं, यह विशेष प्रश्न मुझे बिना किसी अतिरिक्त गड़बड़ी के स्पष्ट लगता है। चलो इसे साफ रखें।

— होनज़ा ज़िदेक

आप पैकेज के आधिकारिक दस्तावेज़ों में बहुत सारे उत्तर और मार्गदर्शन पा सकते हैं: docs.oracle.com/javase/8/docs/api/java/util/stream/…

— Christophe Roussy

Answer 1

सबसे आसान तरीका toArray(IntFunction<A[]> generator)एरे कंस्ट्रक्टर संदर्भ के साथ विधि का उपयोग करना है । यह विधि के लिए एपीआई प्रलेखन में सुझाव दिया गया है ।

String[] stringArray = stringStream.toArray(String[]::new);

यह जो करता है वह एक विधि है जो एक पूर्णांक (आकार) में तर्क के रूप में लेता है, और एक लौटाता है String[], जो वास्तव में वही करता है (ओवरलोड में से एक) new String[]करता है।

आप अपना स्वयं का भी लिख सकते हैं IntFunction:

Stream<String> stringStream = ...;
String[] stringArray = stringStream.toArray(size -> new String[size]);

इसका उद्देश्य IntFunction<A[]> generatorएक पूर्णांक, सरणी के आकार को एक नए सरणी में बदलना है।

उदाहरण कोड:

Stream<String> stringStream = Stream.of("a", "b", "c");
String[] stringArray = stringStream.toArray(size -> new String[size]);
Arrays.stream(stringArray).forEach(System.out::println);

प्रिंटों:

a
b
c

Comments

और यहाँ एक व्याख्या क्यों और कैसे ऐरे कंस्ट्रक्टर संदर्भ वास्तव में काम करते हैं: stackoverflow.com/questions/29447561/…

— jarek.jpa

"Zenexer सही है, समाधान होना चाहिए: stream.toArray (स्ट्रिंग [] :: नया)); ... ठीक है, लेकिन किसी को यह समझना चाहिए कि विधि संदर्भ तार्किक और कार्यात्मक रूप से बराबर है toArray(sz -> new String[sz])इसलिए मुझे यकीन नहीं है कि कोई वास्तव में कह सकता है कि समाधान क्या होना चाहिए या होना चाहिए।

— स्कूटब

@scott sz -> new String[sz]एक नया फंक्शन बनाता है जहाँ कंस्ट्रक्टर रेफरेंस नहीं होता है। यह निर्भर करता है कि आप गारबेज कलेक्शन मंथन को कितना महत्व देते हैं।

— वर्कस

@ नेटवर्क यह नहीं करता है। यह (स्टैटिकली!) एक नया, private तरीका बनाता है , जो मंथन का कारण नहीं बन सकता है, और दोनों संस्करणों को एक नई वस्तु बनाने की आवश्यकता है। एक संदर्भ एक वस्तु बनाता है जो सीधे लक्ष्य पद्धति पर इंगित करता है; एक लैम्ब्डा एक ऑब्जेक्ट बनाता है जो उत्पन्न पर इंगित करता privateहै। एक निर्माता का एक संदर्भ अभी भी अप्रत्यक्ष और आसान वीएम अनुकूलन की कमी के लिए बेहतर प्रदर्शन करना चाहिए, लेकिन मंथन का इससे कोई लेना-देना नहीं है।

— एचटीएनडब्लू

@HTNW आप सही हैं, मेरी माफी चाहते हैं। यह डिबग करने का मेरा प्रयास था जो पहली बार मैंने ऐसा करने की कोशिश कर रहा था, जिसके कारण यह मंथन हो रहा था, इसलिए मैंने इसे अपने सिर में दबा लिया था कि यह कैसा था। (ऐसा होने पर घृणा करो)।

— कार्यस्थल

Answer 2

यदि आप स्ट्रीम से 1 से 10 के मान के साथ, इन्टस की एक सरणी प्राप्त करना चाहते हैं, तो आपके निपटान में IntStream है।

यहाँ हम एक Stream.of विधि के साथ एक स्ट्रीम बनाते हैं और एक MapToInt का उपयोग करके स्ट्रीम को एक IntStream में परिवर्तित करते हैं। तब हम IntStream की toArray विधि को कॉल कर सकते हैं।

Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
//or use this to create our stream 
//Stream<Integer> stream = IntStream.rangeClosed(1, 10).boxed();
int[] array =  stream.mapToInt(x -> x).toArray();

यहाँ एक ही बात है, स्ट्रीम के बिना, केवल IntStream का उपयोग करना

int[]array2 =  IntStream.rangeClosed(1, 10).toArray();

Answer 3

आप इस साधारण कोड ब्लॉक का उपयोग करके java 8 स्ट्रीम को सरणी में बदल सकते हैं:

 String[] myNewArray3 = myNewStream.toArray(String[]::new);

लेकिन चलो चीजों को और अधिक समझाते हैं, पहले, चलो तीन मूल्यों से भरे स्ट्रिंग की एक सूची बनाएं:

String[] stringList = {"Bachiri","Taoufiq","Abderrahman"};

दिए गए Array से एक स्ट्रीम बनाएँ:

Stream<String> stringStream = Arrays.stream(stringList);

अब हम इस स्ट्रीम पर कुछ ऑपरेशन कर सकते हैं Ex:

Stream<String> myNewStream = stringStream.map(s -> s.toUpperCase());

और अंत में इसे इन विधियों का उपयोग करके एक जावा 8 ऐरे में परिवर्तित करें:

1-क्लासिक विधि (कार्यात्मक इंटरफ़ेस)

IntFunction<String[]> intFunction = new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
};


String[] myNewArray = myNewStream.toArray(intFunction);

2 -लम्बड़ा अभिव्यक्ति

 String[] myNewArray2 = myNewStream.toArray(value -> new String[value]);

3- विधि संदर्भ

String[] myNewArray3 = myNewStream.toArray(String[]::new);

विधि संदर्भ स्पष्टीकरण:

यह लंबोदर अभिव्यक्ति लिखने का एक और तरीका है कि यह दूसरे के साथ कड़ाई के बराबर है।

Answer 4

टेक्स्ट को स्ट्रिंग एरे में कनवर्ट करें जहां कॉमा द्वारा प्रत्येक मान को अलग किया जा रहा है, और उदाहरण के लिए, प्रत्येक फ़ील्ड को ट्रिम करें:

String[] stringArray = Arrays.stream(line.split(",")).map(String::trim).toArray(String[]::new);

Answer 5

आप एक कस्टम कलेक्टर बना सकते हैं जो एक स्ट्रीम को सरणी में परिवर्तित करता है।

public static <T> Collector<T, ?, T[]> toArray( IntFunction<T[]> converter )
{
    return Collectors.collectingAndThen( 
                  Collectors.toList(), 
                  list ->list.toArray( converter.apply( list.size() ) ) );
}

और एक त्वरित उपयोग

List<String> input = Arrays.asList( ..... );

String[] result = input.stream().
         .collect( CustomCollectors.**toArray**( String[]::new ) );

Comments

आप इसे Stream.toArray (IntFunction) के बजाय इसका उपयोग क्यों करेंगे ?

— डिडिएर एल

मुझे 2-arg पास करने के लिए एक कलेक्टर की आवश्यकता थी Collectors.groupingByताकि मैं प्रति विशेषता मान में ऑब्जेक्ट्स के सरणियों के लिए कुछ विशेषता मैप कर सकूं । यह उत्तर मुझे ठीक वैसा ही देता है। इसके अलावा @DidierL।

— ओले वीवी

Answer 6

toArray(IntFunction<A[]> generator)विधि का उपयोग करना वास्तव में एक बहुत ही सुरुचिपूर्ण और सुरक्षित तरीका है (या अधिक सही ढंग से इकट्ठा करने के लिए) एक स्ट्रीम को उसी प्रकार के स्ट्रीम में सरणी में।

हालाँकि, यदि दी गई सरणी का प्रकार महत्वपूर्ण नहीं है, तो बस toArray()विधि का उपयोग करना आसान और छोटा दोनों है । उदाहरण के लिए:

    Stream<Object> args = Stream.of(BigDecimal.ONE, "Two", 3);
    System.out.printf("%s, %s, %s!", args.toArray());

Answer 7

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

int[] arr=   stream.mapToInt(x->x.intValue()).toArray();

Answer 8

import java.util.List;
import java.util.stream.Stream;

class Main {

    public static void main(String[] args) {
        // Create a stream of strings from list of strings
        Stream<String> myStreamOfStrings = List.of("lala", "foo", "bar").stream();

        // Convert stream to array by using toArray method
        String[] myArrayOfStrings = myStreamOfStrings.toArray(String[]::new);

        // Print results
        for (String string : myArrayOfStrings) {
            System.out.println(string);
        }
    }
}

इसे ऑनलाइन आज़माएँ: https://repl.it/@SmaMa/Stream-to-array

Comments

आपके उत्तर और स्वीकृत उत्तर में क्या अंतर है?

— लंबे गुयेन 13

@LongNguyen यह एक ऑनलाइन रिप्ले परिदृश्य सहित एक पूर्ण उदाहरण है, न केवल एक स्निपेट।

— Sma Ma

Answer 9

     Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

     Integer[] integers = stream.toArray(it->new Integer[it]);

Answer 10

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

List<String> persons = new ArrayList<String>(){{add("a"); add("b"); add("c");}};
Stream<String> stream = persons.stream();

अब आप निम्न में से किसी भी तरीके का उपयोग कर सकते हैं।

1. परिभाषित आकार के साथ एक नया स्ट्रिंगर्रे बनाने के लिए लैम्ब्डा एक्सप्रेशियन का उपयोग करना।

   स्ट्रिंग [] stringArray = stream.toArray (आकार-> नया स्ट्रिंग [आकार]);

2. सीधे विधि संदर्भ का उपयोग करना।

   स्ट्रिंग [] stringArray = stream.toArray (स्ट्रिंग [] :: नया);