جاوا ۾ lambda اظهار بابت مشهور. مثالن ۽ ڪمن سان. حصو 1

هي مضمون ڪنهن لاءِ آهي؟

• انهن لاءِ جيڪي سمجهن ٿا ته اهي اڳ ۾ ئي جاوا ڪور کي چڱي طرح ڄاڻن ٿا، پر جاوا ۾ لامبڊا اظهار بابت ڪا ڄاڻ ناهي. يا، شايد، توهان اڳ ۾ ئي ڪجهه ٻڌو آهي ليمبڊاس بابت، پر تفصيل کان سواء.
• انهن لاءِ جن کي لامبڊا جي اظهار جي ڪجهه سمجهه آهي، پر اڃا تائين انهن کي استعمال ڪرڻ کان ڊپ ۽ غير معمولي آهن.

جيڪڏهن توهان انهن مان ڪنهن هڪ درجي ۾ نه ٿا وڃو، توهان شايد هن مضمون کي بورنگ، غلط، ۽ عام طور تي "ٿڌو نه" ڳولي سگهو ٿا. انهي حالت ۾، يا ته آزاد محسوس ڪريو گذرڻ ۾، يا، جيڪڏهن توهان موضوع ۾ چڱي طرح ڄاڻو ٿا، تبصرن ۾ مشورو ڏيو ته آئون آرٽيڪل کي بهتر يا اضافي ڪري سگهان ٿو. مواد ڪنهن به علمي قدر جي دعويٰ نٿو ڪري، تمام گهٽ نوانيت. بلڪه، ان جي برعڪس: ان ۾ مان ڪوشش ڪندس پيچيده (ڪجهه لاءِ) شين کي بيان ڪرڻ جي جيترو ممڪن هجي. مون کي لکڻ لاءِ متاثر ڪيو ويو هو هڪ درخواست ذريعي اسٽريم ايپ جي وضاحت ڪرڻ لاءِ. مون ان بابت سوچيو ۽ فيصلو ڪيو ته ليمبڊا جي اظهار کي سمجهڻ کان سواءِ، ”اسٽريمز“ بابت منهنجا ڪجهه مثال سمجھ کان ٻاهر هوندا. سو اچو ته شروع ڪريون lambdas سان. ھن مضمون کي سمجھڻ لاءِ ڪھڙي ڄاڻ جي ضرورت آھي:

1. اعتراض تي مبني پروگرامنگ کي سمجھڻ (هتان کان پوء OOP جو حوالو ڏنو ويو آهي)، يعني:
• ڄاڻ ته ڪهڙا طبقا ۽ شيون آهن، انهن ۾ ڪهڙو فرق آهي؛
• ڄاڻو ته انٽرفيس ڇا آهن، اهي ڪئين طبقن کان مختلف آهن، انهن جي وچ ۾ ڪهڙو تعلق آهي (انٽرفيس ۽ طبقن)؛
• ڄاڻڻ جو طريقو ڇا آهي، ان کي ڪيئن سڏيو وڃي، هڪ خلاصو طريقو ڇا آهي (يا هڪ طريقو بغير ڪنهن عمل جي)، ڪنهن طريقي جا پيرا ميٽرس / دليل ڇا آهن، انهن کي ڪيئن منتقل ڪيو وڃي؛
• تبديلين تائين رسائي، جامد طريقا/متغير، آخري طريقا/متغير؛
• وراثت (ڪلاس، انٽرفيس، انٽرفيس جي گھڻن وراثت).
2. جاوا ڪور جو علم: عام، مجموعو (فهرست)، موضوع.

خير، اچو ته شروع ڪريون.

ٿوري تاريخ

