जावा 8 - त्वरित गाइड

JAVA 8, JAVA प्रोग्रामिंग भाषा के विकास की एक प्रमुख विशेषता है। इसका प्रारंभिक संस्करण 18 मार्च 2014 को जारी किया गया था। जावा 8 रिलीज के साथ, जावा ने कार्यात्मक प्रोग्रामिंग, नए जावास्क्रिप्ट इंजन, तारीख के समय के लिए नए एपीआई, नए स्ट्रीमिंग एपीआई, आदि के लिए समर्थन प्रदान किया।

नए विशेषताएँ

  • Lambda expression - जावा के लिए कार्यात्मक प्रसंस्करण क्षमता जोड़ता है।

  • Method references- सीधे उनके नाम को लागू करने के बजाय उनके नाम से कार्य करना। पैरामीटर के रूप में कार्यों का उपयोग करना।

  • Default method - डिफ़ॉल्ट विधि कार्यान्वयन के लिए इंटरफ़ेस।

  • New tools - नए संकलक उपकरण और उपयोगिताओं को निर्भरता का पता लगाने के लिए 'jdeps' की तरह जोड़ा जाता है।

  • Stream API - पाइपलाइन प्रसंस्करण की सुविधा के लिए नई स्ट्रीम एपीआई।

  • Date Time API - बेहतर तारीख समय एपीआई।

  • Optional - अशक्त मूल्यों को ठीक से संभालने के लिए सर्वोत्तम प्रथाओं पर जोर।

  • Nashorn, JavaScript Engine - जावास्क्रिप्ट कोड को निष्पादित करने के लिए जावा-आधारित इंजन।

निम्नलिखित कोड स्निपेट पर विचार करें।

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Java8Tester {

   public static void main(String args[]) {
   
      List<String> names1 = new ArrayList<String>();
      names1.add("Mahesh ");
      names1.add("Suresh ");
      names1.add("Ramesh ");
      names1.add("Naresh ");
      names1.add("Kalpesh ");
		
      List<String> names2 = new ArrayList<String>();
      names2.add("Mahesh ");
      names2.add("Suresh ");
      names2.add("Ramesh ");
      names2.add("Naresh ");
      names2.add("Kalpesh ");
		
      Java8Tester tester = new Java8Tester();
      System.out.println("Sort using Java 7 syntax: ");
		
      tester.sortUsingJava7(names1);
      System.out.println(names1);
      System.out.println("Sort using Java 8 syntax: ");
		
      tester.sortUsingJava8(names2);
      System.out.println(names2);
   }
   
   //sort using java 7
   private void sortUsingJava7(List<String> names) {   
      Collections.sort(names, new Comparator<String>() {
         @Override
         public int compare(String s1, String s2) {
            return s1.compareTo(s2);
         }
      });
   }
   
   //sort using java 8
   private void sortUsingJava8(List<String> names) {
      Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
   }
}

निम्नलिखित परिणाम प्राप्त करने के लिए कार्यक्रम चलाएं।

Sort using Java 7 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]
Sort using Java 8 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]

यहां ही sortUsingJava8() विधि छँटाई मापदंड प्राप्त करने के लिए पैरामीटर के रूप में एक लंबोदर अभिव्यक्ति के साथ सॉर्ट फ़ंक्शन का उपयोग करता है।

स्थानीय पर्यावरण सेटअप

यदि आप जावा प्रोग्रामिंग भाषा के लिए अपना खुद का वातावरण स्थापित करना चाहते हैं, तो यह अनुभाग आपको पूरी प्रक्रिया के माध्यम से मार्गदर्शन करता है। कृपया अपना जावा वातावरण सेट करने के लिए नीचे दिए गए चरणों का पालन करें।

जावा एसई को निम्न लिंक से मुफ्त में डाउनलोड किया जा सकता है -

https://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html

आप अपने ऑपरेटिंग सिस्टम के आधार पर एक संस्करण डाउनलोड करते हैं।

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

Windows 2000 / XP के लिए पथ की स्थापना

मान लें कि आपने c: \ Program Files \ java \ jdk निर्देशिका में Java स्थापित किया है -

  • 'मेरा कंप्यूटर' पर राइट-क्लिक करें और 'गुण' चुनें।

  • 'उन्नत' टैब के अंतर्गत 'पर्यावरण चर' बटन पर क्लिक करें।

  • अब, 'Path' वैरिएबल को बदल दें ताकि इसमें जावा एक्जीक्यूटेबल का पथ भी शामिल हो। उदाहरण के लिए, यदि पथ वर्तमान में 'C: \ WINDOWS \ SYSTEM32' पर सेट है, तो 'C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin' पढ़ने के लिए अपना पथ परिवर्तित करें।

विंडोज 95/98 / ME के ​​लिए पथ की स्थापना

मान लें कि आपने c: \ Program Files \ java \ jdk निर्देशिका में Java स्थापित किया है -

  • 'C: \ autoexec.bat' फ़ाइल को संपादित करें और अंत में निम्नलिखित पंक्ति जोड़ें -

    PATH =% PATH% सेट करें; C: \ Program Files \ java \ jdk \ bin

लिनक्स, यूनिक्स, सोलारिस, फ्रीबीएसडी के लिए पथ की स्थापना

जावा चर को स्थापित करने के लिए पर्यावरण चर पथ को निर्धारित किया जाना चाहिए। यदि आपको ऐसा करने में परेशानी होती है, तो अपने शेल दस्तावेज़ देखें।

उदाहरण के लिए, यदि आप अपने शेल के रूप में बैश का उपयोग करते हैं, तो आप अपने '.bashrc: PATH = / path / to / java: $ PATH' के अंत में निम्न पंक्ति जोड़ेंगे।

लोकप्रिय जावा संपादक

जावा प्रोग्राम लिखने के लिए, आपको एक टेक्स्ट एडिटर चाहिए। बाजार में और भी अधिक परिष्कृत IDE उपलब्ध हैं। लेकिन अभी के लिए, आप निम्नलिखित में से एक पर विचार कर सकते हैं -

  • Notepad - विंडोज मशीन पर, आप नोटपैड (इस ट्यूटोरियल के लिए अनुशंसित) या टेक्स्टपैड जैसे किसी भी सरल पाठ संपादक का उपयोग कर सकते हैं।

  • Netbeans- यह एक जावा आईडीई है जो ओपन-सोर्स और फ्री है। इससे डाउनलोड किया जा सकता हैhttps://netbeans.org/index.html।

  • Eclipse - यह एक जावा आईडीई भी है जिसे एक्लिप्स ओपन-सोर्स समुदाय द्वारा विकसित किया गया है और इससे डाउनलोड किया जा सकता है https://www.eclipse.org/।

लैम्ब्डा एक्सप्रेशन जावा 8 में पेश किए गए हैं और जावा 8. की सबसे बड़ी विशेषता बताई गई है। लैम्ब्डा एक्सप्रेशन में कार्यात्मक प्रोग्रामिंग की सुविधा है, और विकास को बहुत सरल करता है।

वाक्य - विन्यास

एक लैम्ब्डा अभिव्यक्ति की विशेषता निम्नलिखित सिंटैक्स द्वारा होती है।

parameter -> expression body

