جاوا 8. سڀ ڪجھ توھان جي ضرورت آھي

جاوا 8 سبق

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

جاوا 8 جي منهنجي تعارف ۾ ڀليڪار. هي آرٽيڪل توهان کي جاوا 7 کان جاوا 8 تائين سڀني نئين خاصيتن جي ذريعي قدم قدم تي وٺي ويندو. تڪڙي ۽ سادي ڪوڊ جي مثالن سان، اسان سکي سگهون ٿا ته ڪيئن استعمال ڪجي ڊفالٽ انٽرفيس، ميٿڊ ريفرنس ، ۽ ورجائي سگهندڙ تشريحون . آرٽيڪل جي آخر ۾ اسين واقف ٿينداسين اسٽريم API سان. ڪابه غير ضروري چيٽ نه - صرف ڪوڊ ۽ تبصرا! اڳتي!

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

جاوا 8 اسان کي غير تجريدي طريقا شامل ڪرڻ جي اجازت ڏئي ٿو (جيڪي لاڳو ٿيل آهن) انٽرفيس ۾ شامل ڪندي default. ھن خصوصيت کي Extention Methods طور سڃاتو وڃي ٿو . هيٺيون پهريون مثال آهي:

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

تجريدي طريقي سان گڏوگڏ calculate، انٽرفيس Formulaپڻ ڊفالٽ طريقو بيان ڪري ٿو sqrt. ڪلاس جيڪي هن انٽرفيس کي لاڳو ڪن ٿا صرف ان کي لاڳو ڪرڻ جي ضرورت آهي calculate. ڊفالٽ طريقو 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

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

Lambda اظهار

اچو ته جاوا جي پوئين ورزن ۾ تارن جي لسٽ کي ترتيب ڏيڻ جي هڪ سادي مثال سان شروع ڪريون:

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

جامد طريقو Collections.sortهڪ فهرست قبول ڪري ٿو ۽ هڪ تقابلي ترتيب ۾ جنهن ۾ لسٽ کي ترتيب ڏيڻو آهي. توهان هميشه هڪ گمنام موازنہ ڪلاس ٺاهي سگهو ٿا ۽ ان سان گڏ پاس ڪريو. هڪ گمنام ڪلاس ٺاهڻ جي بدران، جاوا 8 ۾ توهان هڪ ننڍو فارم لکي سگهو ٿا، هڪ لامبڊا اظهار.

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

جئين توهان ڏسي سگهو ٿا ڪوڊ تمام ننڍو ۽ پڙهڻ ۾ آسان آهي. پر اهو به ننڍو ڪري سگهجي ٿو:

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

ھڪڙي لڪير سان ھڪڙي جسم لاء، توھان {}لفظ کي ڇڏي سگھو ٿا return. پر توھان ان کي اڃا ننڍو ڪري سگھو ٿا:

Collections.sort(names, (a, b) -> b.compareTo(a));

جاوا گڏ ڪرڻ وارو ڄاڻندڙ دليلن جي قسمن بابت، تنهنڪري توهان انهن کي پڻ ڇڏي سگهو ٿا. اچو ته لامبڊا جي اظهارن ۾ تمام گهڻي کوٽائي ڪريون ۽ سمجھون ته انهن کي ڪيئن استعمال ڪري سگهجي ٿو.

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

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

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

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

ذهن ۾ رکو ته ڪوڊ پڻ مرتب ڪيو ويندو جيڪڏهن @FunctionalInterfaceتشريح کي ختم ڪيو وڃي.

طريقه ۽ تعمير ڪندڙ حوالا

مٿي ڏنل مثال کي طريقو حوالن کي استعمال ڪندي اڃا به ننڍو ڪري سگهجي ٿو:

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

جاوا 8 توهان کي اجازت ڏئي ٿو ته حوالن کي هڪ طريقو يا تعمير ڪندڙ شامل ڪندي ::. مٿي ڏنل مثال ڏيکاري ٿو ته اسان هڪ جامد طريقو ڪيئن حوالو ڪري سگهون ٿا، جيتوڻيڪ اسين غير جامد طريقن جو حوالو پڻ ڪري سگهون ٿا:

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

Something something = new Something();
Converter<String, String> 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 extends Person> {
    P create(String firstName, String lastName);
}

تخليق ڪارخاني کي لاڳو ڪرڻ جي بدران، اسان اهو سڀ گڏجي تعمير ڪندڙ جي مدد سان ڳنڍينداسين :::

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

اسان ٺاھيندڙ جي ذريعي ھڪڙي لنڪ ٺاھيو Person::new. جاوا ڪمپلر خودڪار طريقي سان صحيح ٺاھيندڙ کي منتخب ڪندو جيڪو طريقي جي دستخط سان ملندو PersonFactory.create. ... جاري رکڻ گهرجي. بدقسمتي سان، مون کي آرٽيڪل جي مسودي کي محفوظ ڪرڻ جو ڪو طريقو نه مليو، ۽ اهو واقعي عجيب آهي، ۽ ترجمي جو وقت ختم ٿي چڪو آهي - تنهنڪري مان ان کي بعد ۾ ختم ڪندس. هر ڪنهن لاءِ جيڪو ڄاڻي ٿو ۽ سمجهي ٿو انگريزي - اصل آرٽيڪل . جيڪڏهن توهان وٽ ترجمي کي درست ڪرڻ لاءِ تجويزون آهن، ته توهان وٽ موجود ڪنهن به طريقي سان لکو. منهنجو Github اڪائونٽ