Lambda ايڪسپريس جاوا ۾ فنڪشنل پروگرامنگ کان آيا، ۽ اتي رياضي کان. آمريڪا ۾ ويهين صديءَ جي وچ ڌاري، پرنسٽن يونيورسٽي ۾ هڪ خاص الونزو چرچ ڪم ڪيو، جنهن کي رياضي ۽ هر قسم جي تجريد جو تمام گهڻو شوق هو. اهو الونزو چرچ هو جيڪو لامبڊا حساب ڪتاب سان گڏ آيو، جيڪو پهرين ۾ ڪجهه تجريدي خيالن جو هڪ سيٽ هو ۽ پروگرامنگ سان ڪو به تعلق نه هو. ساڳئي وقت، رياضي دان جهڙوڪ ايلن ٽرنگ ۽ جان وون نيومن ساڳئي پرنسٽن يونيورسٽي ۾ ڪم ڪيو. سڀ ڪجهه گڏ ٿيو: چرچ لامبڊا حساب ڪتاب سان گڏ آيو، ٽرنگ پنهنجي تجريدي ڪمپيوٽنگ مشين کي ترقي ڪئي، جيڪا هاڻي "Turing مشين" جي نالي سان مشهور آهي. خير، وون نيومن ڪمپيوٽرن جي فن تعمير جو هڪ خاڪو پيش ڪيو، جيڪو جديد ڪمپيوٽرن جو بنياد بڻيو (۽ هاڻي "وان نيومن آرڪيٽيڪچر" سڏيو ويندو آهي). ان وقت، الونزو چرچ جي خيالن کي پنهنجي ساٿين جي ڪم جي طور تي تمام گهڻو شهرت حاصل نه ڪيو هو (سواء "خالص" رياضي جي ميدان جي). تنهن هوندي به، ٿوري دير کان پوء، هڪ خاص جان McCarthy (پڻ پرنسٽن يونيورسٽي جي گريجوئيٽ، ڪهاڻي جي وقت ۾ - ٽيڪنالاجي جي Massachusetts انسٽيٽيوٽ جي هڪ ملازم) چرچ جي خيالن ۾ دلچسپي ورتي. انهن جي بنياد تي، 1958 ۾ هن پهرين فنڪشنل پروگرامنگ ٻولي، Lisp ٺاهي. ۽ 58 سالن کان پوءِ، فنڪشنل پروگرامنگ جا خيال جاوا ۾ 8 نمبر تي لڪي ويا. اڃا 70 سال به نه گذريا آهن... حقيقت ۾، رياضياتي خيال کي عملي طور تي لاڳو ڪرڻ لاءِ اهو سڀ کان ڊگهو عرصو ناهي.

جوهر

هڪ lambda اظهار هڪ اهڙي فنڪشن آهي. توھان ھن کي جاوا ۾ ھڪڙي باقاعده طريقي جي طور تي سوچي سگھو ٿا، فرق صرف اھو آھي ته اھو ٻين طريقن کي دليل جي طور تي منظور ڪري سگھجي ٿو. ها، اهو ممڪن ٿي چڪو آهي ته نه رڳو نمبرن، تارن ۽ ڪيٽس کي طريقن سان، پر ٻين طريقن سان پڻ! جڏهن اسان کي هن جي ضرورت ٿي سگهي ٿي؟ مثال طور، جيڪڏهن اسان چاهيون ٿا ڪجهه ڪال بڪ پاس ڪرڻ. اسان کي ضرورت آهي ته اهو طريقو جنهن کي اسين سڏيندا آهيون ڪنهن ٻئي طريقي کي سڏڻ جي قابل ٿي سگهون ٿا جيڪو اسان ان ڏانهن وڃون ٿا. اهو آهي، انهي ڪري ته اسان کي ڪجهه ڪيسن ۾ هڪ ڪالبڪ منتقل ڪرڻ جو موقعو آهي، ۽ ٻيو ٻين ۾. ۽ اسان جو طريقو، جيڪو اسان جي ڪال بيڪ قبول ڪندو، انهن کي سڏيندو. هڪ سادي مثال ترتيب ڏيڻ آهي. اچو ته چوندا آهيون ته اسان ڪجهه قسم جي مشڪل ترتيب لکندا آهيون جيڪا ڪجهه هن طرح نظر اچي ٿي:

public void mySuperSort() {
    // ... do something here
    if(compare(obj1, obj2) > 0)
    // ... and here we do something
}

