लैंबड़ा अभिव्यक्ति सरणी / सूची को स्ट्रिंग की सरणी / सूची में बदलने के लिए

Question

चूंकि जावा 8 शक्तिशाली लैम्ब्डा भावों के साथ आता है,

मैं स्ट्रिंग्स की सूची / सरणी को सरणी / सूची में पूर्णांक, फ़्लोट्स, डबल्स इत्यादि में बदलने के लिए एक फ़ंक्शन लिखना चाहूंगा।

सामान्य जावा में, यह उतना ही सरल होगा

for(String str : strList){
   intList.add(Integer.valueOf(str));
}

लेकिन मैं एक लैंबडा के साथ कैसे हासिल करूं, स्ट्रिंग्स की एक सरणी को एक पूर्णांक में परिवर्तित किया जा सकता है।

Answer 1

आप सहायक विधियों का निर्माण कर सकते हैं, जो ऑपरेशन का उपयोग करके प्रकार Tकी एक सूची (सरणी) को एक सूची (सरणी) में बदल देगा ।Umapstream

//for lists
public static <T, U> List<U> convertList(List<T> from, Function<T, U> func) {
    return from.stream().map(func).collect(Collectors.toList());
}

//for arrays
public static <T, U> U[] convertArray(T[] from, 
                                      Function<T, U> func, 
                                      IntFunction<U[]> generator) {
    return Arrays.stream(from).map(func).toArray(generator);
}

और इसे इस तरह से उपयोग करें:

//for lists
List<String> stringList = Arrays.asList("1","2","3");
List<Integer> integerList = convertList(stringList, s -> Integer.parseInt(s));

//for arrays
String[] stringArr = {"1","2","3"};
Double[] doubleArr = convertArray(stringArr, Double::parseDouble, Double[]::new);

---

ध्यान दें कि s -> Integer.parseInt(s)इसे बदला जा सकता है Integer::parseInt( विधि संदर्भ देखें )

Comments

यदि आप अमरूद का उपयोग कर रहे हैं, तो आप भी उपयोग कर सकते हैं Lists.transform()।

— अलेक्जेंड्रोस

बहुत अच्छा उदाहरण है। फ़ंक्शन कोड को अधिक बहुमुखी और शक्तिशाली बनाता है। Thks !!!

— मार्सेलो रेबुकास

Answer 2

List<Integer> intList = strList.stream()
                               .map(Integer::valueOf)
                               .collect(Collectors.toList());

Comments

क्या आप इसे थोड़ा समझा सकते हैं?

— उन्नीलीग

यह स्ट्रिंग की एक सूची को एक स्ट्रीम में परिवर्तित कर रहा है और फिर सूची के प्रत्येक तत्व को इंटेगर में परिवर्तित कर रहा है और फिर एक सूची में एकत्रित कर रहा है।

— हेमंतो

यह स्वीकृत उत्तर होना चाहिए, क्योंकि लैम्ब्डा के बिंदु (एक लैंबडा अभिव्यक्ति के लिए मूल प्रश्न पूछता है) एक नए फ़ंक्शन को परिभाषित करने से बचने के लिए है। जिसके शीर्ष पर, यह उत्तर मौजूदा इंटेगर :: वैल्यूऑफ फंक्शन का उपयोग करता है

— जोनाथन बेन्

Answer 3

स्वीकृत उत्तर से सहायक विधियों की आवश्यकता नहीं है। विधाओं का उपयोग लंबोदर के साथ किया जा सकता है या आमतौर पर विधि सन्दर्भों का उपयोग करके छोटा किया जा सकता है । धाराएं कार्यात्मक संचालन को सक्षम करती हैं। map()तत्वों को रूपांतरित करता है और collect(...)या toArray()फिर स्ट्रीम को एक सरणी या संग्रह में लपेटता है।

वेंकट सुब्रमण्यम की बात (वीडियो) मुझे इससे बेहतर बताती है।

1 में परिवर्तित List<String>करेंList<Integer>

List<String> l1 = Arrays.asList("1", "2", "3");
List<Integer> r1 = l1.stream().map(Integer::parseInt).collect(Collectors.toList());

// the longer full lambda version:
List<Integer> r1 = l1.stream().map(s -> Integer.parseInt(s)).collect(Collectors.toList());

