JavaRush /جاوا بلاگ /Random-SD /جاوا 8 گائيڊ. 1 حصو.

سطح

28 February 2021
44 views
0 comments

جاوا 8 گائيڊ. 1 حصو.

"جاوا اڃا زنده آهي - ۽ ماڻهو ان کي سمجهڻ شروع ڪري رهيا آهن."

جاوا 8 جي منهنجي تعارف ۾ ڀليڪار. هي گائيڊ توهان کي ٻوليءَ جي سڀني نئين خاصيتن جي ذريعي قدم قدم تي وٺي ويندي. مختصر، سادي ڪوڊ جي مثالن ذريعي، توهان سکندا ته ڪيئن استعمال ڪجي انٽرفيس ڊفالٽ طريقا , lambda expressions , reference methods , and repetable annotations . آرٽيڪل جي آخر تائين، توهان APIs ۾ جديد تبديلين جهڙوڪ اسٽريمز، فنڪشن انٽرفيس، ايسوسيئيشن ايڪسٽينشن، ۽ نئين تاريخ API کان واقف ٿي ويندا. بورنگ متن جي ڪابه ديوار نه آهي - صرف تبصرو ڪيل ڪوڊ جي ٽڪرن جو هڪ گروپ. مزو وٺو!

انٽرفيس لاءِ ڊفالٽ طريقا

Java 8 اسان کي انٽرفيس ۾ لاڳو ڪيل غير تجريدي طريقا شامل ڪرڻ جي اجازت ڏئي ٿو ڊفالٽ لفظ جي استعمال ذريعي . هي خصوصيت پڻ سڃاتي وڃي ٿي توسيع طريقن جي طور تي . هتي اسان جو پهريون مثال آهي: interface Formula { double calculate(int a); default double sqrt(int a) { return Math.sqrt(a); } } خلاصي طريقي جي حساب سان گڏ ، فارمولا انٽرفيس پڻ وضاحت ڪري ٿو هڪ ڊفالٽ طريقو sqrt . ڪلاس جيڪي فارمولا انٽرفيس کي لاڳو ڪن ٿا صرف خلاصي حساب ڪتاب جو طريقو لاڳو ڪن ٿا . ڊفالٽ sqrt طريقو استعمال ڪري سگھجي ٿو سڌو دٻي مان ٻاهر. فارمولا

Formula formula = new Formula() { @Override public double calculate(int a) { return sqrt(a * 100); } }; formula.calculate(100); // 100.0 formula.sqrt(16); // 4.0

اعتراض هڪ گمنام اعتراض جي طور تي لاڳو ڪيو ويو آهي. ڪوڊ ڪافي متاثر ڪندڙ آهي: ڪوڊ جون 6 لائينون صرف حساب ڪرڻ لاءِ sqrt(a * 100) . جيئن ته اسين ايندڙ حصي ۾ ڏسنداسين، جاوا 8 ۾ ھڪڙي طريقي واري شين کي لاڳو ڪرڻ لاء ھڪڙو وڌيڪ پرڪشش طريقو آھي.

Lambda اظهار