جتي، ifاسان طريقي کي سڏين ٿا compare()، اتي ٻه شيون گذريون ٿا جن جو اسان مقابلو ڪريون ٿا، ۽ اسان اهو ڳولڻ چاهيون ٿا ته انهن شين مان ڪهڙي "وڏي" آهي. اسان ان کي رکون ٿا جيڪو "وڌيڪ" آهي ان کان اڳ جيڪو "ننڍو" آهي. مون اقتباس ۾ ”وڌيڪ“ لکيو آهي ڇاڪاڻ ته اسان هڪ آفاقي طريقو لکي رهيا آهيون جيڪو نه صرف ترتيب ڏيڻ جي قابل هوندو پر نزول جي ترتيب ۾ (هن صورت ۾، "وڌيڪ" اهو اعتراض هوندو جيڪو بنيادي طور تي ننڍو هوندو، ۽ ان جي برعڪس) . قاعدو قائم ڪرڻ لاءِ ته جيئن اسان ترتيب ڏيڻ چاهيون ٿا، اسان کي ڪنهن نه ڪنهن طرح ان کي اسان جي mySuperSort(). انهي صورت ۾، اسان ڪنهن به طريقي سان اسان جي طريقي کي "ڪنٽرول" ڪرڻ جي قابل ٿي سگهنداسين جڏهن اهو سڏيو وڃي ٿو. يقينا، توهان ترتيب ڏيڻ mySuperSortAsc()لاء ٻه الڳ طريقا لکي سگهو ٿا mySuperSortDesc()چڙهڻ ۽ هيٺيون ترتيب. يا طريقي جي اندر ڪجھ پيٽرولر پاس ڪريو (مثال طور، booleanجيڪڏھن true, ترتيب ڏيڻ جي ترتيب ۾، ۽ جيڪڏھن falseھيٺئين ترتيب ۾). پر ڇا جيڪڏهن اسان ڪجهه سادو ڍانچي کي ترتيب ڏيڻ چاهيون ٿا، پر مثال طور، اسٽرنگ صفن جي هڪ فهرست؟ اسان جي طريقي کي ڪيئن mySuperSort()معلوم ٿيندو ته انهن اسٽرنگ صفن کي ڪيئن ترتيب ڏيو؟ سائيز تائين؟ لفظن جي مجموعي ڊيگهه سان؟ شايد الفابيٽ جي لحاظ کان، صف ۾ پهرين قطار تي منحصر آهي؟ پر ڇا جيڪڏهن، ڪجهه حالتن ۾، اسان کي صف جي سائيز جي ترتيب سان ترتيب ڏيڻ جي ضرورت آهي، ۽ ٻي صورت ۾، صف ۾ لفظن جي ڪل ڊيگهه جي مطابق؟ منهنجو خيال آهي ته توهان اڳ ۾ ئي comparators جي باري ۾ ٻڌو آهي ۽ اهڙين حالتن ۾ اسان صرف هڪ comparator اعتراض کي اسان جي ترتيب ڏيڻ واري طريقي ڏانهن منتقل ڪريون ٿا، جنهن ۾ اسان انهن قاعدن کي بيان ڪريون ٿا جن سان اسان ترتيب ڏيڻ چاهيون ٿا. جيئن ته معياري طريقو sort()ساڳيو اصول تي لاڳو ڪيو ويو آهي، mySuperSort()مثالن ۾ آئون معياري هڪ استعمال ڪندس sort().

String[] array1 = {"Mother", "soap", "frame"};
String[] array2 = {"I", "Very", "I love", "java"};
String[] array3 = {"world", "work", "May"};

List<String[]> arrays = new ArrayList<>();
arrays.add(array1);
arrays.add(array2);
arrays.add(array3);

Comparator<String[]> sortByLength = new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1.length - o2.length;
    }
};

Comparator<String[]> sortByWordsLength = new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        int length1 = 0;
        int length2 = 0;
        for (String s : o1) {
            length1 += s.length();
        }
        for (String s : o2) {
            length2 += s.length();
        }
        return length1 - length2;
    }
};

arrays.sort(sortByLength);

نتيجو:

1. ماء فريم ڌوئي
2. امن مزدور ٿي سگھي ٿو
3. مان واقعي جاوا سان پيار ڪريان ٿو

