जावा 8: java.util.function में कहाँ TriFunction (और परिजन) है? या विकल्प क्या है?

Question

मुझे java.util.function.BiFunction दिखाई देता है, इसलिए मैं यह कर सकता हूं:

BiFunction<Integer, Integer, Integer> f = (x, y) -> { return 0; };

क्या होगा अगर वह पर्याप्त अच्छा नहीं है और मुझे ट्राइफंक्शन की आवश्यकता है? यह मौजूद नहीं है!

TriFunction<Integer, Integer, Integer, Integer> f = (x, y, z) -> { return 0; };

मुझे लगता है कि मुझे यह जोड़ना चाहिए कि मुझे पता है कि मैं अपने ट्राइफंक्शन को परिभाषित कर सकता हूं, मैं मानक पुस्तकालय में इसे शामिल नहीं करने के पीछे तर्क को समझने की कोशिश कर रहा हूं।

Comments

बिफंक्शन इंटरफेस के साथ, आप आसानी से एन-फंक्शन क्लास को परिभाषित कर सकते हैं, यदि आप अलग-अलग इंटरफेस के रूप में ट्राइफंक्शन को परिभाषित करते हैं, तो पहला एसबी पूछेगा कि क्यों नहीं क्वाडफंक्शन, और दूसरा, आपको उन सभी तरीकों को डुप्लिकेट करने की आवश्यकता है जो बिफंक्शन को पैरामीटर के रूप में लेते हैं

— user2383

इस तरह एपीआई के लिए कम रिटर्न की बात है। (व्यक्तिगत रूप से, मुझे लगता है कि JDK8 ने इसे कुछ समय पहले पारित कर दिया था, लेकिन यह इससे भी परे है।)

— लुई वासरमैन

मेरा मानना ​​है कि तर्क यह कहना था कि फंक्शन और बायफ़ंक्शन पूरी तरह से वस्तुओं और देशी प्रकारों के साथ लागू किए गए थे। सभी विविधताओं के साथ TriFunctions को शामिल करना JRE को कक्षाओं और विधियों के साथ उड़ा देगा।

— थोरबजोरन राव एंडरसन

संक्षिप्त जवाब। जावा में, यदि आप इसे नहीं देखते हैं, तो आप अपना स्वयं का निर्माण करते हैं (एलेक्स पी के उत्तर देखें)। सिडेनोट, सी # में, डॉटनेट के कार्यान्वयनकर्ताओं ने आपको पूर्व-डिब्बाबंद वाले (16 तर्क तक) दिए, लेकिन उपसर्ग नामों के बिना ("द्वि" यहाँ): देखें docs.microsoft.com/en-us/dotnet/api/… बस एक सरल "फंक"। तो यह उन जगहों में से एक है जिसे मैं जावा पर डॉटनेट पसंद करता हूं। कृपया इस टिप्पणी अनुभाग को h0ly युद्ध में न बदलें। और केवल BiFunction के लिए टिप्पणियों को सीमित करें।

— ग्रेनडाकोडर 6'19

Answer 1

जहाँ तक मुझे पता है, केवल दो प्रकार के कार्य हैं, विनाशकारी और रचनात्मक।

रचनात्मक कार्य करते समय, जैसा कि नाम का अर्थ है, कुछ का निर्माण करता है, एक विनाशकारी कुछ नष्ट कर देता है, लेकिन उस तरीके से नहीं जैसा आप अब सोच सकते हैं।

उदाहरण के लिए, फ़ंक्शन

Function<Integer,Integer> f = (x,y) -> x + y  

एक रचनात्मक है। जैसा कि आपको कुछ निर्माण करने की आवश्यकता है। उदाहरण में आपने टूपल (x, y) का निर्माण किया । रचनात्मक कार्यों में समस्या है, अनंत तर्कों को संभालने में सक्षम नहीं होने की। लेकिन सबसे बुरी बात यह है कि आप सिर्फ एक तर्क खुला नहीं छोड़ सकते। आप बस "अच्छी तरह से, x: = 1" नहीं कह सकते हैं और हर उस y को आज़मा सकते हैं जिसे आप आज़माना चाहते हैं। आपको हर बार पूरे टपल का निर्माण करना होगा x := 1। तो आप के लिए क्या काम करता है वापसी देखना पसंद करता है, तो y := 1, y := 2, y := 3आपके पास लेखन करने के लिए है f(1,1) , f(1,2) , f(1,3)।

जावा 8 में, रचनात्मक संदर्भों को विधि संदर्भों का उपयोग करके (अधिकतर समय) संभाला जाना चाहिए क्योंकि एक रचनात्मक लंबो फ़ंक्शन का उपयोग करने का बहुत अधिक लाभ नहीं है। वे स्थिर तरीकों की तरह एक सा है। आप उनका उपयोग कर सकते हैं, लेकिन उनके पास कोई वास्तविक स्थिति नहीं है।

दूसरा प्रकार विनाशकारी है, यह कुछ लेता है और आवश्यकतानुसार इसे नष्ट कर देता है। उदाहरण के लिए, विनाशकारी कार्य

Function<Integer, Function<Integer, Integer>> g = x -> (y -> x + y) 

फ़ंक्शन के रूप में वही करता है fजो रचनात्मक था। एक विनाशकारी कार्य के लाभ हैं, आप अब अनंत तर्कों को संभाल सकते हैं, जो धाराओं के लिए विशेष रूप से सुविधाजनक है, और आप सिर्फ तर्कों को खुला छोड़ सकते हैं। अगर तुम्हें फिर से देख क्या परिणाम अगर जैसा होगा चाहते हैं तो x := 1और y := 1 , y := 2 , y := 3, आप कह सकते हैं h = g(1)और h(1)के लिए परिणाम है y := 1, h(2)के लिए y := 2और h(3)के लिए y := 3।

तो यहाँ आप एक निश्चित राज्य है! यह काफी गतिशील है और यह इस समय है कि हम लंबोदर से क्या चाहते हैं।

फैक्ट्री जैसे पैटर्न बहुत आसान हैं यदि आप सिर्फ एक फ़ंक्शन में रख सकते हैं जो आपके लिए काम करता है।

विनाशकारी आसानी से एक दूसरे के साथ संयुक्त होते हैं। यदि प्रकार सही है, तो आप उन्हें अपनी इच्छानुसार बना सकते हैं। इसका उपयोग करके, आप आसानी से आकारिकी को परिभाषित कर सकते हैं जो (अपरिवर्तनीय मूल्यों के साथ) बहुत आसान परीक्षण करता है!

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

तो वहाँ BiFunctionक्यों नहीं है की तुलना में सवाल का अधिक होना चाहिए की आवश्यकता क्यों है TriFunction?

सबसे पहले, आपके पास बहुत समय है बस कुछ मान हैं (3 से कम) और बस एक परिणाम की आवश्यकता है, इसलिए एक सामान्य विनाशकारी फ़ंक्शन की बिल्कुल भी आवश्यकता नहीं होगी, एक रचनात्मक एक ठीक करेगा। और मोनाड्स जैसी चीजें हैं जो वास्तव में एक रचनात्मक कार्य की आवश्यकता है। लेकिन इससे अलग, वहाँ वास्तव में बहुत सारे अच्छे कारण नहीं हैं कि वहाँ बिल्कुल क्यों है BiFunction। इसका मतलब यह नहीं है कि इसे हटा दिया जाना चाहिए! मैं अपने मोनाड्स के लिए तब तक लड़ता हूँ जब तक मैं मर नहीं जाता!

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

Comments

आपने मेरे प्रश्न का उत्तर दिया ... मुझे लगता है ... मुझे नहीं पता कि जावा भाषा डिजाइनर इस विचारधारा से आ रहे हैं, लेकिन मैं कार्यात्मक प्रोग्रामिंग से अच्छी तरह वाकिफ नहीं हूं। विवरण के लिए आपका धन्यवाद।