اچو ته هڪ سادي مثال سان شروع ڪريون ته جاوا جي شروعاتي ورزن ۾ تارن جي هڪ صف کي ڪيئن ترتيب ڏيو: شمارياتي مددگار طريقو Collections.sort ڏنل فهرست جي عناصرن کي ترتيب ڏيڻ لاءِ هڪ فهرست ۽ هڪ Comparator وٺندو آهي . ڇا اڪثر ٿئي ٿو ته توهان گمنام موازن ٺاهيندا آهيو ۽ انهن کي طريقن کي ترتيب ڏيڻ لاء پاس ڪندا آهيو. هر وقت گمنام شيون ٺاهڻ جي بدران، جاوا 8 توهان کي تمام گهٽ نحو استعمال ڪرڻ جي صلاحيت ڏئي ٿو، ليمبڊا ايڪسپريس : جيئن توهان ڏسي سگهو ٿا، ڪوڊ تمام ننڍو ۽ پڙهڻ ۾ آسان آهي. پر ھتي اھو اڃا به ننڍو ٿي وڃي ٿو: ھڪڙي لڪير واري طريقي لاءِ، توھان حاصل ڪري سگھوٿا {} curly braces ۽ return keyword . پر هتي اهو آهي جتي ڪوڊ اڃا به ننڍو ٿي وڃي ٿو: جاوا ڪمپلر پيٽرولس جي قسمن کان واقف آهي، تنهنڪري توهان انهن کي پڻ ڇڏي سگهو ٿا. ھاڻي اچو ته ان ۾ وڌيڪ گہرا ھلون ته ڪيئن لامبدا اظهار حقيقي زندگي ۾ استعمال ڪري سگھجن ٿا.

List
   names = Arrays.asList("peter", "anna", "mike", "xenia"); Collections.sort(names, new Comparator
   
    () { @Override public int compare(String a, String b) { return b.compareTo(a); } });

Collections.sort(names, (String a, String b) -> { return b.compareTo(a); }); Collections.sort(names, (String a, String b) -> b.compareTo(a)); Collections.sort(names, (a, b) -> b.compareTo(a));

فنڪشنل انٽرفيس

جاوا ٽائيپ سسٽم ۾ لامبڊا ايڪسپريس ڪيئن ٺهندا آهن؟ هر ليمبڊا انٽرفيس طرفان بيان ڪيل ڏنل قسم سان ملندو آهي. ۽ نام نهاد فنڪشنل انٽرفيس ۾ لازمي طور تي ھڪڙو اعلان ڪيل خلاصو طريقو آھي. ڏنل قسم جي هر ليمبڊا ايڪسپريشن هن تجريدي طريقي سان ملندڙ هوندي. جيئن ته ڊفالٽ طريقا تجريدي طريقا نه آهن، توهان آزاد آهيو پنهنجي فنڪشنل انٽرفيس ۾ ڊفالٽ طريقا شامل ڪرڻ لاءِ. اسان استعمال ڪري سگھون ٿا صوابديدي انٽرفيس کي ليمبڊا ايڪسپريس جي طور تي، بشرطيڪ ته انٽرفيس ۾ صرف هڪ خلاصو طريقو هجي. انهي کي يقيني بڻائڻ لاءِ ته توهان جو انٽرفيس انهن شرطن کي پورو ڪري ٿو، توهان کي شامل ڪرڻ گهرجي @FunctionalInterface تشريح . مرتب ڪندڙ کي هن تشريح ذريعي ٻڌايو ويندو ته انٽرفيس ۾ صرف هڪ طريقو هجڻ گهرجي، ۽ جيڪڏهن هن انٽرفيس ۾ هڪ ٻيو خلاصو طريقو سامهون اچي ٿو، اهو هڪ غلطي اڇلائي ڇڏيندو. مثال: ذهن ۾ رکو ته هي ڪوڊ به صحيح هوندو جيتوڻيڪ @FunctionalInterface تشريح جو اعلان نه ڪيو ويو هجي.

@FunctionalInterface interface Converter
   { T convert(F from); }

Converter
   converter = (from) -> Integer.valueOf(from); Integer converted = converter.convert("123"); System.out.println(converted); // 123

طريقن ۽ constructors جي حوالي سان

مٿي ڏنل مثال کي وڌيڪ آسان بڻائي سگهجي ٿو شمارياتي طريقي جي حوالي سان استعمال ڪندي: Java 8 توهان کي اجازت ڏئي ٿو حوالن کي پاس ڪرڻ جي طريقن ۽ تعمير ڪندڙن کي استعمال ڪندي :: keyword signs . مٿي ڏنل مثال ڏيکاري ٿو ته ڪيئن شمارياتي طريقا استعمال ڪري سگھجن ٿا. پر اسان شين تي طريقن جو حوالو پڻ ڏئي سگھون ٿا: اچو ته ڏسو ته ڪيئن استعمال ڪندي :: تعمير ڪندڙن لاءِ ڪم ڪري ٿو. پهرين، اچو ته مختلف تعمير ڪندڙن سان هڪ مثال بيان ڪريون: اڳيون، اسان نئين شخص جي شين کي ٺاهڻ لاءِ PersonFactory فيڪٽري انٽرفيس جي وضاحت ڪريون ٿا :

Converter
   converter = Integer::valueOf; Integer converted = converter.convert("123"); System.out.println(converted); // 123

class Something { String startsWith(String s) { return String.valueOf(s.charAt(0)); } }

Something something = new Something(); Converter
   converter = something::startsWith; String converted = converter.convert("Java"); System.out.println(converted); // "J"

class Person { String firstName; String lastName; Person() {} Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } }

interface PersonFactory

{ P create(String firstName, String lastName); } فيڪٽري کي دستي طور تي لاڳو ڪرڻ جي بدران، اسان هڪ تعميراتي حوالي سان استعمال ڪندي هر شيء کي گڏ ڪريون ٿا: اسان Person::new ذريعي فرد طبقي جي تعمير ڪندڙ جو حوالو ٺاهيندا آهيون . جاوا ڪمپلر خود بخود مناسب ٺاھيندڙ کي سڏيندو ٺاھيندڙن جي دستخط کي PersonFactory.create طريقي جي دستخط سان موازنہ ڪندي . PersonFactory personFactory = Person::new; Person person = personFactory.create("Peter", "Parker");

Lambda علائقي

لامبڊا ايڪسپريسز مان ٻاهرين دائري جي متغير تائين رسائي کي منظم ڪرڻ هڪ گمنام شئي کان رسائي ڪرڻ جي برابر آهي. توھان حاصل ڪري سگھوٿا آخري متغيرن کي مقامي دائري مان، گڏوگڏ مثال جي فيلڊ ۽ مجموعي متغير.

مقامي variables تائين رسائي

اسان لامبڊا ايڪسپريشن جي دائري مان فائنل موڊيفائر سان مقامي متغير پڙهي سگهون ٿا : پر گمنام شين جي برعڪس، متغيرن کي حتمي قرار ڏيڻ جي ضرورت ناهي ته ليمبڊا ايڪسپريشن مان رسائي حاصل ڪرڻ لاءِ . هي ڪوڊ پڻ صحيح آهي: جڏهن ته، نمبر متغير لازمي طور تي تبديل ٿيڻ گهرجي، يعني. ضابطي جي تاليف لاءِ ضمني فائنل ٿيڻ. هيٺ ڏنل ڪوڊ مرتب نه ٿيندو: لامبڊا ايڪسپريس ۾ نمبر ۾ تبديلين جي به اجازت ناهي.

final int num = 1; Converter
   stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3

int num = 1; Converter
   stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3

int num = 1; Converter
   stringConverter = (from) -> String.valueOf(from + num); num = 3;

مثال جي فيلڊ ۽ شمارياتي متغير تائين رسائي

مقامي متغيرن جي برعڪس، اسان پڙهي ۽ تبديل ڪري سگھون ٿا مثال جي شعبن ۽ شمارياتي متغيرن اندر lambda ايڪسپريس. اسان هن رويي کي گمنام شين مان ڄاڻون ٿا.

class Lambda4 { static int outerStaticNum; int outerNum; void testScopes() { Converter
   stringConverter1 = (from) -> { outerNum = 23; return String.valueOf(from); }; Converter
   
    stringConverter2 = (from) -> { outerStaticNum = 72; return String.valueOf(from); }; } }

انٽرفيس جي ڊفالٽ طريقن تائين رسائي