هتي هر صف ۾ لفظن جي تعداد جي ترتيب سان ترتيب ڏنل آهن. ٿورن لفظن سان هڪ صف کي "ننڍو" سمجهيو ويندو آهي. انهي ڪري اهو شروع ۾ اچي ٿو. جتي وڌيڪ لفظ آهن، ان کي ”وڌيڪ“ سمجهيو وڃي ٿو ۽ آخر ۾ ختم ٿئي ٿو. جيڪڏهن sort()اسان طريقي سان هڪ ٻيو موازنہ پاس ڪريون ٿا (sortByWordsLength)، پوء نتيجو مختلف ٿيندو:

1. امن مزدور ٿي سگھي ٿو
2. ماء فريم ڌوئي
3. مان واقعي جاوا سان پيار ڪريان ٿو

ھاڻي اھڙن صفن جي لفظن ۾ اکر جي ڪل تعداد جي حساب سان ترتيب ڏنل آھي. پهرين صورت ۾ 10 اکر آهن، ٻئي ۾ 12، ۽ ٽئين ۾ 15. جيڪڏهن اسان صرف هڪ موازنہ استعمال ڪريون ٿا، ته پوءِ اسان ان لاءِ الڳ متغير نه ٿا ٺاهي سگهون، پر صرف هڪ گمنام طبقي جو اعتراض ٺاهيو. طريقو سڏڻ جو وقت sort(). ان جيان:

String[] array1 = {"Mother", "soap", "frame"};
String[] array2 = {"I", "Very", "I love", "java"};
String[] array3 = {"world", "work", "May"};

List<String[]> arrays = new ArrayList<>();
arrays.add(array1);
arrays.add(array2);
arrays.add(array3);

arrays.sort(new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1.length - o2.length;
    }
});

نتيجو ساڳيو ٿيندو جيئن پهرين صورت ۾. ڪم 1 . ھن مثال کي وري لکو ته جيئن اُھي صفن کي ترتيب ڏئي اُنھن جي تعداد جي اڀرندي آرڊر ۾ نه، پر ھيٺئين ترتيب ۾. اسان اڳ ۾ ئي اهو سڀ ڄاڻون ٿا. اسان ڄاڻون ٿا ته شين کي طريقن ڏانهن ڪيئن منتقل ڪيو وڃي، اسان هن يا انهي اعتراض کي هڪ طريقي سان منتقل ڪري سگهون ٿا، ان تي منحصر ڪري ٿو ته اسان کي هن وقت ڪهڙي ضرورت آهي، ۽ طريقي جي اندر جتي اسان اهڙي شئي کي پاس ڪريون ٿا، اهو طريقو جنهن لاء اسان لکيو آهي ان تي عملدرآمد سڏيو ويندو. . سوال پيدا ٿئي ٿو: ليمبڊا اظهار جو ان سان ڇا تعلق آهي؟ ڏنو ويو آهي ته هڪ lambda هڪ اعتراض آهي جنهن ۾ بلڪل هڪ طريقو آهي. اهو هڪ طريقو اعتراض وانگر آهي. ڪنهن شئي ۾ ويڙهيل طريقو. انهن وٽ صرف هڪ ٿورڙو غير معمولي نحو آهي (پر ان کان پوء وڌيڪ). اچو ته هن داخلا تي هڪ ٻيو نظر وجهون

arrays.sort(new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1.length - o2.length;
    }
});

هتي اسان پنهنجي لسٽ کي وٺون ٿا arrays۽ ان جي طريقي کي سڏين ٿا sort()، جتي اسان هڪ واحد طريقي سان هڪ موازنہ اعتراض پاس ڪريون ٿا compare()(اها ڳالهه ناهي ته اسان کي ان کي ڇا سڏيو وڃي، ڇاڪاڻ ته اهو هن اعتراض ۾ صرف هڪ آهي، اسان ان کي ياد نه ڪنداسين). اهو طريقو ٻه پيٽرولر وٺندو آهي، جنهن کي اسين اڳتي هلي ڪم ڪندا آهيون. جيڪڏهن توهان IntelliJ IDEA ۾ ڪم ڪري رهيا آهيو ، توهان شايد ڏٺو هوندو ته اهو توهان کي اهو ڪوڊ پيش ڪري ٿو ته ڪيئن اهم طور تي مختصر ڪرڻ لاءِ:

arrays.sort((o1, o2) -> o1.length - o2.length);

اهڙيءَ طرح ڇهه سٽون هڪ مختصر ۾ بدلجي ويون. 6 سٽون هڪ مختصر هڪ ۾ ٻيهر لکيا ويا. ڪجھ غائب ٿي ويو آهي، پر مان ضمانت ڏيان ٿو ته ڪجھ به اهم غائب نه ٿيو آهي، ۽ اهو ڪوڊ بلڪل ساڳيو ڪم ڪندو جيئن گمنام طبقي سان. ڪم 2 . سمجھو ته ڪيئن لکجي مسئلي جو حل 1 lambdas استعمال ڪندي (آخري ڪوشش جي طور تي، IntelliJ IDEA کان پڇو ته پنھنجي گمنام طبقي کي ليمبڊا ۾ تبديل ڪري).

اچو ته انٽرفيس بابت ڳالهايون

بنيادي طور تي، هڪ انٽرفيس صرف خلاصي طريقن جي هڪ فهرست آهي. جڏهن اسان هڪ ڪلاس ٺاهيندا آهيون ۽ چئون ٿا ته اهو ڪنهن قسم جي انٽرفيس کي لاڳو ڪندو، اسان کي پنهنجي ڪلاس ۾ لکڻ گهرجي انهن طريقن جو هڪ نفاذ جيڪو انٽرفيس ۾ درج ٿيل آهي (يا، آخري حل جي طور تي، ان کي نه لکو، پر ڪلاس کي خلاصو ٺاهيو. ). اتي ڪيترن ئي مختلف طريقن سان انٽرفيس آهن (مثال طور List)، صرف هڪ طريقي سان انٽرفيس آهن (مثال طور، ساڳيو Comparator يا Runnable). انٽرفيس آهن بغير ڪنهن هڪ طريقي جي (نام نهاد مارڪر انٽرفيس، مثال طور سيريلائيبل). اهي انٽرفيس جن ۾ صرف هڪ طريقو آهي، انهن کي فنڪشنل انٽرفيس پڻ سڏيو ويندو آهي . جاوا 8 ۾ اهي پڻ نشان لڳل آهن هڪ خاص @FunctionalInterface تشريح سان . اهو هڪ واحد طريقي سان انٽرفيس آهي جيڪو ليمبڊا اظهار جي استعمال لاءِ موزون آهي. جيئن مون مٿي چيو آهي، هڪ لامبڊا اظهار هڪ طريقو آهي جيڪو هڪ اعتراض ۾ لپي ويو آهي. ۽ جڏهن اسان اهڙي شئي کي ڪنهن جاءِ تي پاس ڪريون ٿا، ته حقيقت ۾، اسان اهو هڪ واحد طريقو پاس ڪريون ٿا. اهو ظاهر ٿئي ٿو ته اهو اسان لاء ڪو مسئلو ناهي ته هي طريقو ڇا سڏيو ويندو آهي. اهو سڀ ڪجهه اسان لاءِ اهم آهي اهي پيرا ميٽرس جيڪي هي طريقو وٺندو آهي، ۽ حقيقت ۾، طريقو ڪوڊ پاڻ. هڪ لامبدا اظهار آهي، بنيادي طور تي. هڪ فنڪشنل انٽرفيس جي نفاذ. جتي اسان هڪ انٽرفيس کي هڪ طريقي سان ڏسون ٿا، ان جو مطلب اهو آهي ته اسان هڪ لامبڊا استعمال ڪندي اهڙي گمنام ڪلاس کي ٻيهر لکي سگهون ٿا. جيڪڏهن انٽرفيس ۾ هڪ کان وڌيڪ/گهٽ طريقو آهي، ته پوءِ لامبڊا جو اظهار اسان لاءِ مناسب نه هوندو، ۽ اسين هڪ گمنام ڪلاس، يا اڃا به هڪ باقاعده استعمال ڪنداسين. اهو وقت لمبڊاس ۾ کڄڻ جو وقت آهي. :)

نحو

عام نحو ڪجهه هن طرح آهي:

(параметры) -> {тело метода}

اهو آهي، قوس، انهن جي اندر طريقن جا پيرا ميٽر آهن، هڪ "تير" (اهي هڪ قطار ۾ ٻه اکر آهن: مائنس ۽ وڏو)، جنهن کان پوء طريقي جي جسم کي گھمڻ واري ڪنگڻ ۾، هميشه وانگر. پيرا ميٽرز انهن سان ملن ٿا جيڪي انٽرفيس ۾ بيان ڪيل آهن جڏهن طريقي کي بيان ڪيو وڃي. جيڪڏهن متغيرن جو قسم واضح طور تي مرتب ڪري سگهجي ٿو (اسان جي صورت ۾، اهو پڪ سان معلوم ٿئي ٿو ته اسان اسٽرنگ جي صفن سان ڪم ڪري رهيا آهيون، ڇاڪاڻ ته اهو Listصحيح طور تي تارن جي صفن سان ٽائيپ ڪيو ويو آهي)، پوء متغير جي قسم جي String[]ضرورت ناهي. لکيو وڃي. توھان وڌيڪ پڙھي سگھوٿا Oracle tutorial ۾ ، مثال طور. ان کي ”ٽارگٽ ٽائپنگ“ چئبو آهي . متغيرن کي ڪي به نالا ڏئي سگھجن ٿا، ضروري نه آهي ته اهي انٽرفيس ۾ بيان ڪيل هجن. جيڪڏهن ڪي به پيرا ميٽر نه آهن، پوء صرف قوسون. جيڪڏهن صرف هڪ پيٽرولر آهي، صرف متغير جو نالو قوس کان سواء. اسان پيرا ميٽرز کي ترتيب ڏنو آھي، ھاڻي پاڻ لامبڊا ايڪسپريس جي جسم بابت. گھڙي گھڙي جي ڪنگڻ جي اندر، ڪوڊ لکو جيئن باقاعده طريقي سان. جيڪڏهن توهان جو سڄو ڪوڊ صرف هڪ لڪير تي مشتمل آهي، توهان کي تمام گھڙيل braces لکڻ جي ضرورت ناهي (جيئن ته ifs ۽ loops سان). جيڪڏهن توهان جو ليمبڊا ڪجهه موٽائي ٿو، پر ان جو جسم هڪ لڪير تي مشتمل آهي، اهو returnلکڻ ضروري ناهي. پر جيڪڏهن توهان وٽ گھمڻ وارا ڪنگڻ آهن، ته پوء، عام طريقي سان، توهان کي واضح طور تي لکڻ جي ضرورت آهي return.

مثال

مثال 1.

() -> {}

آسان ترين اختيار. ۽ سڀ کان وڌيڪ بي معنيٰ:). مثال 2.

() -> ""

پڻ هڪ دلچسپ اختيار. اهو ڪجھ به قبول نه ڪندو آهي ۽ هڪ خالي تار واپس ڪندو آهي ( returnغير ضروري طور تي ختم ٿيل). ساڳيو، پر ان سان return:

() -> {
    return "";
}

مثال 3. هيلو ورلڊ استعمال ڪندي ليمبڊاس

() -> System.out.println("Hello world!")

ڪجھ به حاصل نه ٿو ڪري، ڪجھ به نه موٽائي ٿو (اسان returnڪال کان اڳ نه ٿا رکي سگھون System.out.println()، ڇاڪاڻ ته طريقي ۾ واپسي جو قسم println() — void)، صرف اسڪرين تي لکت ڏيکاري ٿو. انٽرفيس کي لاڳو ڪرڻ لاء مثالي Runnable. ساڳيو مثال وڌيڪ مڪمل آهي:

public class Main {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello world!")).start();
    }
}

يا هن طرح:

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> System.out.println("Hello world!"));
        t.start();
    }
}

يا اسان لامبڊا ايڪسپريس کي به هڪ قسم جي شئي طور محفوظ ڪري سگهون ٿا Runnable، ۽ پوءِ ان کي تعمير ڪندڙ ڏانهن منتقل ڪريون ٿا thread’а:

public class Main {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("Hello world!");
        Thread t = new Thread(runnable);
        t.start();
    }
}