निम्नलिखित एक लंबोदर अभिव्यक्ति की महत्वपूर्ण विशेषताएं हैं।

  • Optional type declaration- पैरामीटर के प्रकार को घोषित करने की आवश्यकता नहीं है। कंपाइलर पैरामीटर के मूल्य से समान अनुमान लगा सकता है।

  • Optional parenthesis around parameter- कोष्ठक में एक भी पैरामीटर घोषित करने की आवश्यकता नहीं है। कई मापदंडों के लिए, कोष्ठकों की आवश्यकता होती है।

  • Optional curly braces - अगर शरीर में एक भी कथन हो, तो अभिव्यक्ति बॉडी में घुंघराले ब्रेस का उपयोग करने की आवश्यकता नहीं है।

  • Optional return keyword- कंपाइलर स्वचालित रूप से मान लौटाता है यदि शरीर के पास मूल्य वापस करने के लिए एकल अभिव्यक्ति है। घुंघराले ब्रेसिज़ को इंगित करने के लिए आवश्यक है कि अभिव्यक्ति एक मूल्य लौटाती है।

लैम्ब्डा एक्सप्रेशन उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester tester = new Java8Tester();
		
      //with type declaration
      MathOperation addition = (int a, int b) -> a + b;
		
      //with out type declaration
      MathOperation subtraction = (a, b) -> a - b;
		
      //with return statement along with curly braces
      MathOperation multiplication = (int a, int b) -> { return a * b; };
		
      //without return statement and without curly braces
      MathOperation division = (int a, int b) -> a / b;
		
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
		
      //without parenthesis
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
		
      //with parenthesis
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
		
      greetService1.sayMessage("Mahesh");
      greetService2.sayMessage("Suresh");
   }
	
   interface MathOperation {
      int operation(int a, int b);
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
	
   private int operate(int a, int b, MathOperation mathOperation) {
      return mathOperation.operation(a, b);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Mahesh
Hello Suresh

उपरोक्त उदाहरण में विचार किए जाने वाले महत्वपूर्ण बिंदु निम्नलिखित हैं।

  • लैम्ब्डा अभिव्यक्तियों का उपयोग मुख्य रूप से एक कार्यात्मक इंटरफ़ेस के इनलाइन कार्यान्वयन को परिभाषित करने के लिए किया जाता है, अर्थात, केवल एक विधि के साथ एक इंटरफ़ेस। उपरोक्त उदाहरण में, हमने MathOperation इंटरफ़ेस की संचालन विधि को परिभाषित करने के लिए विभिन्न प्रकार के लैम्ब्डा अभिव्यक्तियों का उपयोग किया है। फिर हमने GreetingService के sayMessage के कार्यान्वयन को परिभाषित किया है।

  • लैम्ब्डा अभिव्यक्ति अनाम वर्ग की आवश्यकता को समाप्त करती है और जावा को एक बहुत ही सरल लेकिन शक्तिशाली कार्यात्मक प्रोग्रामिंग क्षमता प्रदान करती है।

क्षेत्र

लैम्ब्डा अभिव्यक्ति का उपयोग करना, आप किसी भी अंतिम चर या प्रभावी रूप से अंतिम चर का उल्लेख कर सकते हैं (जो केवल एक बार सौंपा गया है)। यदि एक चर को दूसरी बार एक मान सौंपा जाता है, तो लैम्ब्डा अभिव्यक्ति एक संकलन त्रुटि फेंकता है।

स्कोप उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

public class Java8Tester {

   final static String salutation = "Hello! ";
   
   public static void main(String args[]) {
      GreetingService greetService1 = message -> 
      System.out.println(salutation + message);
      greetService1.sayMessage("Mahesh");
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Hello! Mahesh

विधि संदर्भ उनके नाम से विधियों को इंगित करने में मदद करते हैं। एक विधि संदर्भ "::" प्रतीक का उपयोग करके वर्णित है। एक विधि संदर्भ का उपयोग निम्न प्रकार के तरीकों को इंगित करने के लिए किया जा सकता है -

  • स्थैतिक तरीके
  • उदाहरण के तरीके
  • नए ऑपरेटर का उपयोग करने वाले निर्माता (ट्रीसेट :: नई)

विधि संदर्भ उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.util.List;
import java.util.ArrayList;

public class Java8Tester {

   public static void main(String args[]) {
      List names = new ArrayList();
		
      names.add("Mahesh");
      names.add("Suresh");
      names.add("Ramesh");
      names.add("Naresh");
      names.add("Kalpesh");
		
      names.forEach(System.out::println);
   }
}

यहाँ हमने System.out :: println पद्धति को एक स्थिर विधि संदर्भ के रूप में पारित किया है।

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Mahesh
Suresh
Ramesh
Naresh
Kalpesh

कार्यात्मक इंटरफेस में प्रदर्शन करने के लिए एकल कार्यक्षमता है। उदाहरण के लिए, तुलनात्मक उद्देश्य के लिए एकल विधि 'ComparTo' के साथ एक तुलनीय इंटरफ़ेस का उपयोग किया जाता है। जावा 8 ने लंबोदर भावों में बड़े पैमाने पर इस्तेमाल किए जाने वाले बहुत सारे कार्यात्मक इंटरफेस को परिभाषित किया है। निम्नलिखित java.util.Function पैकेज में परिभाषित कार्यात्मक इंटरफेस की सूची है।

अनु क्रमांक। इंटरफ़ेस और विवरण
1

BiConsumer<T,U>

एक ऑपरेशन का प्रतिनिधित्व करता है जो दो इनपुट तर्कों को स्वीकार करता है, और कोई परिणाम नहीं देता है।
2

BiFunction<T,U,R>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दो तर्कों को स्वीकार करता है और एक परिणाम पैदा करता है।
3

BinaryOperator<T>

एक ही प्रकार के दो ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है, जिससे ऑपरेंड के समान प्रकार का परिणाम होता है।
4

BiPredicate<T,U>

दो तर्कों के एक विधेय (बूलियन-मूल्यवान फ़ंक्शन) का प्रतिनिधित्व करता है।
5

BooleanSupplier

बूलियन-मूल्यवान परिणामों के एक आपूर्तिकर्ता का प्रतिनिधित्व करता है।
6

Consumer<T>

एक ऑपरेशन का प्रतिनिधित्व करता है जो एकल इनपुट तर्क को स्वीकार करता है और कोई परिणाम नहीं देता है।
7

DoubleBinaryOperator

दो डबल-वैल्यू ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है और एक डबल-वैल्यू परिणाम का उत्पादन करता है।
8

DoubleConsumer

एक ऐसे ऑपरेशन का प्रतिनिधित्व करता है जो एक एकल दोहरे मान वाले तर्क को स्वीकार करता है और कोई परिणाम नहीं देता है।
9

DoubleFunction<R>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दोहरे मान वाले तर्क को स्वीकार करता है और एक परिणाम पैदा करता है।
10

DoublePredicate

एक डबल-मूल्यवान तर्क के एक विधेय (बूलियन-मूल्यवान फ़ंक्शन) का प्रतिनिधित्व करता है।
1 1

DoubleSupplier

दोहरा-मूल्यवान परिणामों के एक आपूर्तिकर्ता का प्रतिनिधित्व करता है।
12

DoubleToIntFunction

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दोहरे मान वाले तर्क को स्वीकार करता है और एक पूर्व-मूल्यवान परिणाम पैदा करता है।
13

DoubleToLongFunction

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दोहरे मान वाले तर्क को स्वीकार करता है और एक लंबे समय से मूल्यवान परिणाम पैदा करता है।
14

DoubleUnaryOperator

एक एकल डबल-मूल्यवान ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है जो एक डबल-वैल्यू परिणाम का उत्पादन करता है।
15

Function<T,R>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक तर्क को स्वीकार करता है और एक परिणाम पैदा करता है।
16

IntBinaryOperator

दो पूर्व-मूल्यवान ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है और एक अंतर-मूल्यवान परिणाम पैदा करता है।
17

IntConsumer

एक ऑपरेशन का प्रतिनिधित्व करता है जो एक एकल पूर्व-मूल्यवान तर्क को स्वीकार करता है और कोई परिणाम नहीं देता है।
18

IntFunction<R>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक पूर्व-मूल्यवान तर्क को स्वीकार करता है और एक परिणाम पैदा करता है।
19

IntPredicate

एक पूर्व-मूल्यवान तर्क के एक विधेय (बूलियन-मूल्यवान फ़ंक्शन) का प्रतिनिधित्व करता है।
20

IntSupplier

पूर्व-मूल्यवान परिणामों के एक आपूर्तिकर्ता का प्रतिनिधित्व करता है।
21

IntToDoubleFunction

एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक पूर्व-मूल्यवान तर्क को स्वीकार करता है और एक डबल-मूल्यवान परिणाम पैदा करता है।
22

IntToLongFunction

एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक पूर्व-मूल्यवान तर्क को स्वीकार करता है और एक लंबे समय से मूल्यवान परिणाम पैदा करता है।
23

IntUnaryOperator

एक एकल पूर्व-मूल्यवान ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है जो एक पूर्व-मूल्यवान परिणाम पैदा करता है।
24

LongBinaryOperator

दो लंबे-मूल्यवान ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है और एक लंबे समय से मूल्यवान परिणाम पैदा करता है।
25

LongConsumer

एक ऐसे ऑपरेशन का प्रतिनिधित्व करता है जो एक लंबे समय से मूल्यवान तर्क को स्वीकार करता है और कोई परिणाम नहीं देता है।
26

LongFunction<R>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो लंबे समय से मूल्यवान तर्क को स्वीकार करता है और एक परिणाम पैदा करता है।
27

LongPredicate

एक लंबे समय से मूल्यवान तर्क के एक विधेय (बूलियन-मूल्यवान फ़ंक्शन) का प्रतिनिधित्व करता है।
28

LongSupplier

लंबे समय से मूल्यवान परिणामों के एक आपूर्तिकर्ता का प्रतिनिधित्व करता है।
29

LongToDoubleFunction

एक फ़ंक्शन का प्रतिनिधित्व करता है जो लंबे समय से मूल्यवान तर्क को स्वीकार करता है और एक डबल-मूल्यवान परिणाम पैदा करता है।
30

LongToIntFunction

एक फ़ंक्शन का प्रतिनिधित्व करता है जो लंबे समय से मूल्यवान तर्क को स्वीकार करता है और एक पूर्व-मूल्यवान परिणाम पैदा करता है।
31

LongUnaryOperator

एक लंबे समय से मूल्यवान ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है जो एक लंबे समय से मूल्यवान परिणाम पैदा करता है।
32

ObjDoubleConsumer<T>

एक ऑपरेशन का प्रतिनिधित्व करता है जो एक ऑब्जेक्ट-वैल्यू और एक डबल-वैल्यू तर्क स्वीकार करता है, और कोई परिणाम नहीं देता है।
33

ObjIntConsumer<T>

एक ऑपरेशन का प्रतिनिधित्व करता है जो एक ऑब्जेक्ट-वैल्यू और एक पूर्व-मूल्यवान तर्क को स्वीकार करता है, और कोई परिणाम नहीं देता है।
34

ObjLongConsumer<T>

एक ऑपरेशन का प्रतिनिधित्व करता है जो ऑब्जेक्ट-वैल्यू और लंबे समय से मूल्यवान तर्क को स्वीकार करता है, और कोई परिणाम नहीं देता है।
35

Predicate<T>

एक तर्क के एक विधेय (बूलियन-मूल्यवान फ़ंक्शन) का प्रतिनिधित्व करता है।
36

Supplier<T>

परिणामों के एक आपूर्तिकर्ता का प्रतिनिधित्व करता है।
37

ToDoubleBiFunction<T,U>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दो तर्कों को स्वीकार करता है और एक डबल-मूल्यवान परिणाम पैदा करता है।
38

ToDoubleFunction<T>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक डबल-मूल्यवान परिणाम पैदा करता है।
39

ToIntBiFunction<T,U>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दो तर्कों को स्वीकार करता है और एक पूर्व-मूल्यवान परिणाम पैदा करता है।
40

ToIntFunction<T>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक पूर्व-मूल्यवान परिणाम पैदा करता है।
41

ToLongBiFunction<T,U>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो दो तर्कों को स्वीकार करता है और एक लंबे समय से मूल्यवान परिणाम पैदा करता है।
42

ToLongFunction<T>

एक फ़ंक्शन का प्रतिनिधित्व करता है जो लंबे समय से मूल्यवान परिणाम पैदा करता है।
43

UnaryOperator<T>

एक एकल ऑपरेंड पर एक ऑपरेशन का प्रतिनिधित्व करता है जो अपने ऑपरेंड के समान प्रकार का परिणाम उत्पन्न करता है।

कार्यात्मक इंटरफ़ेस उदाहरण

एक बूलियन मान वापस करने के लिए विधि परीक्षण (ऑब्जेक्ट) के साथ एक </ T> इंटरफ़ेस एक कार्यात्मक इंटरफ़ेस है। यह इंटरफ़ेस दर्शाता है कि किसी वस्तु का परीक्षण सही या गलत होने के लिए किया गया है।

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Java8Tester {

   public static void main(String args[]) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
		
      // Predicate<Integer> predicate = n -> true
      // n is passed as parameter to test method of Predicate interface
      // test method will always return true no matter what value n has.
		
      System.out.println("Print all numbers:");
		
      //pass n as parameter
      eval(list, n->true);
		
      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n%2 comes to be zero
		
      System.out.println("Print even numbers:");
      eval(list, n-> n%2 == 0 );
		
      // Predicate<Integer> predicate2 = n -> n > 3
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n is greater than 3.
		
      System.out.println("Print numbers greater than 3:");
      eval(list, n-> n > 3 );
   }
	
   public static void eval(List<Integer> list, Predicate<Integer> predicate) {

      for(Integer n: list) {

         if(predicate.test(n)) {
            System.out.println(n + " ");
         }
      }
   }
}

यहाँ हमने Predicate इंटरफ़ेस पास किया है, जो एकल इनपुट लेता है और बूलियन देता है।

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Print all numbers:
1
2
3
4
5
6
7
8
9
Print even numbers:
2
4
6
8
Print numbers greater than 3:
4
5
6
7
8
9

जावा 8 इंटरफेस में डिफ़ॉल्ट पद्धति के कार्यान्वयन की एक नई अवधारणा का परिचय देता है। इस क्षमता को पिछड़े संगतता के लिए जोड़ा जाता है ताकि जावा 8 के लैम्ब्डा अभिव्यक्ति क्षमता का लाभ उठाने के लिए पुराने इंटरफेस का उपयोग किया जा सके।

उदाहरण के लिए, 'सूची' या 'संग्रह' इंटरफेस के पास 'पूर्व विधि' की घोषणा नहीं है। इस प्रकार, इस तरह की विधि को जोड़ने से संग्रह ढांचे का क्रियान्वयन टूट जाएगा। Java 8 डिफ़ॉल्ट विधि का परिचय देता है ताकि सूची / संग्रह इंटरफ़ेस में forEach पद्धति का डिफ़ॉल्ट कार्यान्वयन हो सके, और इन इंटरफेस को लागू करने वाले वर्ग को समान लागू करने की आवश्यकता न हो।

वाक्य - विन्यास

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

कई चूक

इंटरफेस में डिफ़ॉल्ट कार्यों के साथ, एक संभावना है कि एक वर्ग समान डिफ़ॉल्ट विधियों के साथ दो इंटरफेस को लागू कर रहा है। निम्नलिखित कोड बताता है कि इस अस्पष्टता को कैसे हल किया जा सकता है।

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

public interface fourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

पहला उपाय स्वयं की विधि बनाना है जो डिफ़ॉल्ट कार्यान्वयन को ओवरराइड करता है।

public class car implements vehicle, fourWheeler {

   public void print() {
      System.out.println("I am a four wheeler car vehicle!");
   }
}

दूसरा उपाय सुपर का उपयोग करके निर्दिष्ट इंटरफ़ेस की डिफ़ॉल्ट विधि को कॉल करना है।

public class car implements vehicle, fourWheeler {

   public void print() {
      vehicle.super.print();
   }
}

स्थैतिक डिफ़ॉल्ट तरीके

एक इंटरफ़ेस में जावा 8 के बाद से स्थैतिक सहायक विधियाँ भी हो सकती हैं।

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

डिफ़ॉल्ट विधि उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

public class Java8Tester {

   public static void main(String args[]) {
      Vehicle vehicle = new Car();
      vehicle.print();
   }
}

interface Vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

interface FourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

class Car implements Vehicle, FourWheeler {

   public void print() {
      Vehicle.super.print();
      FourWheeler.super.print();
      Vehicle.blowHorn();
      System.out.println("I am a car!");
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

I am a vehicle!
I am a four wheeler!
Blowing horn!!!
I am a car!

स्ट्रीम जावा 8 में शुरू की गई एक नई अमूर्त परत है। स्ट्रीम का उपयोग करके, आप एसक्यूएल स्टेटमेंट के समान ही डिक्लेक्टिव तरीके से डेटा प्रोसेस कर सकते हैं। उदाहरण के लिए, निम्न SQL कथन पर विचार करें।

SELECT max(salary), employee_id, employee_name FROM Employee

उपरोक्त एसक्यूएल अभिव्यक्ति स्वचालित रूप से अधिकतम वेतनभोगी कर्मचारी के विवरण को लौटाता है, बिना डेवलपर के अंत में कोई संगणना किए बिना। जावा में संग्रह ढांचे का उपयोग करते हुए, एक डेवलपर को छोरों का उपयोग करना पड़ता है और बार-बार चेक करना पड़ता है। एक और चिंता दक्षता है; जैसा कि मल्टी-कोर प्रोसेसर आसानी से उपलब्ध हैं, एक जावा डेवलपर को समानांतर कोड प्रसंस्करण लिखना पड़ता है जो बहुत त्रुटि-प्रवण हो सकता है।

इस तरह के मुद्दों को हल करने के लिए, जावा 8 ने धारा की अवधारणा को पेश किया जो डेवलपर को इसके लिए कोई विशिष्ट कोड लिखने की आवश्यकता के बिना डेटा को घोषणात्मक रूप से संसाधित करने और मल्टीकोर आर्किटेक्चर का लाभ उठाने की अनुमति देता है।

स्ट्रीम क्या है?

स्ट्रीम एक स्रोत से वस्तुओं के अनुक्रम का प्रतिनिधित्व करता है, जो कुल संचालन का समर्थन करता है। एक स्ट्रीम की विशेषताएं निम्नलिखित हैं -

  • Sequence of elements- एक धारा क्रमबद्ध तरीके से विशिष्ट प्रकार के तत्वों का एक सेट प्रदान करती है। एक स्ट्रीम मांग पर तत्वों को प्राप्त / गणना करता है। यह तत्वों को कभी संग्रहीत नहीं करता है।

  • Source - स्ट्रीम कलेक्शन, एरे, या I / O संसाधनों को इनपुट स्रोत के रूप में लेता है।

  • Aggregate operations - स्ट्रीम फ़िल्टर, मानचित्र, सीमा, घटाना, ढूंढना, मिलान करना, और इसी तरह के कुल संचालन का समर्थन करती है।

  • Pipelining- अधिकांश स्ट्रीम ऑपरेशन स्वयं स्ट्रीम को लौटाते हैं ताकि उनका परिणाम पाइपलाइन किया जा सके। इन परिचालनों को मध्यवर्ती संचालन कहा जाता है और उनका कार्य इनपुट लेना, उन्हें संसाधित करना और आउटपुट को लक्ष्य पर वापस लाना है। इकट्ठा () विधि एक टर्मिनल ऑपरेशन है जो आम तौर पर स्ट्रीम के अंत को चिह्नित करने के लिए पाइपलाइनिंग ऑपरेशन के अंत में मौजूद होता है।

  • Automatic iterations स्ट्रीम ऑपरेशन, संग्रह के विपरीत स्रोत तत्वों पर आंतरिक रूप से पुनरावृत्तियां करते हैं, जहां स्पष्ट पुनरावृत्ति की आवश्यकता होती है।

उत्पन्न करने वाली धाराएँ

जावा 8 के साथ, संग्रह इंटरफ़ेस में एक स्ट्रीम उत्पन्न करने के दो तरीके हैं।

  • stream() - संग्रह के स्रोत के रूप में विचार करते हुए एक अनुक्रमिक धारा लौटाता है।

  • parallelStream() - संग्रह के स्रोत के रूप में एक समानांतर स्ट्रीम पर विचार करता है।

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

प्रत्येक के लिए

स्ट्रीम ने धारा के प्रत्येक तत्व को पुनरावृत्त करने के लिए एक नई विधि 'forEach' प्रदान की है। निम्न कोड खंड दिखाता है कि forEach का उपयोग करके 10 यादृच्छिक संख्याओं को कैसे प्रिंट किया जाए।

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

नक्शा

'मैप' विधि का उपयोग प्रत्येक तत्व को उसके अनुरूप परिणाम के लिए मैप करने के लिए किया जाता है। निम्नलिखित कोड खंड मानचित्र का उपयोग करके संख्याओं के अनूठे वर्गों को प्रिंट करता है।

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

//get list of unique squares
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

फिल्टर

मापदंड के आधार पर तत्वों को खत्म करने के लिए 'फिल्टर' विधि का उपयोग किया जाता है। निम्नलिखित कोड खंड फिल्टर का उपयोग करके खाली तारों की एक गिनती प्रिंट करता है।

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
int count = strings.stream().filter(string -> string.isEmpty()).count();

सीमा

धारा के आकार को कम करने के लिए 'सीमा' विधि का उपयोग किया जाता है। निम्न कोड खंड दिखाता है कि सीमा का उपयोग करके 10 यादृच्छिक संख्याओं को कैसे प्रिंट किया जाए।

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

क्रमबद्ध

स्ट्रीम को सॉर्ट करने के लिए 'सॉर्टेड' पद्धति का उपयोग किया जाता है। निम्न कोड खंड दिखाता है कि क्रमबद्ध क्रम में 10 यादृच्छिक संख्याओं को कैसे प्रिंट किया जाए।

Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);

समानांतर प्रसंस्करण

समानांतर प्रसंस्करण के लिए धारा का विकल्प है। निम्नलिखित कोड खंड पर एक नज़र डालें जो समानांतर स्ट्र्रीम का उपयोग करके खाली तारों की एक गिनती प्रिंट करता है।

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

अनुक्रमिक और समानांतर धाराओं के बीच स्विच करना बहुत आसान है।

कलेक्टरों

एक धारा के तत्वों पर प्रसंस्करण के परिणाम को संयोजित करने के लिए कलेक्टरों का उपयोग किया जाता है। एक सूची या एक स्ट्रिंग वापस करने के लिए कलेक्टरों का उपयोग किया जा सकता है।

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

System.out.println("Filtered List: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);

आंकड़े

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

List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all numbers : " + stats.getAverage());

स्ट्रीम उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;

public class Java8Tester {

   public static void main(String args[]) {
      System.out.println("Using Java 7: ");
		
      // Count empty strings
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("List: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);
		
      System.out.println("Empty Strings: " + count);
      count = getCountLength3UsingJava7(strings);
		
      System.out.println("Strings of length 3: " + count);
		
      //Eliminate empty string
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("Filtered List: " + filtered);
		
      //Eliminate empty string and join using comma.
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("Merged String: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
		
      //get list of square of distinct numbers
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("Squares List: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
		
      System.out.println("List: " +integers);
      System.out.println("Highest number in List : " + getMax(integers));
      System.out.println("Lowest number in List : " + getMin(integers));
      System.out.println("Sum of all numbers : " + getSum(integers));
      System.out.println("Average of all numbers : " + getAverage(integers));
      System.out.println("Random Numbers: ");
		
      //print ten random numbers
      Random random = new Random();
		
      for(int i = 0; i < 10; i++) {
         System.out.println(random.nextInt());
      }
		
      System.out.println("Using Java 8: ");
      System.out.println("List: " +strings);
		
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
		
      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("Strings of length 3: " + count);
		
      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("Filtered List: " + filtered);
		
      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("Merged String: " + mergedString);
		
      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("List: " +integers);
		
      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
		
      System.out.println("Highest number in List : " + stats.getMax());
      System.out.println("Lowest number in List : " + stats.getMin());
      System.out.println("Sum of all numbers : " + stats.getSum());
      System.out.println("Average of all numbers : " + stats.getAverage());
      System.out.println("Random Numbers: ");
		
      random.ints().limit(10).sorted().forEach(System.out::println);
		
      //parallel processing
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
   }
	
   private static int getCountEmptyStringUsingJava7(List<String> strings) {
      int count = 0;

      for(String string: strings) {
		
         if(string.isEmpty()) {
            count++;
         }
      }
      return count;
   }
	
   private static int getCountLength3UsingJava7(List<String> strings) {
      int count = 0;
		
      for(String string: strings) {
		
         if(string.length() == 3) {
            count++;
         }
      }
      return count;
   }
	
   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings) {
      List<String> filteredList = new ArrayList<String>();
		
      for(String string: strings) {
		
         if(!string.isEmpty()) {
             filteredList.add(string);
         }
      }
      return filteredList;
   }
	
   private static String getMergedStringUsingJava7(List<String> strings, String separator) {
      StringBuilder stringBuilder = new StringBuilder();
		
      for(String string: strings) {
		
         if(!string.isEmpty()) {
            stringBuilder.append(string);
            stringBuilder.append(separator);
         }
      }
      String mergedString = stringBuilder.toString();
      return mergedString.substring(0, mergedString.length()-2);
   }
	
   private static List<Integer> getSquares(List<Integer> numbers) {
      List<Integer> squaresList = new ArrayList<Integer>();
		
      for(Integer number: numbers) {
         Integer square = new Integer(number.intValue() * number.intValue());
			
         if(!squaresList.contains(square)) {
            squaresList.add(square);
         }
      }
      return squaresList;
   }
	
   private static int getMax(List<Integer> numbers) {
      int max = numbers.get(0);
		
      for(int i = 1;i < numbers.size();i++) {
		
         Integer number = numbers.get(i);
			
         if(number.intValue() > max) {
            max = number.intValue();
         }
      }
      return max;
   }
	
   private static int getMin(List<Integer> numbers) {
      int min = numbers.get(0);
		
      for(int i= 1;i < numbers.size();i++) {
         Integer number = numbers.get(i);
		
         if(number.intValue() < min) {
            min = number.intValue();
         }
      }
      return min;
   }
	
   private static int getSum(List numbers) {
      int sum = (int)(numbers.get(0));
		
      for(int i = 1;i < numbers.size();i++) {
         sum += (int)numbers.get(i);
      }
      return sum;
   }
	
   private static int getAverage(List<Integer> numbers) {
      return getSum(numbers) / numbers.size();
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित परिणाम का उत्पादन करना चाहिए -

Using Java 7:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9
Random Numbers:
-1279735475
903418352
-1133928044
-1571118911
628530462
18407523
-881538250
-718932165
270259229
421676854
Using Java 8:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9.444444444444445
Random Numbers:
-1009474951
-551240647
-2484714
181614550
933444268
1227850416
1579250773
1627454872
1683033687
1798939493
Empty Strings: 2

वैकल्पिक एक कंटेनर वस्तु है जिसका उपयोग न-नल वस्तुओं में होता है। अनुपस्थित मान के साथ शून्य का प्रतिनिधित्व करने के लिए वैकल्पिक वस्तु का उपयोग किया जाता है। इस वर्ग में विभिन्न उपयोगी विधियाँ हैं, ताकि कोड मानों की जाँच करने के बजाय 'उपलब्ध' या 'उपलब्ध नहीं' जैसे मूल्यों को संभालने के लिए कोड को सुविधाजनक बनाया जा सके। यह जावा 8 में पेश किया गया है और यह अमरूद में वैकल्पिक के समान है।

वर्ग घोषणा

निम्नलिखित के लिए घोषणा है java.util.Optional<T> वर्ग -

public final class Optional<T> extends Object

कक्षा विधि

अनु क्रमांक। विधि और विवरण
1

static <T> Optional<T> empty()

एक खाली वैकल्पिक उदाहरण देता है।
2

boolean equals(Object obj)

इंगित करता है कि क्या कोई अन्य वस्तु "इस वैकल्पिक" के बराबर है।
3

Optional<T> filter(Predicate<? super <T> predicate)

यदि कोई मान मौजूद है और मान किसी दिए गए विधेय से मेल खाता है, तो यह मान का वर्णन करते हुए एक वैकल्पिक लौटाता है, अन्यथा एक खाली वैकल्पिक देता है।
4

<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)

यदि कोई मान मौजूद है, तो यह प्रदान किए गए वैकल्पिक-असर मानचित्रण फ़ंक्शन को उस पर लागू करता है, उस परिणाम को लौटाता है, अन्यथा एक खाली वैकल्पिक रिटर्न देता है।
5

T get()

यदि कोई मान इस वैकल्पिक में मौजूद है, तो मान लौटाता है, अन्यथा NoSuchElementException को फेंकता है।
6

int hashCode()

वर्तमान मान का हैश कोड मान लौटाता है, यदि कोई हो, या 0 (शून्य) यदि कोई मूल्य मौजूद नहीं है।
7

void ifPresent(Consumer<? super T> consumer)

यदि कोई मान मौजूद है, तो वह निर्दिष्ट उपभोक्ता को मूल्य के साथ आमंत्रित करता है, अन्यथा कुछ भी नहीं करता है।
8

boolean isPresent()

अगर कोई मूल्य मौजूद है, तो सत्य है, अन्यथा गलत है।
9

<U>Optional<U> map(Function<? super T,? extends U> mapper)

यदि कोई मान मौजूद है, तो प्रदान की गई मैपिंग फ़ंक्शन को उस पर लागू करता है, और यदि परिणाम गैर-शून्य है, तो परिणाम का वर्णन करते हुए एक वैकल्पिक देता है।
10

static <T> Optional<T> of(T value)

निर्दिष्ट वर्तमान गैर-शून्य मान के साथ एक वैकल्पिक लौटाता है।
1 1

static <T> Optional<T> ofNullable(T value)

गैर-अशक्त होने पर निर्दिष्ट मान का वर्णन करने वाला एक वैकल्पिक लौटाता है, अन्यथा एक खाली वैकल्पिक रिटर्न देता है।
12

T orElse(T other)

यदि मौजूद है तो मान लौटाता है, अन्यथा अन्य वापस करता है।
13

T orElseGet(Supplier<? extends T> other)

यदि मौजूद है तो मान लौटाता है, अन्यथा अन्य को आमंत्रित करता है और उस मंगलाचरण का परिणाम देता है।
14

<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)

निहित मान लौटाता है, यदि मौजूद है, अन्यथा प्रदान किए गए आपूर्तिकर्ता द्वारा बनाए जाने वाले अपवाद को फेंकता है।
15

String toString()

डीबगिंग के लिए उपयुक्त इस वैकल्पिक का एक गैर-रिक्त स्ट्रिंग प्रतिनिधित्व लौटाता है।

इस वर्ग को निम्न वर्ग से विधियाँ प्राप्त होती हैं -

  • java.lang.Object

वैकल्पिक उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.util.Optional;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
		
      //Optional.ofNullable - allows passed parameter to be null.
      Optional<Integer> a = Optional.ofNullable(value1);
		
      //Optional.of - throws NullPointerException if passed parameter is null
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
	
   public Integer sum(Optional<Integer> a, Optional<Integer> b) {
      //Optional.isPresent - checks the value is present or not
		
      System.out.println("First parameter is present: " + a.isPresent());
      System.out.println("Second parameter is present: " + b.isPresent());
		
      //Optional.orElse - returns the value if present otherwise returns
      //the default value passed.
      Integer value1 = a.orElse(new Integer(0));
		
      //Optional.get - gets the value, value should be present
      Integer value2 = b.get();
      return value1 + value2;
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

First parameter is present: false
Second parameter is present: true
10

जावा 8 के साथ, नैशॉर्न, एक बहुत बेहतर जावास्क्रिप्ट इंजन पेश किया गया है, जो मौजूदा राइनो को बदलने के लिए है। नैशॉर्न 2 से 10 गुना बेहतर प्रदर्शन प्रदान करता है, क्योंकि यह सीधे कोड को मेमोरी में संकलित करता है और जेवीएम को बाईटकोड पास करता है। नैशॉर्न ने प्रदर्शन को बेहतर बनाने के लिए जावा 7 में शुरू किए गए इनवॉइस डायनामिक्स फीचर का उपयोग किया है।

Jjs

नैशॉर्न इंजन के लिए, JAVA 8 एक नया कमांड लाइन टूल पेश करता है, jjs, कंसोल पर जावास्क्रिप्ट कोड निष्पादित करने के लिए।

जेएस फाइल की व्याख्या

फाइल बनाएं और सेव करें sample.js c: \> जावा फोल्डर में।

sample.js

print('Hello World!');

कंसोल खोलें और निम्न कमांड का उपयोग करें।

C:\JAVA>jjs sample.js

यह निम्नलिखित उत्पादन का उत्पादन करेगा:

Hello World!

इंटरएक्टिव मोड में jjs

कंसोल खोलें और निम्न कमांड का उपयोग करें।

C:\JAVA>jjs
jjs> print("Hello, World!")
Hello, World!
jjs> quit()
>>

तर्क पारित करें

कंसोल खोलें और निम्न कमांड का उपयोग करें।

C:\JAVA> jjs -- a b c
jjs> print('letters: ' +arguments.join(", "))
letters: a, b, c
jjs>

जावा से जावास्क्रिप्ट कॉलिंग

ScriptEngineManager का उपयोग करके जावा में जावास्क्रिप्ट कोड को बुलाया और व्याख्या की जा सकती है।

उदाहरण

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Java8Tester {

   public static void main(String args[]) {
      ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
      ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
		
      String name = "Mahesh";
      Integer result = null;
      
      try {
         nashorn.eval("print('" + name + "')");
         result = (Integer) nashorn.eval("10 + 2");
         
      } catch(ScriptException e) {
         System.out.println("Error executing script: "+ e.getMessage());
      }
      System.out.println(result.toString());
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित परिणाम का उत्पादन करना चाहिए -

Mahesh
12

जावा को जावास्क्रिप्ट से कॉल करना

निम्नलिखित उदाहरण जावा स्क्रिप्ट में जावा कक्षाओं को आयात और उपयोग करने का तरीका बताते हैं।

बनाएं और सहेजें sample.js c: \> जावा फोल्डर में।

sample.js

var BigDecimal = Java.type('java.math.BigDecimal');

function calculate(amount, percentage) {

   var result = new BigDecimal(amount).multiply(new BigDecimal(percentage)).divide(
      new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_EVEN);
   
   return result.toPlainString();
}
var result = calculate(568000000000000000023,13.9);
print(result);

कंसोल खोलें और निम्न कमांड का उपयोग करें।

C:\JAVA>jjs sample.js

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

78952000000000000003.20

जावा 8 के साथ, पुराने दिनांक-समय एपीआई की निम्नलिखित कमियों को कवर करने के लिए एक नया दिनांक-टाइम एपीआई पेश किया गया है।

  • Not thread safe- java.util.Date थ्रेड सुरक्षित नहीं है, इस प्रकार डेवलपर्स को तारीख का उपयोग करते समय संगामिति के मुद्दे से निपटना पड़ता है। नया दिनांक-समय API अपरिवर्तनीय है और इसमें सेटर विधियां नहीं हैं।

  • Poor design- डिफ़ॉल्ट तिथि 1900 से शुरू होती है, महीने 1 से शुरू होता है, और दिन 0 से शुरू होता है, इसलिए कोई एकरूपता नहीं है। पुराने एपीआई में तारीख संचालन के लिए कम प्रत्यक्ष तरीके थे। नया एपीआई इस तरह के संचालन के लिए कई उपयोगिता तरीके प्रदान करता है।

  • Difficult time zone handling- टाइमजोन के मुद्दों से निपटने के लिए डेवलपर्स को बहुत सारे कोड लिखने पड़ते थे। नए एपीआई को डोमेन-विशिष्ट डिज़ाइन को ध्यान में रखते हुए विकसित किया गया है।

जावा 8 पैकेज java.time के तहत एक नई तिथि-समय एपीआई पेश करता है। Java.time पैकेज में शुरू की गई कुछ महत्वपूर्ण कक्षाएं निम्नलिखित हैं।

  • Local - सरलीकृत तारीख-समय एपीआई समय जटिलता से निपटने की जटिलता के साथ नहीं।

  • Zoned - विभिन्न टाइमज़ोन से निपटने के लिए विशेष तिथि-समय एपीआई।

स्थानीय दिनांक-समय एपीआई

LocalDate / LocalTime और LocalDateTime वर्ग विकास को सरल बनाते हैं जहाँ टाइमज़ोन की आवश्यकता नहीं होती है। आइए देखते हैं उन्हें एक्शन में।

अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं, कहते हैं: C: \> JAVA।

Java8Tester.java

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testLocalDateTime();
   }
	
   public void testLocalDateTime() {
      // Get the current date and time
      LocalDateTime currentTime = LocalDateTime.now();
      System.out.println("Current DateTime: " + currentTime);
		
      LocalDate date1 = currentTime.toLocalDate();
      System.out.println("date1: " + date1);
		
      Month month = currentTime.getMonth();
      int day = currentTime.getDayOfMonth();
      int seconds = currentTime.getSecond();
		
      System.out.println("Month: " + month +"day: " + day +"seconds: " + seconds);
		
      LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
      System.out.println("date2: " + date2);
		
      //12 december 2014
      LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
      System.out.println("date3: " + date3);
		
      //22 hour 15 minutes
      LocalTime date4 = LocalTime.of(22, 15);
      System.out.println("date4: " + date4);
		
      //parse a string
      LocalTime date5 = LocalTime.parse("20:15:30");
      System.out.println("date5: " + date5);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Current DateTime: 2014-12-09T11:00:45.457
date1: 2014-12-09
Month: DECEMBERday: 9seconds: 45
date2: 2012-12-10T11:00:45.457
date3: 2014-12-12
date4: 22:15
date5: 20:15:30

ज़ोनड डेट-टाइम एपीआई

ज़ोनड डेट-टाइम API का उपयोग तब किया जाना है जब टाइम ज़ोन पर विचार किया जाए। हम उन्हें कार्रवाई में देखते हैं।

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
	
   public void testZonedDateTime() {
      // Get the current date and time
      ZonedDateTime date1 = ZonedDateTime.parse("2007-12-03T10:15:30+05:30[Asia/Karachi]");
      System.out.println("date1: " + date1);
		
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);
		
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("CurrentZone: " + currentZone);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

date1: 2007-12-03T10:15:30+05:00[Asia/Karachi]
ZoneId: Europe/Paris
CurrentZone: Etc/UTC

क्रोनो यूनिट्स एनम

java.time.temporal.hronoUnit enum को Java 8 में जोड़ा जाता है ताकि दिन, महीने आदि का प्रतिनिधित्व करने के लिए पुराने API में उपयोग किए जाने वाले पूर्णांक मानों को बदला जा सके।

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testChromoUnits();
   }
	
   public void testChromoUnits() {
      //Get the current date
      LocalDate today = LocalDate.now();
      System.out.println("Current date: " + today);
		
      //add 1 week to the current date
      LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
      System.out.println("Next week: " + nextWeek);
		
      //add 1 month to the current date
      LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + nextMonth);
		
      //add 1 year to the current date
      LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
      System.out.println("Next year: " + nextYear);
		
      //add 10 years to the current date
      LocalDate nextDecade = today.plus(1, ChronoUnit.DECADES);
      System.out.println("Date after ten year: " + nextDecade);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित परिणाम का उत्पादन करना चाहिए -

Current date: 2014-12-10
Next week: 2014-12-17
Next month: 2015-01-10
Next year: 2015-12-10
Date after ten year: 2024-12-10

अवधि और अवधि

जावा 8 के साथ, समय के अंतर से निपटने के लिए दो विशेष कक्षाएं शुरू की गई हैं।

  • Period - यह तारीख आधारित समय के साथ संबंधित है।

  • Duration - यह समय के आधार पर समय की मात्रा से संबंधित है।

हम उन्हें कार्रवाई में देखते हैं।

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.time.temporal.ChronoUnit;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Duration;
import java.time.Period;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testPeriod();
      java8tester.testDuration();
   }
	
   public void testPeriod() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //add 1 month to the current date
      LocalDate date2 = date1.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + date2);
      
      Period period = Period.between(date2, date1);
      System.out.println("Period: " + period);
   }
	
   public void testDuration() {
      LocalTime time1 = LocalTime.now();
      Duration twoHours = Duration.ofHours(2);
		
      LocalTime time2 = time1.plus(twoHours);
      Duration duration = Duration.between(time1, time2);
		
      System.out.println("Duration: " + duration);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Current date: 2014-12-10
Next month: 2015-01-10
Period: P-1M
Duration: PT2H

टेम्पोरल समायोजक

TemporalAdjuster का उपयोग दिनांक गणित करने के लिए किया जाता है। उदाहरण के लिए, "महीने का दूसरा शनिवार" या "अगला मंगलवार" प्राप्त करें। हम उन्हें कार्रवाई में देखते हैं।

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.time.DayOfWeek;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testAdjusters();
   }
	
   public void testAdjusters() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //get the next tuesday
      LocalDate nextTuesday = date1.with(TemporalAdjusters.next(DayOfWeek.TUESDAY));
      System.out.println("Next Tuesday on : " + nextTuesday);
		
      //get the second saturday of next month
      LocalDate firstInYear = LocalDate.of(date1.getYear(),date1.getMonth(), 1);
      LocalDate secondSaturday = firstInYear.with(TemporalAdjusters.nextOrSame(
         DayOfWeek.SATURDAY)).with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
      System.out.println("Second Saturday on : " + secondSaturday);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित परिणाम का उत्पादन करना चाहिए -

Current date: 2014-12-10
Next Tuesday on : 2014-12-16
Second Saturday on : 2014-12-13

अनिच्छुक अनुकूलता

मूल तिथि और कैलेंडर ऑब्जेक्ट में एक InInstant () विधि जोड़ी जाती है, जिसका उपयोग उन्हें नए दिनांक-समय API में परिवर्तित करने के लिए किया जा सकता है। LocalDateTime या ZonedDateTime ऑब्जेक्ट को प्राप्त करने के लिए Instant (Insant, ZoneId) पद्धति का उपयोग करें। हम उन्हें कार्रवाई में देखते हैं।

C: \> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.time.LocalDateTime;
import java.time.ZonedDateTime;

import java.util.Date;

import java.time.Instant;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testBackwardCompatability();
   }
	
   public void testBackwardCompatability() {
      //Get the current date
      Date currentDate = new Date();
      System.out.println("Current date: " + currentDate);
		
      //Get the instant of current date in terms of milliseconds
      Instant now = currentDate.toInstant();
      ZoneId currentZone = ZoneId.systemDefault();
		
      LocalDateTime localDateTime = LocalDateTime.ofInstant(now, currentZone);
      System.out.println("Local date: " + localDateTime);
		
      ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(now, currentZone);
      System.out.println("Zoned date: " + zonedDateTime);
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Current date: Wed Dec 10 05:44:06 UTC 2014
Local date: 2014-12-10T05:44:06.635
Zoned date: 2014-12-10T05:44:06.635Z[Etc/UTC]

जावा 8 के साथ, बेस 64 को आखिरकार इसका कारण मिल गया। Java 8 में अब बेस 64 एनकोडिंग के लिए इनबिल्ट एनकोडर और डिकोडर है। Java 8 में, हम तीन प्रकार के Base64 एन्कोडिंग का उपयोग कर सकते हैं।

  • Simple- आउटपुट को A-Za-z0-9 + / में पड़े हुए अक्षरों के समूह में मैप किया जाता है। एनकोडर आउटपुट में किसी भी लाइन फीड को नहीं जोड़ता है, और डिकोडर ए-ज़-ज़ेड0-9 / / के अलावा किसी भी वर्ण को अस्वीकार करता है।

  • URL- आउटपुट A-Za-z0-9 + _ में पड़े वर्णों के सेट करने के लिए मैप किया गया है। आउटपुट URL और फ़ाइल नाम सुरक्षित है।

  • MIME- आउटपुट को MIME फ्रेंडली प्रारूप में मैप किया जाता है। आउटपुट को 76 से अधिक वर्णों की पंक्तियों में दर्शाया गया है, और लाइन विभाजक के रूप में एक लाइनफीड '\ n' के बाद एक गाड़ी वापसी '\ r' का उपयोग करता है। एन्कोडेड आउटपुट के अंत में कोई लाइन विभाजक मौजूद नहीं है।

नेस्टेड क्लासेस

अनु क्रमांक। नेस्टेड क्लास और विवरण
1

static class Base64.Decoder

यह वर्ग RFC 4648 और RFC 445 में निर्दिष्ट Base64 एन्कोडिंग योजना का उपयोग करके बाइट डेटा को डिकोड करने के लिए एक डिकोडर लागू करता है।
2

static class Base64.Encoder

यह वर्ग R64 4648 और RFC 2045 में निर्दिष्ट बेस 64 एन्कोडिंग योजना का उपयोग करके बाइट डेटा एन्कोडिंग के लिए एक एनकोडर को लागू करता है।

तरीकों

अनु क्रमांक। विधि का नाम और विवरण
1

static Base64.Decoder getDecoder()

एक Base64.Decoder को लौटाता है जो मूल प्रकार की Base64 एन्कोडिंग योजना का उपयोग करके डिकोड करता है।
2

static Base64.Encoder getEncoder()

एक Base64.Encoder जो मूल प्रकार Base64 एन्कोडिंग योजना का उपयोग करते हुए एनकोड करता है।
3

static Base64.Decoder getMimeDecoder()

एक Base64.Decoder लौटाता है जो MIME प्रकार base64 डिकोडिंग योजना का उपयोग करके डिकोड करता है।
4

static Base64.Encoder getMimeEncoder()

एक Base64.Encoder लौटाता है जो MIME प्रकार base64 एन्कोडिंग योजना का उपयोग करके एन्कोड करता है।
5

static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator)

एक Base64.Encoder रिटर्न करता है जो MIME प्रकार की बेस 64 एन्कोडिंग स्कीम का उपयोग करके निर्दिष्ट लाइन लंबाई और लाइन विभाजकों के साथ एन्कोड करता है।
6

static Base64.Decoder getUrlDecoder()

एक Base64.Decoder लौटाता है जो URL और फाइलनाम सुरक्षित प्रकार Base64 एन्कोडिंग योजना का उपयोग करके डिकोड करता है।
7

static Base64.Encoder getUrlEncoder()

एक Base64.Encoder लौटाता है जो URL और फ़ाइल नाम सुरक्षित प्रकार Base64 एन्कोडिंग योजना का उपयोग करके एन्कोड करता है।

तरीके निहित हैं

इस वर्ग को निम्न वर्ग से विधियाँ प्राप्त होती हैं -

  • java.lang.Object

बेस 64 उदाहरण

C: /> JAVA में अपनी पसंद के किसी भी संपादक का उपयोग करके निम्नलिखित जावा प्रोग्राम बनाएं।

Java8Tester.java

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;

public class HelloWorld {

   public static void main(String args[]) {

      try {
		
         // Encode using basic encoder
         String base64encodedString = Base64.getEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (Basic) :" + base64encodedString);
		
         // Decode
         byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
		
         System.out.println("Original String: " + new String(base64decodedBytes, "utf-8"));
         base64encodedString = Base64.getUrlEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (URL) :" + base64encodedString);
		
         StringBuilder stringBuilder = new StringBuilder();
		
         for (int i = 0; i < 10; ++i) {
            stringBuilder.append(UUID.randomUUID().toString());
         }
		
         byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
         String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
         System.out.println("Base64 Encoded String (MIME) :" + mimeEncodedString);

      } catch(UnsupportedEncodingException e) {
         System.out.println("Error :" + e.getMessage());
      }
   }
}

परिणाम सत्यापित करें

का उपयोग कर वर्ग संकलित करें javac संकलक निम्नानुसार है -

C:\JAVA>javac Java8Tester.java

अब निम्नानुसार Java8Tester चलाएं -

C:\JAVA>java Java8Tester

यह निम्नलिखित उत्पादन का उत्पादन करना चाहिए -

Base64 Encoded String (Basic) :VHV0b3JpYWxzUG9pbnQ/amF2YTg=
Original String: TutorialsPoint?java8
Base64 Encoded String (URL) :VHV0b3JpYWxzUG9pbnQ_amF2YTg=
Base64 Encoded String (MIME) :YmU3NWY2ODktNGM5YS00ODlmLWI2MTUtZTVkOTk2YzQ1Njk1Y2EwZTg2OTEtMmRiZC00YTQ1LWJl
NTctMTI1MWUwMTk0ZWQyNDE0NDAwYjgtYTYxOS00NDY5LTllYTctNjc1YzE3YWJhZTk1MTQ2MDQz
NDItOTAyOC00ZWI0LThlOTYtZWU5YzcwNWQyYzVhMTQxMWRjYTMtY2MwNi00MzU0LTg0MTgtNGQ1
MDkwYjdiMzg2ZTY0OWU5MmUtZmNkYS00YWEwLTg0MjQtYThiOTQxNDQ2YzhhNTVhYWExZjItNjU2
Mi00YmM4LTk2ZGYtMDE4YmY5ZDZhMjkwMzM3MWUzNDMtMmQ3MS00MDczLWI0Y2UtMTQxODE0MGU5
YjdmYTVlODUxYzItN2NmOS00N2UyLWIyODQtMThlMWVkYTY4M2Q1YjE3YTMyYmItZjllMS00MTFk
LWJiM2UtM2JhYzUxYzI5OWI4
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved