லாம்ப்டா வெளிப்பாடுகள்

Java 8 இலிருந்து தொடங்கி, செயல்பாட்டு நிரலாக்கமானது Lambda Expressions வழியாக ஆதரிக்கப்படுகிறது. ஒரு லாம்ப்டா வெளிப்பாடு அடிப்படையில் ஒரு அநாமதேய முறையாகும் (பெயர் இல்லாத ஒரு செயல்பாடு) இது முறைகளுக்கு ஒரு வாதமாக அனுப்பப்படலாம் அல்லது மாறிகளில் சேமிக்கப்படும்.

செயல்பாட்டு இடைமுகங்கள்

செயல்பாட்டு இடைமுகம் தேவைப்படும் இடத்தில் மட்டுமே லாம்ப்டா வெளிப்பாடு பயன்படுத்தப்படும். செயல்பாட்டு இடைமுகம் என்பது சரியாக ஒரு சுருக்க முறையை அறிவிக்கும் ஒரு இடைமுகமாகும். Java இந்த இடைமுகங்களை விருப்பமான @FunctionalInterface சிறுகுறிப்புடன் குறிக்கிறது.

பயனர் வரையறுக்கப்பட்ட செயல்பாட்டு இடைமுகத்தின் எடுத்துக்காட்டு:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

ஜாவா 8 க்கு முன், நீங்கள் ஒரு அநாமதேய உள் வகுப்பை வரையறுக்க வேண்டும். லாம்ப்டாஸ் மூலம், தொடரியல் எளிமைப்படுத்தப்பட்டுள்ளது:

MathOperation addition = (a, b) -> a + b;
int result = addition.operate(5, 3); // Returns 8

லாம்ப்டா வெளிப்பாடுகளின் அமைப்பு

லாம்ப்டாவின் அடிப்படை தொடரியல்:

(parameters) -> { body }

• அளவுருக்கள் இல்லாமல்: () -> System.out.println("Hello")
• ஒற்றை அளவுரு: x -> x * 2 (அடைப்புக்குறிகளைத் தவிர்க்கலாம்)
• பல அளவுருக்கள்: (x, y) -> x + y
• மல்டி-லைன் பாடி: உடலில் பல அறிக்கைகள் இருந்தால், பிரேஸ்கள் {} மற்றும் வெளிப்படையான return அறிக்கை தேவை.

MathOperation detailedAddition = (a, b) -> {
    System.out.println("Adding...");
    return a + b;
};

ஜாவாவில் நிலையான செயல்பாட்டு இடைமுகங்கள்

java.util.function தொகுப்பு பல உள்ளமைக்கப்பட்ட செயல்பாட்டு இடைமுகங்களை வழங்குகிறது:

• Predicate<T>: T வகை வாதத்தை ஏற்றுக்கொண்டு, பூலியன் (test(T t) முறை) ஐ வழங்குகிறது.
• Consumer<T>: T வகையின் வாதத்தை ஏற்றுக்கொண்டு, முடிவைத் தராமல் ஒரு செயல்பாட்டைச் செய்கிறது (accept(T t) முறை).
• Function<T, R>: ஒரு வாதத்தை ஏற்று T முடிவை வழங்குகிறது R (apply(T t) முறை).
• Supplier<T>: எந்த வாதங்களையும் ஏற்காது மற்றும் T வகையின் மதிப்பை வழங்கும் (get() முறை).

நீங்களே முயற்சி செய்து பாருங்கள்