اچو ته هڪ ويجهڙائي تي نظر رکون ٿا هڪ لامبڊا اظهار کي محفوظ ڪرڻ جي لمحن ۾ هڪ متغير ۾. انٽرفيس Runnableاسان کي ٻڌائي ٿو ته ان جي شين جو هڪ طريقو هجڻ گهرجي public void run(). انٽرفيس جي مطابق، رن جو طريقو ڪنهن به شيء کي پيراگراف طور قبول نٿو ڪري. ۽ اهو ڪجهه به واپس نٿو ڪري (void). تنهن ڪري، هن طريقي سان لکڻ دوران، هڪ اعتراض پيدا ڪيو ويندو جيڪو ڪنهن به طريقي سان قبول يا واپس نه ڪندو. run()جيڪو انٽرفيس ۾ طريقي سان ڪافي مطابقت رکي ٿو Runnable. ان ڪري اسان هن لامبڊا ايڪسپريس کي هڪ متغير ۾ رکڻ جي قابل ٿي ويا هئاسين Runnable. مثال 4

() -> 42

ٻيهر، اهو ڪجهه به قبول نٿو ڪري، پر نمبر 42 واپس ڪري ٿو. هي lambda ايڪسپريشن قسم جي متغير ۾ رکي سگهجي ٿو Callable، ڇاڪاڻ ته هي انٽرفيس صرف هڪ طريقو بيان ڪري ٿو، جيڪو ڪجهه هن طرح نظر اچي ٿو:

V call(),

Vواپسي جي قيمت جو قسم ڪٿي آهي (اسان جي صورت ۾ int). ان جي مطابق، اسان هيٺ ڏنل لامبڊا اظهار کي محفوظ ڪري سگهون ٿا:

Callable<Integer> c = () -> 42;

مثال 5. Lambda ڪيترن ئي لائينن ۾

() -> {
    String[] helloWorld = {"Hello", "world!"};
    System.out.println(helloWorld[0]);
    System.out.println(helloWorld[1]);
}

ٻيهر، هي هڪ ليمبڊا اظهار آهي بغير پيٽرولر ۽ ان جي واپسي جو قسم void(جيئن ته ڪو به ناهي return). مثال 6

x -> x

هتي اسان ڪنهن شيءِ کي متغير ۾ وٺي وڃون ٿا х۽ ان کي واپس ڏيون ٿا. مهرباني ڪري نوٽ ڪريو ته جيڪڏهن صرف هڪ پيٽرولر قبول ڪيو وڃي، پوء ان جي چوڌاري قوس لکڻ جي ضرورت ناهي. ساڳيو، پر بریکٹ سان:

(x) -> x

۽ ھتي ھڪڙو اختيار آھي ھڪڙو واضح سان return:

x -> {
    return x;
}

يا هن وانگر، بریکٹ ۽ return:

(x) -> {
    return x;
}

يا قسم جي واضح اشاري سان (۽، مطابق، قوس سان):

(int x) -> x

مثال 7

x -> ++x

اسان ان کي قبول ڪيو х۽ ان کي واپس ڏيو، پر 1وڌيڪ لاء. توھان پڻ ان کي ھن طرح ٻيهر لکي سگھو ٿا:

x -> x + 1

ٻنهي صورتن ۾، اسان پيراميٽر، طريقو جسم، ۽ لفظ جي چوڌاري قوسون ظاهر نه ڪندا آهيون return، ڇاڪاڻ ته اهو ضروري ناهي. بریکٹ ۽ موٽڻ جا اختيار مثال 6 ۾ بيان ڪيا ويا آهن. مثال 8

(x, y) -> x % y

اسان ڪجھ قبول ڪريون ٿا х۽ уباقي حصو واپس ڪريون xٿا y. پيرا ميٽرن جي چوڌاري قوس اڳ ۾ ئي هتي گهربل آهن. اهي صرف اختياري آهن جڏهن صرف هڪ پيٽرولر آهي. هن طرح جي قسمن جي واضح اشارو سان:

(double x, int y) -> x % y

مثال 9

(Cat cat, String name, int age) -> {
    cat.setName(name);
    cat.setAge(age);
}