پهرين حصي مان فارمولا مثال سان مثال ياد رکو ؟ فارمولا انٽرفيس هڪ ڊفالٽ sqrt طريقو بيان ڪري ٿو جيڪو فارمولا جي هر مثال مان رسائي سگهجي ٿو ، بشمول گمنام شيون. اهو ڪم نه ڪندو آهي lambda اظهار سان. ڊفالٽ طريقن تائين رسائي نه ٿي ڪري سگھجي اندر لامبڊا اظهار. هيٺ ڏنل ڪوڊ مرتب نٿو ڪري: Formula formula = (a) -> sqrt( a * 100);

بلٽ ان فنڪشنل انٽرفيس

JDK 1.8 API ڪيترن ئي تعمير ٿيل فنڪشنل انٽرفيس تي مشتمل آهي. انهن مان ڪجهه جاوا جي پوئين نسخن کان چڱي ريت سڃاتل آهن. مثال طور Comparator يا Runnable . انهن انٽرفيس کي وڌايو ويو آهي شامل ڪرڻ لاءِ lambda سپورٽ استعمال ڪندي @FunctionalInterface تشريح . پر جاوا 8 API پڻ نئين فنڪشنل انٽرفيس سان ڀريل آهي جيڪي توهان جي زندگي کي آسان بڻائي سگهندا. انهن مان ڪجهه انٽرفيس گوگل جي گووا لائبريري مان مشهور آهن . جيتوڻيڪ توهان هن لائبريري سان واقف آهيو، توهان کي ويجهي نظر رکڻ گهرجي ته اهي انٽرفيس ڪيئن وڌا ويا آهن، ڪجهه مفيد توسيع طريقن سان.

اڳڪٿي ڪري ٿو

Predicates هڪ دليل سان Boolean فنڪشن آهن. انٽرفيس ۾ پيچيده منطقي اظهار (۽، يا، نفي) ٺاهڻ لاءِ اڳڪٿيون استعمال ڪرڻ لاءِ مختلف ڊفالٽ طريقا شامل آهن.

Predicate
   predicate = (s) -> s.length() > 0; predicate.test("foo"); // true predicate.negate().test("foo"); // false Predicate
   
    nonNull = Objects::nonNull; Predicate
    
     isNull = Objects::isNull; Predicate
     
      isEmpty = String::isEmpty; Predicate
      
       isNotEmpty = isEmpty.negate();

افعال

فنڪشن هڪ دليل وٺن ٿا ۽ نتيجو پيدا ڪن ٿا. ڊفالٽ طريقا استعمال ڪري سگھجن ٿا ڪيترن ئي ڪمن کي گڏ ڪرڻ لاءِ هڪ زنجير ۾ گڏ ڪريو (ڪمپوز، ۽ پوءِ).

Function
   toInteger = Integer::valueOf; Function
   
    backToString = toInteger.andThen(String::valueOf); backToString.apply("123"); // "123"

فراهم ڪندڙ

سپلائرز ھڪڙي قسم يا ٻئي جو نتيجو (مثال) موٽائي ٿو. افعال جي برعڪس، مهيا ڪندڙ دليل نه وٺندا آهن.

Supplier
   personSupplier = Person::new; personSupplier.get(); // new Person

صارفين

صارفين هڪ واحد دليل سان انٽرفيس طريقن جي نمائندگي ڪن ٿا.

Consumer
   greeter = (p) -> System.out.println("Hello, " + p.firstName); greeter.accept(new Person("Luke", "Skywalker"));

موازنہ ڪندڙ

جاوا جي پوئين ورزن مان اسان کي Comparators سڃاتل آهن. جاوا 8 توهان کي مختلف ڊفالٽ طريقا شامل ڪرڻ جي اجازت ڏئي ٿو انٽرفيس ۾.

