आइए एक नए तरीके से समाचार और कोड को देखें।
तो, चलो सूची के साथ शुरू करते हैं।
मान लीजिए कि एक सूची है।
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
अब याद रखें कि हमने पुराने दिनों में कैसे पुनरावृत्ति की:
for (int i = 0; i < numbers.size(); i++){ System.out.println(numbers.get(i)); }
सब कुछ बहुत अच्छा है, लेकिन इसे बंद करना और <= के बजाय <या 1 से शुरू करना आसान है। 0. इसके बजाय उपरोक्त कोड में, हम पूरी तरह से यांत्रिकी को नियंत्रित करते हैं, हम सभी चलती भागों को ध्यान में रखते हैं। यह कई मामलों में अच्छा है, और किसी ने इसे जावा 5 में हमसे नहीं लिया, उन्होंने सिर्फ चीनी जोड़ा।
for(int num:numbers){ System.out.println(num); }
जावा 8 में, वे अभी भी कुछ भी नहीं लेते हैं, लेकिन वे "घोषणात्मक" दृष्टिकोण की पेशकश करते हैं, जिसका अर्थ है कि हम घोषणा करते हैं कि हम क्या करना चाहते हैं, और सभी यांत्रिकी को जेवीएम पर रखें।
numbers.forEach(value -> System.out.println(value));
ध्यान दें कि उदाहरण एक लैम्ब्डा अभिव्यक्ति का उपयोग करता है। अगले पैराग्राफ में उसके बारे में। कई पहले से ही कई भाषाओं और पुस्तकालयों में देख चुके हैं। इसलिए, हमें एक पंक्ति में "यहां आपके लिए एक संग्रह है, इस अभिव्यक्ति को इसके सभी तत्वों पर लागू करने की अनुमति देता है" (घोषणात्मक दृष्टिकोण), और "पहले से शुरू होने और अंतिम के साथ समाप्त होने पर, एक-एक करके पुन: व्यवस्थित करें और प्रत्येक तत्व का उपयोग करें"।
अब लंबोदर भावों के बारे में।
एक बहुत ही स्वादिष्ट नवाचार जो कार्यों के साथ अनाम कक्षाओं को बदलने की अनुमति देता है।
ऊपर दिए गए उदाहरण पर विचार करें:
numbers.forEach(value -> System.out.println(value));
अगर कोई लंबोदर भाव नहीं थे, तो यह उदाहरण इस तरह दिखाई देगा:
numbers.forEach(new Consumer<Integer>() { @Override public void accept(Integer integer) { System.out.println(integer); } @Override public Consumer<Integer> andThen(Consumer<? super Integer> after) { return null; } });
यह जटिल है, है ना। लेकिन एक सरल एक-लाइन अभिव्यक्ति पर वापस, और यहां आप अभी भी कुछ सरल कर सकते हैं: हमें दो बार मूल्य का उल्लेख क्यों करना चाहिए, अगर यह पहले से ही स्पष्ट है कि कोई अन्य चर नहीं हो सकता है।
numbers.forEach(System.out::println);
हां, हां, हमने फ़ंक्शन (*) के रूप में विधि पारित की। तो हमने कहा, "यहाँ आपके लिए एक विधि है, इसे लूप में लागू करें।"
अनाम वर्गों को फ़ंक्शंस के साथ बदलने के कुछ और उदाहरण हैं:
स्ट्रीम निर्माण:
new Thread(SomeClass::runSomething).start();
तुलनित्र क्रमबद्ध
Collections.sort(numbers, (o1, o2)-> o2.compareTo(o1));
कलेक्शंस फ्रेमवर्क में बदलाव
लैम्ब्डा के भावों के बारे में जानने के बाद, हम कलेक्शन फ्रेमवर्क में नवीनतम पर जाएँगे। मान लीजिए, हमें सूची में सभी संख्याओं के योग को दो से गुणा करने की आवश्यकता है। दो बार सोचने के बिना, हम एक कोड बनाते हैं:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6); int sum = 0; for (int num : numbers) { sum += num * 2; }
अब घोषणात्मक दृष्टिकोण की ओर मुड़ते हैं:
int result = numbers.stream(). mapToInt(value->value*2). sum();
एक मिनट रुको, क्या यह नक्शा-कम नहीं है? वह सबसे है। हम क्रम में विश्लेषण करेंगे। इसलिए mapToInt मानचित्र संचालन करता है, जिसके परिणामस्वरूप तत्व दो गुना हो जाते हैं। योग एक पूर्ण रूपांतरण है जो केवल पूर्णांकों के लिए उपलब्ध है।
मान लीजिए कि एक आदेश कोड को संशोधित करने और केवल विषम लोगों को संसाधित करने और विषम लोगों को फ़िल्टर करने के लिए प्राप्त हुआ है।
System.out.println(numbers.stream(). filter(value -> value % 2 == 0). mapToInt(value -> value * 2). sum());
अब इसके विपरीत, विषम गणना और यहां तक कि बाहर फेंक:
System.out.println(numbers.stream(). filter(value -> value % 2 != 0). mapToInt(value -> value * 2). sum());
एक और नई भाषा सुविधा
हम इस तथ्य के लिए उपयोग किए जाते हैं कि इंटरफ़ेस हमें बताता है कि "हम क्या करेंगे", लेकिन अपने दम पर कुछ भी नहीं करता है। जावा 8 में, इंटरफ़ेस कभी-कभी कुछ करता है।
यहाँ आपके लिए एक उदाहरण है:
public interface IFly { public void takeOff(); public default void cruise() { System.out.println("IFly.cruise"); }; public void turn(); public void land(); }
जो लोग C ++ में प्रोग्राम करते हैं और Björn Staustrup पढ़ते हैं, वे सवाल पूछेंगे: "हीरे की समस्या के बारे में क्या?"। सवाल दिलचस्प है। और एक जवाब है।
मान लीजिए कि एक वर्ग को दो इंटरफेस विरासत में मिले हैं, और उनमें से प्रत्येक में एक डिफ़ॉल्ट विधि है। संकलन के दौरान एक त्रुटि होगी।
public interface A { default void hello() { System.out.println("Hello World from A"); } } public interface B { default void hello() { System.out.println("Hello World from B"); } public class D implements A,B {}
आइए एक और उदाहरण देखें: एक त्रिकोण
public interface A { default void hello() { System.out.println("Hello World from A"); } } public interface B extends A { default void hello() { System.out.println("Hello World from B"); } } public class C implements B, A { public static void main(String... args) { new C().hello(); } }
इस स्थिति में, पदानुक्रम में निकटतम व्यक्ति जीत जाएगा, अर्थात् इंटरफ़ेस बी। खैर, यदि आप इंटरफ़ेस ए की विधि का उपयोग करना चाहते हैं, तो आपको स्पष्ट रूप से निर्दिष्ट करना होगा
A.super.hello();
आइए एक तीसरा उदाहरण देखें: एक अमूर्त वर्ग और इंटरफ़ेस में परस्पर विरोधी विधि है। नियम - वर्ग हमेशा जीतता है।
इस प्रकार, समस्या हल हो गई है:
- यदि संघर्ष समान पदानुक्रम स्तर पर है - संकलक ऐसा नहीं होने देगा
- अगर विभिन्न स्तरों पर - निकटतम जीत जाएगा
- यदि इंटरफ़ेस वर्ग के विरुद्ध है, तो वर्ग जीतता है
एक जोड़े को अधिक उपहार
Base64, संकलक ने हमें कितने समय तक अप्रचलित sun.misc.Base64 के बारे में भयानक संदेश दिए और आपको एक साधारण सी चीज के लिए अपाचेव पुस्तकालयों का उपयोग करना पड़ा।
अब समस्या हल हो गई है: java.util.Base64
Base64.getEncoder().encode(new byte[]{1, 2, 3, 4, 5});
नई तारीख और समय एपीआई। यदि आप अच्छे पुराने ग्रेगोरियन कैलंडर की कल्पना नहीं कर सकते हैं, तो आप नई घड़ी, समय, स्थानीय समय वर्गों की कोशिश कर सकते हैं
import java.time.LocalDate; import java.time.Period; ... LocalDate time = LocalDate.now(); Period period = Period.ofDays(2); LocalDate newDate = time.plus(period); System.out.println("year:"+newDate.getYear()); System.out.println("month:"+newDate.getMonth()); System.out.println("day:"+newDate.getDayOfMonth());