2 में परिवर्तित List<String>करेंint[]

int[] r2 = l1.stream().mapToInt(Integer::parseInt).toArray();

3 में परिवर्तित String[]करेंList<Integer>

String[] a1 = {"4", "5", "6"};
List<Integer> r3 = Stream.of(a1).map(Integer::parseInt).collect(Collectors.toList());

4 में परिवर्तित String[]करेंint[]

int[] r4 = Stream.of(a1).mapToInt(Integer::parseInt).toArray();

5 में परिवर्तित String[]करेंList<Double>

List<Double> r5 = Stream.of(a1).map(Double::parseDouble).collect(Collectors.toList());

6 (बोनस) में कनवर्ट int[]करेंString[]

int[] a2 = {7, 8, 9};
String[] r6 = Arrays.stream(a2).mapToObj(Integer::toString).toArray(String[]::new);

बहुत अधिक बदलाव निश्चित रूप से संभव हैं।

इन उदाहरणों का Ideone संस्करण भी देखें । कांटा क्लिक कर सकते हैं और फिर ब्राउज़र में चलाने के लिए चला सकते हैं।

Answer 4

संपादित करें: जैसा कि टिप्पणियों में बताया गया है, यह एक बहुत ही सरल संस्करण है: Arrays.stream(stringArray).mapToInt(Integer::parseInt).toArray() इस तरह हम एक सूची में और पूरे रूपांतरण को छोड़ सकते हैं।

---

मुझे एक और एक लाइन समाधान मिला, लेकिन यह अभी भी बहुत धीमा है (चक्र के लिए लगभग 100 गुना अधिक समय लगता है - 6000 0 के सरणी पर परीक्षण किया गया)

String[] stringArray = ...
int[] out= Arrays.asList(stringArray).stream().map(Integer::parseInt).mapToInt(i->i).toArray();

यह क्या करता है:

1. Arrays.asList () सरणी को सूची में परिवर्तित करता है
2. .St इसे एक स्ट्रीम में कनवर्ट करता है (एक नक्शा करने के लिए आवश्यक)
3. .map (Integer :: parseInt) स्ट्रीम के सभी तत्वों को इंटेगर में परिवर्तित करता है
4. .mapToInt (i-> i) सभी इंटेगर को किलों में परिवर्तित करता है (आपको ऐसा करने की जरूरत नहीं है यदि आप केवल इंटीजर चाहते हैं)
5. .toArray () स्ट्रीम को सरणी में वापस कनवर्ट करता है

Comments

आपको चरण 1 और 4 की आवश्यकता नहीं है:Arrays.stream(stringArray).mapToInt(Integer::parseInt).toArray()

— xehpuk

Answer 5

सूची के लिए:

List<Integer> intList 
 = stringList.stream().map(Integer::valueOf).collect(Collectors.toList());

सरणी के लिए:

int[] intArray = Arrays.stream(stringArray).mapToInt(Integer::valueOf).toArray();

Answer 6

आप भी उपयोग कर सकते हैं,

List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");

    Integer[] array = list.stream()
        .map( v -> Integer.valueOf(v))
        .toArray(Integer[]::new);

Answer 7

मुझे यह पिछले उत्तर में नहीं मिला, इसलिए, जावा 8 और धाराओं के साथ:

में परिवर्तित String[]करें Integer[]:

Arrays.stream(stringArray).map(Integer::valueOf).toArray(Integer[]::new)

Answer 8

इसके अलावा - नियंत्रण जब स्ट्रिंग सरणी में तत्व नहीं हैं:

Arrays.stream(from).filter(t -> (t != null)&&!("".equals(t))).map(func).toArray(generator) 

Answer 9

मैंने लेग्डा ऑपरेशन के साथ maptoInt () का इस्तेमाल किया जो कि स्ट्रिंग को इंटेगर में परिवर्तित करने के लिए किया गया था

int[] arr = Arrays.stream(stringArray).mapToInt(item -> Integer.parseInt(item)).toArray();

Answer 10

Arrays.toString (int []) मेरे लिए काम करता है।

Comments

मैं इस सवाल का जवाब नहीं देता: "लैम्बदास के साथ इसे कैसे प्राप्त किया जाए"।

— सर्गेई सिरिक