Comparator
   comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); Person p1 = new Person("John", "Doe"); Person p2 = new Person("Alice", "Wonderland"); comparator.compare(p1, p2); // > 0 comparator.reversed().compare(p1, p2); // < 0

اختياري

Optionals انٽرفيس فنڪشنل نه آهي، پر NullPointerException کي روڪڻ لاءِ هڪ وڏي افاديت آهي . اهو ايندڙ سيڪشن لاءِ هڪ اهم نقطو آهي، تنهنڪري اچو ته هڪ تڪڙو نظر وجهون ته هي انٽرفيس ڪيئن ڪم ڪري ٿو. اختياري انٽرفيس قدرن لاءِ ھڪڙو سادو ڪنٽينر آھي جيڪو null يا غير null ٿي سگھي ٿو. تصور ڪريو ته ھڪڙو طريقو ھڪڙو قدر يا ڪجھھ موٽائي سگھي ٿو. جاوا 8 ۾، null موٽڻ جي بدران ، توهان هڪ اختياري مثال ڏيو ٿا .

Comparator
   comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); Person p1 = new Person("John", "Doe"); Person p2 = new Person("Alice", "Wonderland"); comparator.compare(p1, p2); // > 0 comparator.reversed().compare(p1, p2); // < 0

وهڪرو

java.util.Stream عناصر جو ھڪڙو سلسلو آھي جنھن تي ھڪڙو يا گھڻا آپريشن ڪيا ويندا آھن. هر وهڪرو آپريشن يا ته وچولي يا ٽرمينل آهي. ٽرمينل آپريشنز هڪ مخصوص قسم جي نتيجي ۾ موٽندا آهن، جڏهن ته وچولي آپريشن پاڻ کي وهڪرو اعتراض واپس آڻيندي، طريقي جي ڪالن جي هڪ زنجير کي پيدا ڪرڻ جي اجازت ڏئي ٿي. اسٽريم ھڪ انٽرفيس آھي، جھڙوڪ java.util.Collection فهرستن ۽ سيٽن لاءِ (نقشو سپورٽ نه آھن). ھر اسٽريم آپريشن کي ترتيب وار يا متوازي طور تي عمل ۾ آڻي سگھجي ٿو. اچو ته هڪ نظر رکون ته وهڪرو ڪيئن ڪم ڪري ٿو. پهرين، اسان نموني ڪوڊ ٺاهينداسين اسٽرنگ جي فهرست جي صورت ۾: جاوا 8 ۾ مجموعن کي وڌايو ويو آهي ته جيئن توهان مجموعي طور تي ڪال ڪري سگھوٿا اسٽريمز ٺاهي سگهو ٿا Collection.stream() يا Collection.parallelStream() . ايندڙ سيڪشن سڀ کان اهم، سادي اسٽريم آپريشن جي وضاحت ڪندو.

List
   stringCollection = new ArrayList<>(); stringCollection.add("ddd2"); stringCollection.add("aaa2"); stringCollection.add("bbb1"); stringCollection.add("aaa1"); stringCollection.add("bbb3"); stringCollection.add("ccc"); stringCollection.add("bbb2"); stringCollection.add("ddd1");

فلٽر

فلٽر اسٽريم جي سڀني عنصرن کي فلٽر ڪرڻ لاءِ اڳڪٿيون قبول ڪري ٿو. هي آپريشن وچولي آهي، جيڪا اسان کي ٻين اسٽريم آپريشنز کي ڪال ڪرڻ جي اجازت ڏئي ٿي (مثال طور ForEach) نتيجي تي (فلٽر ٿيل) نتيجو. ForEach هڪ آپريشن کي قبول ڪري ٿو جيڪو اڳ ۾ ئي فلٽر ٿيل وهڪرو جي هر عنصر تي ڪيو ويندو. ForEach هڪ ٽرمينل آپريشن آهي. ان کان سواء، ٻين عملن کي سڏڻ ناممڪن آهي. stringCollection .stream() .filter((s) -> s.startsWith("a")) .forEach(System.out::println); // "aaa2", "aaa1"