— रिचर्ड फाइनगन

मैंने आपके द्वारा वर्णित अवधारणाओं को संदर्भित करने के लिए रचनात्मक और विनाशकारी शब्दों का इस्तेमाल कभी नहीं किया है। मुझे लगता है कि करी और नॉन-करी अधिक सामान्य शब्द हैं।

— फ़्यूएर्मुरमेल

पहला फ़ंक्शन उदाहरण वाक्यविन्यास रूप से सही नहीं है। यह BiFunction होना चाहिए, न कि फ़ंक्शन, क्योंकि इसमें दो इनपुट तर्क होते हैं।

— annouk

IMO BiFunctionको आसान डेटा कटौती की अनुमति देने के लिए बनाया गया था, और अधिकांश Streams टर्मिनल ऑपरेशन सिर्फ डेटा में कटौती हैं। एक अच्छा उदाहरण है BinaryOperator<T>, कई में प्रयोग किया जाता है Collectors। एक पहला तत्व दूसरे के साथ कम हो जाता है, फिर अगले एक के साथ कम हो सकता है, और इसी तरह। बेशक, आप एक Function<T, Function<T, T>func = x -> (y -> / * कमी कोड यहाँ * /) बना सकते हैं। परन्तु गंभीरता से? यह सब जब आप बस कर सकते हैं BinaryOperator<T> func = (x, y) -> /*reduction code here*/। साथ ही, यह डेटा कटौती दृष्टिकोण मेरे लिए "विनाशकारी" दृष्टिकोण की तरह लगता है।

— एफबीबी

यह कैसे इतने सारे अपवित्र हो गए? यह एक भयानक और भ्रामक उत्तर है, क्योंकि यह Function<Integer,Integer> f = (x,y) -> x + yवैध जावा पर आधारित है, जो यह नहीं है। इसके साथ शुरू करने के लिए एक BiFunction होना चाहिए!

— wvdz

Answer 2

यदि आपको TriFunction की आवश्यकता है, तो बस यह करें:

@FunctionalInterface
interface TriFunction<A,B,C,R> {

    R apply(A a, B b, C c);

    default <V> TriFunction<A, B, C, V> andThen(
                                Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (A a, B b, C c) -> after.apply(apply(a, b, c));
    }
}

छोटे कार्यक्रम के बाद पता चलता है कि इसका उपयोग कैसे किया जा सकता है। याद रखें कि परिणाम प्रकार अंतिम जेनेरिक प्रकार पैरामीटर के रूप में निर्दिष्ट है।

  public class Main {

    public static void main(String[] args) {
        BiFunction<Integer, Long, String> bi = (x,y) -> ""+x+","+y;
        TriFunction<Boolean, Integer, Long, String> tri = (x,y,z) -> ""+x+","+y+","+z;


        System.out.println(bi.apply(1, 2L)); //1,2
        System.out.println(tri.apply(false, 1, 2L)); //false,1,2

        tri = tri.andThen(s -> "["+s+"]");
        System.out.println(tri.apply(true,2,3L)); //[true,2,3]
    }
  }

मुझे लगता है कि अगर इसमें TriFunction का व्यावहारिक उपयोग होता है java.util.*या java.lang.*इसे परिभाषित किया गया है। मैं 22 तर्कों से आगे कभी नहीं जाऊंगा; हालांकि ;-) मेरा क्या मतलब है, सभी नए कोड जो संग्रह को स्ट्रीम करने की अनुमति देते हैं उन्हें किसी भी तरीके के मापदंडों के रूप में ट्राइफंक्शन की आवश्यकता नहीं होती है। इसलिए इसे शामिल नहीं किया गया था।

अपडेट करें