اسان هڪ ٻلي اعتراض کي قبول ڪندا آهيون، هڪ نالي سان هڪ تار ۽ هڪ عددي عمر. پاڻ طريقي سان، اسان ٻلي کي منظور ٿيل نالو ۽ عمر مقرر ڪيو. catجيئن ته اسان جو متغير هڪ حوالو قسم آهي، ليمبڊا ايڪسپريس کان ٻاهر Cat اعتراض تبديل ٿي ويندو (ان ۾ نالو ۽ عمر گذري ويندي). ٿورڙو وڌيڪ پيچيده نسخو جيڪو ساڳيو لامبڊا استعمال ڪري ٿو:

public class Main {
    public static void main(String[] args) {
        // create a cat and print to the screen to make sure it's "blank"
        Cat myCat = new Cat();
        System.out.println(myCat);

        // create lambda
        Settable<Cat> s = (obj, name, age) -> {
            obj.setName(name);
            obj.setAge(age);
        };

        // call the method, to which we pass the cat and the lambda
        changeEntity(myCat, s);
        // display on the screen and see that the state of the cat has changed (has a name and age)
        System.out.println(myCat);
    }

    private static <T extends WithNameAndAge>  void changeEntity(T entity, Settable<T> s) {
        s.set(entity, "Murzik", 3);
    }
}

interface WithNameAndAge {
    void setName(String name);
    void setAge(int age);
}

interface Settable<C extends WithNameAndAge> {
    void set(C entity, String name, int age);
}

class Cat implements WithNameAndAge {
    private String name;
    private int age;

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

نتيجو: Cat{name='null', age=0} Cat{name='Murzik', age=3} جيئن توهان ڏسي سگهو ٿا، پهرين ته Cat اعتراض جي هڪ حالت هئي، پر lambda ايڪسپريس استعمال ڪرڻ کان پوءِ، حالت بدلجي وئي . Lambda اظهار عام سان سٺو ڪم ڪن ٿا. ۽ جيڪڏھن اسان کي ھڪڙو طبقو ٺاھڻ جي ضرورت آھي Dog، مثال طور، اھو پڻ لاڳو ڪندو WithNameAndAge، پوء طريقي سان main()اسين ساڳيو عمل ڪري سگھون ٿا Dog سان، بغير لامبڊا جي اظهار کي تبديل ڪرڻ کان سواء. ڪم 3 . ھڪڙي فنڪشنل انٽرفيس کي ھڪڙي طريقي سان لکو جيڪو ھڪڙو نمبر وٺي ٿو ۽ ھڪڙو بوليان قدر موٽائي ٿو. لکو اهڙي انٽرفيس جو عمل لامبڊا ايڪسپريشن جي صورت ۾ جيڪو واپس اچي trueته جيڪڏهن پاس ٿيل نمبر 13 سان ورهائجي بغير باقي رهي . ٽاسڪ 4 . ھڪڙي فنڪشنل انٽرفيس کي ھڪڙي طريقي سان لکو جيڪو ٻه اسٽرنگ وٺي ٿو ۽ ساڳي اسٽرنگ کي موٽائي ٿو. لمبڊا جي صورت ۾ اهڙي انٽرفيس جو عمل لکو جيڪو سڀ کان ڊگھي اسٽرنگ واپس ڪري. ڪم 5 . ھڪڙي فنڪشنل انٽرفيس کي ھڪڙي طريقي سان لکو جيڪو قبول ڪري ٿو ٽن جزوي انگن کي: a, b, c۽ واپسي ساڳيو جزوي نمبر. لمبڊا ايڪسپريس جي صورت ۾ هڪ اهڙي انٽرفيس جو عمل لکو جيڪو هڪ تعصب کي واپس ڏئي. ڪير وساريو، D = b^2 - 4ac . ڪم 6 . ٽاسڪ 5 مان فنڪشنل انٽرفيس استعمال ڪندي، هڪ lambda ايڪسپريس لکو جيڪو آپريشن جو نتيجو ڏئي ٿو a * b^c. جاوا ۾ lambda اظهار بابت مشهور. مثالن ۽ ڪمن سان. حصو 2.