ترتيب ڏنل

ترتيب ڏنل هڪ وچولي آپريشن آهي جيڪو وهڪرو جي ترتيب ڏنل نمائندگي ڏي ٿو. عناصر صحيح ترتيب ۾ ترتيب ڏنل آھن جيستائين توھان پنھنجي Comparator جي وضاحت نه ڪريو . stringCollection .stream() .sorted() .filter((s) -> s.startsWith("a")) .forEach(System.out::println); // "aaa1", "aaa2" ذهن ۾ رکو ته ترتيب ڏنل ترتيب جي نمائندگي پيدا ڪري ٿي بغير پاڻ کي گڏ ڪرڻ تي اثر انداز ڪرڻ جي. stringCollection عناصر جو حڪم اڻڄاتل رهي ٿو: System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

نقشو

وچولي نقشي جو آپريشن هر عنصر کي ٻئي شئي ۾ بدلائي ٿو نتيجي واري فنڪشن کي استعمال ڪندي. هيٺ ڏنل مثال هر اسٽرنگ کي اپر ڪيس اسٽرنگ ۾ بدلائي ٿو. پر توهان پڻ استعمال ڪري سگهو ٿا نقشو هر شئي کي مختلف قسم ۾ تبديل ڪرڻ لاءِ. نتيجي ۾ نڪرندڙ اسٽريم شين جو قسم ان فنڪشن جي قسم تي منحصر هوندو آهي جيڪو توهان نقشي ڏانهن منتقل ڪيو ٿا.

stringCollection .stream() .map(String::toUpperCase) .sorted((a, b) -> b.compareTo(a)) .forEach(System.out::println); // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

ملائڻ

مختلف ملندڙ عملن کي استعمال ڪري سگھبو آهي سچائي کي جانچڻ لاءِ هڪ خاص اڳڪٿي جي وهڪري جي سلسلي ۾. سڀئي ميچ آپريشن ٽرمينل آهن ۽ هڪ Boolean نتيجو موٽايو.

boolean anyStartsWithA = stringCollection .stream() .anyMatch((s) -> s.startsWith("a")); System.out.println(anyStartsWithA); // true boolean allStartsWithA = stringCollection .stream() .allMatch((s) -> s.startsWith("a")); System.out.println(allStartsWithA); // false boolean noneStartsWithZ = stringCollection .stream() .noneMatch((s) -> s.startsWith("z")); System.out.println(noneStartsWithZ); // true

شمار

ڳڻپيو هڪ ٽرمينل آپريشن آهي جيڪو واپس ڪري ٿو نديءَ جي عنصرن جو تعداد هڪ ڊگهو .

long startsWithB = stringCollection .stream() .filter((s) -> s.startsWith("b")) .count(); System.out.println(startsWithB); // 3

گھٽائڻ

هي هڪ ٽرمينل آپريشن آهي جيڪو پاس ڪيل فنڪشن استعمال ڪندي وهڪري جي عناصر کي مختصر ڪري ٿو. نتيجو هڪ اختياري هوندو جنهن ۾ ننڍو قدر هوندو.

Optional
   reduced = stringCollection .stream() .sorted() .reduce((s1, s2) -> s1 + "#" + s2); reduced.ifPresent(System.out::println); // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"

متوازي وهڪرو

جيئن مٿي ذڪر ڪيو ويو آهي، سلسلو ترتيب يا متوازي ٿي سگهي ٿو. تسلسل واري وهڪري جا عمل سيريل سلسلي تي ڪيا ويندا آهن، جڏهن ته متوازي وهڪرو آپريشن ڪيترن ئي متوازي موضوعن تي ڪيا ويندا آهن. هيٺ ڏنل مثال ڏيکاري ٿو ته ڪيئن آسانيءَ سان ڪارڪردگيءَ کي وڌائڻ لاءِ هڪ متوازي وهڪرو استعمال ڪندي. پهرين، اچو ته منفرد عناصر جي هڪ وڏي فهرست ٺاهي: هاڻي اسان هن مجموعي جي وهڪري کي ترتيب ڏيڻ ۾ خرچ ڪيل وقت جو اندازو لڳايو.