पूर्णता के लिए और विनाशकारी कार्यों के स्पष्टीकरण का अनुसरण करने के लिए एक अन्य उत्तर में (करी से संबंधित), यहां बताया गया है कि अतिरिक्त इंटरफ़ेस के बिना TriFunction का अनुकरण कैसे किया जा सकता है:

Function<Integer, Function<Integer, UnaryOperator<Integer>>> tri1 = a -> b -> c -> a + b + c;
System.out.println(tri1.apply(1).apply(2).apply(3)); //prints 6

बेशक, अन्य तरीकों से कार्यों को संयोजित करना संभव है, जैसे:

BiFunction<Integer, Integer, UnaryOperator<Integer>> tri2 = (a, b) -> c -> a + b + c;
System.out.println(tri2.apply(1, 2).apply(3)); //prints 6
//partial function can be, of course, extracted this way
UnaryOperator partial = tri2.apply(1,2); //this is partial, eq to c -> 1 + 2 + c;
System.out.println(partial.apply(4)); //prints 7
System.out.println(partial.apply(5)); //prints 8

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

Comments

समाधान के लिए धन्यवाद। और हाँ, BiFunction, TriFunction के लिए निश्चित रूप से उपयोग किया जाता है, ... अन्यथा लोग इसके लिए खोज नहीं करेंगे। यह अनुमान लगाता है कि पूरी लैम्बडा बात अभी ओरेकल के लिए बहुत नई है और बाद के जावा संस्करणों में विस्तारित की जाएगी। फिलहाल यह अवधारणा का अधिक प्रमाण है।

— स्टेफन एंडरुल्लिस

Hy @ एलेक्स आप निम्नलिखित लाइन को परिभाषित कर सकते हैं। यहाँ क्या हो रहा है डिफ़ॉल्ट <V> TriFunction <A, B, C, V> और फिर (फ़ंक्शन <; सुपर R;; V का विस्तार) के बाद {Objects.requireNonNull (after); वापसी (A a, B b, C c) -> after.apply (लागू करें (a, b, c)); }

— मुनीब नासिर

@MeeeebNasir - यह आपको फंक्शन कंपोज़ीशन करने की अनुमति देता है: TriFunction<Integer,Integer,Integer,Integer> comp = (x,y,z) -> x + y + z; comp = comp.andThen(s -> s * 2); int result = comp.apply(1, 2, 3); //12देखें stackoverflow.com/questions/19834611/…

— एलेक्स पाका

andThen()उत्तर में उपयोग उदाहरण जोड़ा गया ।

— एलेक्स पक्का

न केवल करीना जावा भाषा के लिए अच्छी तरह से अनुकूलित नहीं है, बल्कि यह भी है कि अगर मैं गलत हूं, तो मुझे सही करें, लेकिन डेटा में कमी करने के लिए एपीआई BiFunctionमें उपयोग किया जाता है Stream, जो मेरे लिए करी दृष्टिकोण की तरह दिखता है: आप कभी भी दो से अधिक नहीं लेते हैं तर्क, और आप किसी भी संख्या में तत्वों को संसाधित कर सकते हैं, एक बार में एक कमी (स्वीकृत उत्तर पर मेरी टिप्पणी देखें, मुझे यह जानकर खुशी होगी कि क्या मैं इस तरह से देखना गलत हूं)।

— एफबीबी

Answer 3

वैकल्पिक है, नीचे निर्भरता जोड़ें,

<dependency>
    <groupId>io.vavr</groupId>
    <artifactId>vavr</artifactId>
    <version>0.9.0</version>
</dependency>

अब, आप 8 तर्कों के नीचे, जैसे Vavr फंक्शन का उपयोग कर सकते हैं,

3 तर्क:

Function3<Integer, Integer, Integer, Integer> f = 
      (a, b, c) -> a + b + c;

5 तर्क:

Function5<Integer, Integer, Integer, Integer, Integer, Integer> f = 
      (a, b, c, d, e) -> a + b + c + d + e;

Comments