int max = 1000000; List
   values = new ArrayList<>(max); for (int i = 0; i < max; i++) { UUID uuid = UUID.randomUUID(); values.add(uuid.toString()); }

سلسلو سلسلو

long t0 = System.nanoTime(); long count = values.stream().sorted().count(); System.out.println(count); long t1 = System.nanoTime(); long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); System.out.println(String.format("sequential sort took: %d ms", millis)); // sequential sort took: 899 ms

متوازي وهڪرو

long t0 = System.nanoTime(); long count = values.parallelStream().sorted().count(); System.out.println(count); long t1 = System.nanoTime(); long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); System.out.println(String.format("parallel sort took: %d ms", millis)); // parallel sort took: 472 ms

جئين توهان ڏسي سگهو ٿا، ٻئي ٽڪرا لڳ ڀڳ هڪجهڙا آهن، پر متوازي ترتيب 50٪ تيز آهي. توھان کي صرف تبديل ڪرڻ جي ضرورت آھي stream() parallelStream() ۾ .

نقشو

جيئن اڳ ۾ ئي ذڪر ڪيو ويو آهي، نقشا اسٽريم کي سپورٽ نٿا ڪن. ان جي بدران، نقشو عام مسئلن کي حل ڪرڻ لاء نئين ۽ مفيد طريقن جي حمايت ڪرڻ شروع ڪيو. مٿي ڏنل ڪوڊ سمجهه وارو هجڻ گهرجي: putIfAbsent اسان کي اضافي نول چيڪ لکڻ جي خلاف ڊيڄاري ٿو. forEach هڪ فنڪشن قبول ڪري ٿو هر هڪ نقشي جي قيمت لاءِ عمل ڪرڻ لاءِ. هي مثال ڏيکاري ٿو ته ڪئين ڪارڪردگي نقشي جي قيمتن تي ڪارڪردگي کي استعمال ڪندي انجام ڏنو ويو آهي: اڳيون، اسين ڄاڻون ٿا ته هڪ ڏنل ڪيئي جي داخلا کي ڪيئن هٽايو وڃي صرف ان صورت ۾ جڏهن اهو ڏنل قدر سان نقشو ٺاهي ٿو: ٻيو سٺو طريقو: نقشي جي داخلن کي ضم ڪرڻ بلڪل آسان آهي: ضم ڪرڻ يا ته ڪيچي/قدر کي نقشي ۾ داخل ڪندو، جيڪڏھن ڏنل ڪيئي لاءِ ڪا داخلا نه آھي، يا مرج فنڪشن کي سڏيو ويندو، جيڪو موجوده داخلا جي قدر کي تبديل ڪندو.

Map
   map = new HashMap<>(); for (int i = 0; i < 10; i++) { map.putIfAbsent(i, "val" + i); } map.forEach((id, val) -> System.out.println(val));

map.computeIfPresent(3, (num, val) -> val + num); map.get(3); // val33 map.computeIfPresent(9, (num, val) -> null); map.containsKey(9); // false map.computeIfAbsent(23, num -> "val" + num); map.containsKey(23); // true map.computeIfAbsent(3, num -> "bam"); map.get(3); // val33

map.remove(3, "val3"); map.get(3); // val33 map.remove(3, "val33"); map.get(3); // null map.getOrDefault(42, "not found"); // not found

map.merge(9, "val9", (value, newValue) -> value.concat(newValue)); map.get(9); // val9 map.merge(9, "concat", (value, newValue) -> value.concat(newValue)); map.get(9); // val9concat