मैं vavr का उल्लेख करने के लिए अपने उत्तर को अपडेट करने वाला था, लेकिन आप पहले थे, इसलिए मैंने अपवोट किया। यदि आप उस बिंदु पर पहुँचते हैं जिसे आपको एक ट्राइफंक्शन की आवश्यकता होती है, तो एक बड़ा मौका है कि आप vavrलाइब्रेरी का उपयोग करके बेहतर होंगे - यह जावा में कार्यात्मक शैली प्रोग्रामिंग को संभव बनाता है।

— एलेक्स पक्का

Answer 4

मेरे पास लगभग एक ही प्रश्न और एक आंशिक उत्तर है। यह सुनिश्चित नहीं है कि रचनात्मक / डिकंस्ट्रक्टिव उत्तर क्या भाषा डिजाइनरों के दिमाग में था। मुझे लगता है कि 3 और उससे अधिक N के पास वैध उपयोग के मामले हैं।

मैं .NET से आता हूँ। और .NET में आपके पास शून्य फ़ंक्शन के लिए फंक और एक्शन है। विधेय और कुछ अन्य विशेष मामले भी मौजूद हैं। देखें: https://msdn.microsoft.com/en-us/library/bb534960(v=vs.110).aspx

मुझे आश्चर्य है कि क्या कारण था कि भाषा डिजाइनरों ने फंक्शन, बिफंक्शन के लिए चुना और DecaExiFunction तक जारी नहीं किया?

दूसरे भाग का उत्तर टाइप इरेज़र है। संकलन के बाद फंक और फंक के बीच कोई अंतर नहीं है। निम्नलिखित इसलिए संकलन नहीं है:

package eu.hanskruse.trackhacks.joepie;

public class Functions{

    @FunctionalInterface
    public interface Func<T1,T2,T3,R>{
        public R apply(T1 t1,T2 t2,T3 t3);
    }

    @FunctionalInterface
    public interface Func<T1,T2,T3,T4,R>{
        public R apply(T1 t1,T2 t2,T3 t3, T4 t4);
    }
}

एक और मामूली समस्या को दरकिनार करने के लिए आंतरिक कार्यों का उपयोग किया गया। ग्रहण ने एक ही निर्देशिका में फ़ंक्शन नाम की फ़ाइलों में दोनों वर्गों के होने पर जोर दिया ... निश्चित नहीं कि यह आजकल एक संकलक मुद्दा है। लेकिन मैं ग्रहण में त्रुटि को चालू नहीं कर सकता।

फन का इस्तेमाल जावा फंक्शन टाइप के साथ नाम की गड़बड़ी को रोकने के लिए किया गया था।

इसलिए यदि आप 16 तर्क में 3 से Func जोड़ना चाहते हैं तो आप दो काम कर सकते हैं।

• बनाओ TriFunc, TesseraFunc, PendeFunc, ... DecaExiFunc आदि
  • (मुझे ग्रीक या लैटिन का उपयोग करना चाहिए?)
• नामों को अलग बनाने के लिए पैकेज नामों या कक्षाओं का उपयोग करें।

दूसरे तरीके के लिए उदाहरण:

 package eu.hanskruse.trackhacks.joepie.functions.tri;

        @FunctionalInterface
        public interface Func<T1,T2,T3,R>{
            public R apply(T1 t1,T2 t2,T3 t3);
        }

तथा

package eu.trackhacks.joepie.functions.tessera;

    @FunctionalInterface
    public interface Func<T1,T2,T3,T4,R>{
        public R apply(T1 t1,T2 t2,T3 t3, T4 t4);
    }

सबसे अच्छा तरीका क्या होगा?

उपरोक्त उदाहरणों में मैंने (और) और रचना () विधियों के लिए कार्यान्वयन को शामिल नहीं किया। यदि आप इन्हें जोड़ते हैं तो आपको प्रत्येक में 16 अधिभार जोड़ना चाहिए: TriFunc में 16 तर्कों के साथ एक () होना चाहिए। यह आपको परिपत्र निर्भरता के कारण एक जटिल त्रुटि देगा। इसके अलावा, आप फ़ंक्शन और BiFunction के लिए इन अधिभार नहीं होगा। इसलिए आपको फंक को एक तर्क के साथ और फंक को दो तर्कों के साथ परिभाषित करना चाहिए। .NET सर्कुलर निर्भरताओं में विस्तार विधियों का उपयोग करके किया जाएगा जो जावा में मौजूद नहीं हैं।

Comments

आपको andThen16 तर्कों की आवश्यकता क्यों होगी ? जावा में एक फ़ंक्शन का परिणाम एक एकल मूल्य है। andThenयह मान लेता है और इसके साथ कुछ करता है। इसके अलावा, नामकरण के साथ कोई समस्या नहीं है। फ़ंक्शन और BiFunction के साथ जावा भाषा डेवलपर्स द्वारा निर्धारित तर्क का पालन करते हुए, क्लास के नाम अलग-अलग होने चाहिए और एक ही नाम वाली अलग-अलग फाइलों में होने चाहिए। यदि तर्क प्रकार भिन्न हैं, तो भी, इन सभी विभिन्न नामों की आवश्यकता है एक VargFunction(T, R) { R apply(T.. t) ... }एकल प्रकार के लिए बना सकते हैं ।

— एलेक्स पक्का

Answer 5

मुझे यहाँ BiFunction का सोर्स कोड मिला:

https://github.com/JetBrains/jdk8u_jdk/blob/master/src/share/classes/java/util/function/BiFunction.java

मैंने इसे TriFunction बनाने के लिए संशोधित किया। BiFunction की तरह, यह andThen () और नहीं रचना () का उपयोग करता है, इसलिए कुछ अनुप्रयोगों के लिए जिन्हें कंपोज़ () की आवश्यकता होती है, यह उचित नहीं हो सकता है। यह सामान्य प्रकार की वस्तुओं के लिए ठीक होना चाहिए। पर एक अच्छा लेख (तब और) और रचना () यहाँ पाया जा सकता है:

http://www.deadcoderising.com/2015-09-07-java-8-functional-composition-using-compose-and-andthen/

import java.util.Objects;
import java.util.function.Function;

/**
 * Represents a function that accepts two arguments and produces a result.
 * This is the three-arity specialization of {@link Function}.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #apply(Object, Object)}.
 *
 * @param <S> the type of the first argument to the function
 * @param <T> the type of the second argument to the function
 * @param <U> the type of the third argument to the function
 * @param <R> the type of the result of the function
 *
 * @see Function
 * @since 1.8
 */
@FunctionalInterface
public interface TriFunction<S, T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param s the first function argument
     * @param t the second function argument
     * @param u the third function argument
     * @return the function result
     */
    R apply(S s, T t, U u);

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     */
    default <V> TriFunction<S, T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (S s, T t, U u) -> after.apply(apply(s, t, u));
    }
}

Answer 6

आप 3 पैरामीटर लेते हुए अपना स्वयं का फ़ंक्शन भी बना सकते हैं

@FunctionalInterface
public interface MiddleInterface<F,T,V>{
    boolean isBetween(F from, T to, V middleValue);
}

MiddleInterface<Integer, Integer, Integer> middleInterface = 
(x,y,z) -> x>=y && y<=z; // true

Answer 7

आप हमेशा TriFunction पर नहीं रुक सकते। कभी-कभी, आपको अपने कार्यों के लिए कई मापदंडों को पास करना पड़ सकता है। तब आपके कोड को ठीक करने के लिए सपोर्ट टीम को एक क्वाडफ़ंक्शन बनाना होगा। दीर्घकालिक समाधान अतिरिक्त मापदंडों के साथ एक ऑब्जेक्ट बनाने और फिर तैयार किए गए फ़ंक्शन या BiFunction का उपयोग करना होगा।