জাভা 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

দ্বিখণ্ডিত ইন্টারফেস সহ, আপনি সহজেই এন-ফাংশন শ্রেণিটি সংজ্ঞায়িত করতে পারেন, আপনি যদি পৃথক ইন্টারফেস হিসাবে ট্রাইফংশনটি সংজ্ঞায়িত করেন, প্রথমে এসবি জিজ্ঞাসা করবে কেন চতুর্ভুজ নয়, এবং দ্বিতীয়টি, আপনাকে বিভাজনকে প্যারামিটার হিসাবে গ্রহণ করার সমস্ত পদ্ধতি নকল করতে হবে

— user902383

এটির মতো এপিআইয়ের রিটার্ন হ্রাস করার একটি বিন্দু রয়েছে। (ব্যক্তিগতভাবে, আমি মনে করি জেডিকে 8 এটিকে কিছুক্ষণ আগে পাস করেছে, তবে এটি এর বাইরেও))

— লুই ওয়াসারম্যান

আমি বিশ্বাস করি যুক্তিটি হ'ল ফাংশন এবং বায়ু ফাংশনটি বস্তু এবং নেটিভ প্রকারের সাথে পুরোপুরি প্রয়োগ করা হয়েছিল। সমস্ত বিভিন্ন প্রকারের সাথে ট্রিফিউশনগুলি অন্তর্ভুক্ত করা ক্লাস এবং পদ্ধতিগুলির সাথে জেআরইকে ফুটিয়ে তুলবে।

— থরবজর্ন রাভন অ্যান্ডারসন

সংক্ষিপ্ত উত্তর. জাভাতে, আপনি যদি এটি না দেখেন তবে আপনি নিজের তৈরি করেন (অবশ্যই অ্যালেক্স পি উত্তর দেখুন)। সিডনোট, সি # তে ডটনেট প্রয়োগকারীরা আপনাকে প্রাক-ক্যানডগুলি দিয়েছেন (16 টি যুক্তি অবধি), তবে উপসর্গের নামগুলি ছাড়াই ("দ্বি" এখানে) রয়েছে: ডকস.মাইক্রোসফটকম /en-us/dotnet/api /… দেখুন কেবল একটি সাধারণ "ফানক"। সুতরাং এটি আমি জাভা এর চেয়ে ডটনেটকে পছন্দ করি of দয়া করে এই মন্তব্য বিভাগটিকে h0ly যুদ্ধে পরিণত করবেন না। এবং মন্তব্যগুলিকে কেবল বায়ফুনশনে সীমাবদ্ধ করুন।

— গ্রানাডা কোডার

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তৈরি করা হয়েছিল সহজে ডেটা হ্রাস করার অনুমতি দেওয়ার জন্য এবং বেশিরভাগ Streamটার্মিনাল অপারেশনগুলি কেবল ডেটা হ্রাস। একটি ভাল উদাহরণ BinaryOperator<T>, অনেক ক্ষেত্রে ব্যবহৃত হয় Collectors। প্রথম উপাদানটি দ্বিতীয়টির সাথে হ্রাস করা হয়, তারপরে পরবর্তী একের সাথে হ্রাস করা যায়, ইত্যাদি। অবশ্যই, আপনি একটি Function<T, Function<T, T>ফানক = এক্স -> (y -> / * হ্রাস কোড এখানে * /) তৈরি করতে পারেন। কিন্তু গুরুতরভাবে? এই সব যখন আপনি সহজভাবে করতে পারেন BinaryOperator<T> func = (x, y) -> /*reduction code here*/। অধিকন্তু, এই ডেটা হ্রাস পদ্ধতির কাছে আমার কাছে আপনার "ধ্বংসাত্মক" পদ্ধতির মতো অনেকটা মনে হচ্ছে।

— এফবিবি

এটি এত উপার্জন কিভাবে পেল? এটি একটি ভয়ানক এবং বিভ্রান্তিকর উত্তর, কারণ এটি Function<Integer,Integer> f = (x,y) -> x + yবৈধ জাভা ভিত্তির উপর ভিত্তি করে , যা এটি নয়। এটি দিয়ে শুরু করতে হবে একটি দ্বি ফাংশন!

— wvdz

Answer 2

আপনার যদি ট্রাইফঙ্কশনের প্রয়োজন হয় তবে কেবল এটি করুন:

@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]
    }
  }

আমার ধারণা, ট্রাইফানশনের ক্ষেত্রে যদি ব্যবহারিক ব্যবহার হয় java.util.*বা java.lang.*এটি সংজ্ঞায়িত হত। আমি কখনই ২২ টি আর্গুমেন্টের বাইরে যাব না, যদিও ;-) আমি এর অর্থ কী, সমস্ত নতুন কোড যা সংগ্রহগুলি স্ট্রিম করতে দেয় তা কখনই কোনও পদ্ধতির পরামিতি হিসাবে ট্রাইফংশন প্রয়োজন হয় না। সুতরাং এটি অন্তর্ভুক্ত করা হয়নি।

হালনাগাদ

সম্পূর্ণরূপে এবং অন্য উত্তরে (তরকারী সম্পর্কিত) বিপর্যয়কর ফাংশনগুলির ব্যাখ্যা অনুসরণ করার জন্য, এখানে ট্রাইফংশন কীভাবে অতিরিক্ত ইন্টারফেস ছাড়াই অনুকরণ করা যায়:

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

সমাধানের জন্য ধন্যবাদ। এবং হ্যাঁ, বায়ু ফাংশন, ট্রাই ফাংশন, অবশ্যই ব্যবহার রয়েছে ... অন্যথায় লোকেরা এটি অনুসন্ধান করবে না। এটি অনুমান করে যে পুরো ল্যাম্বডা জিনিসটি এখনই ওরাকলের জন্য খুব নতুন এবং পরবর্তী জাভা সংস্করণগুলিতে প্রসারিত হবে। এই মুহূর্তে এটি ধারণার আরও প্রমাণ proof

— স্টিফান এন্ড্রুলিস

হাই @ অ্যালেক্স আপনি নীচের লাইনটি সংজ্ঞায়িত করতে পারেন? এখানে কি ঘটছে ডিফল্ট <ভি> ট্রাই ফাংশন <এ, বি, সি, ভি> এবং তারপরে (ফাংশন <? সুপার আর,? ভি> পরে প্রসারিত) {অবজেক্টস.অরকিয়ারননল (পরে); রিটার্ন (এ এ, বি বি, সি সি) -> আফটার অ্যাপ্লিকেশন (প্রয়োগ করুন (ক, খ, সি)); ।

— মুনিব নাসির

@ মুনিব নাসির - এটি আপনাকে ফাংশন কম্পোজিশন করতে দেয়: স্ট্যাকওভারফ্লো দেখুন / প্রশ্নগুলি 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দেখুন / ১৯৮৪346১১/২

— অ্যালেক্স পাকা

যোগ করা হয়েছে andThen()উত্তর এ ব্যবহার উদাহরণ।

— অ্যালেক্স পাক্কা

জাভা ভাষার সাথে কেবল কারিরিং ভালভাবে খাপ খায় না, তবে আমি ভুল হলে আমাকে সংশোধনও করি, তবে ডেটা হ্রাস করতে এপিআইতে BiFunctionব্যবহৃত হয় Stream, যা আমার কাছে কারিঙ পদ্ধতির মতো দেখতে অনেকটা লাগে: আপনি কখনই দু'জনের বেশি গ্রহণ করবেন না যুক্তিগুলি, এবং আপনি বহু সংখ্যক উপাদান, একসাথে একটি হ্রাস প্রক্রিয়া করতে পারেন (গৃহীত উত্তরের বিষয়ে আমার মন্তব্য দেখুন, আমি যদি সেভাবে দেখতে ভুল করি তবে আমি খুশি হব)।

— এফবিবি

Answer 3

বিকল্পটি হ'ল, নীচের নির্ভরতা যুক্ত করুন,

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

এখন, আপনি 8 টি আর্গুমেন্ট পর্যন্ত নীচে যেমন ভ্যাভ ফাংশন ব্যবহার করতে পারেন,

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লাইব্রেরি ব্যবহার করে আপনি আরও ভাল হবেন এমন একটি বড় সম্ভাবনা রয়েছে - এটি জাভাতে যতটা সম্ভব কার্যক্ষম স্টাইল প্রোগ্রামিংকে বহনযোগ্য করে তোলে।

— অ্যালেক্স পাক্কা

Answer 4

আমার প্রায় একই প্রশ্ন এবং একটি আংশিক উত্তর আছে। গঠনমূলক / ডিকনস্ট্রাকটিভ উত্তরটি ভাষা ডিজাইনারদের মনে কী ছিল তা নিশ্চিত নয়। আমি মনে করি এন পর্যন্ত 3 এবং আরও বেশি থাকার বৈধ ব্যবহারের কেস রয়েছে।

আমি নেট থেকে এসেছি। এবং .NET এ আপনার অকার্যকর ফাংশনের জন্য ফানক এবং অ্যাকশন রয়েছে। ভবিষ্যদ্বাণী এবং আরও কিছু বিশেষ মামলার উপস্থিতি রয়েছে। দেখুন: https://msdn.microsoft.com/en-us/library/bb534960(vvv.1.110).aspx

আমি আশ্চর্য হয়েছি যে এর কারণ কী ছিল যে ভাষা ডিজাইনাররা ফাংশন, বিফংশনকে বেছে নিয়েছিল এবং ডেকএএকসি ফাংশন অবধি চালিয়ে যাননি?

দ্বিতীয় অংশের উত্তরটি টাইপ ইরেজোর। সংকলনের পরে ফানক এবং ফুনকের মধ্যে কোনও পার্থক্য নেই। নিম্নলিখিতগুলি তাই সংকলন করে না:

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);
    }
}

অভ্যন্তরীণ ফাংশনগুলি অন্য একটি ছোটখাটো সমস্যা সমাধানের জন্য ব্যবহৃত হত। গ্রহনটি একই ডিরেক্টরিতে ফাংশন নামের ফাইলগুলিতে উভয় শ্রেণীর থাকার জন্য জোর দিয়েছিল ... আজকাল এটি কোনও সংকলক সমস্যা কিনা তা নিশ্চিত নয়। তবে আমি গ্রহণের ত্রুটিটি ঘুরিয়ে দিতে পারি না।

জাভা ফাংশন ধরণের সাথে নাম সংঘর্ষ রোধ করতে ফানক ব্যবহার করা হয়েছিল।

সুতরাং আপনি যদি 3 টি থেকে 16 টি যুক্তি পর্যন্ত ফানক যুক্ত করতে চান তবে আপনি দুটি জিনিস করতে পারেন।

• ট্রাইফ্যাঙ্ক, টেসেরাফঙ্ক, পেনডেফঙ্ক, ... ডেকাএক্সিফঙ্ক ইত্যাদি তৈরি করুন
  • (আমার গ্রীক না লাতিন ব্যবহার করা উচিত?)
• নাম আলাদা করতে প্যাকেজের নাম বা ক্লাস ব্যবহার করুন।

দ্বিতীয় উপায়ের জন্য উদাহরণ:

 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);
    }

সেরা পদ্ধতির কি হবে?

উপরের উদাহরণগুলিতে আমি andThen () এবং রচনা () পদ্ধতিগুলির জন্য প্রয়োগগুলি অন্তর্ভুক্ত করি নি। আপনি যদি এগুলি যুক্ত করেন তবে আপনাকে অবশ্যই প্রতিটি 16 টি ওভারলোড যুক্ত করতে হবে: ট্রাইফ্যাঙ্কের 16 টি যুক্তি সহ একটি অ্যান্ডিথেন () থাকা উচিত। বিজ্ঞপ্তি নির্ভরতার কারণে এটি আপনাকে একটি সংকলন ত্রুটি দেয়। এছাড়াও ফাংশন এবং বায়ু ফাংশনের জন্য আপনার এই ওভারলোডগুলি নেই। সুতরাং আপনার একটি যুক্তি দিয়ে ফানক এবং দুটি যুক্তি সহ ফানককে সংজ্ঞায়িত করা উচিত। .NET বিজ্ঞপ্তি নির্ভরতাগুলি জাভাতে উপস্থিত নয় এমন এক্সটেনশন পদ্ধতিগুলি ব্যবহার করে নিষ্ক্রিয় করা হবে।

Comments

আপনার andThen16 টি যুক্তি দিয়ে কেন দরকার হবে ? জাভাতে কোনও ফাংশনের ফলাফল একটি একক মান। andThenএই মানটি নেয় এবং এটি দিয়ে কিছু করে। এছাড়াও, নামকরণে কোনও সমস্যা নেই। ফাংশন এবং বায়ু ফাংশন সহ জাভা ভাষার বিকাশকারীদের দ্বারা যুক্তিযুক্ত সেটটি অনুসরণ করে - শ্রেণীর নামগুলি আলাদা আলাদা হওয়া উচিত এবং একই নাম অনুসারে পৃথক ফাইলে থাকা উচিত। এছাড়াও, এই সমস্ত ভিন্ন নামের প্রয়োজন যদি যুক্তির ধরণগুলি পৃথক হয়। 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

আমি ট্রাইফিউশন তৈরি করতে এটি সংশোধন করেছি। বায়ু ফাংশন এর মতো, এটি এবং (এবং) রচনাগুলি () ব্যবহার করে না, তাই কিছু অ্যাপ্লিকেশনগুলির জন্য যা রচনা () প্রয়োজন, এটি উপযুক্ত নাও হতে পারে। এটি সাধারণ ধরণের অবজেক্টের জন্য সূক্ষ্ম হওয়া উচিত। 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

আপনি সর্বদা ট্রাইফুনশনে থামাতে পারবেন না। কখনও কখনও, আপনার ফাংশনগুলিতে আপনাকে n সংখ্যক পরামিতি পাস করতে হতে পারে। তারপরে সহায়তা দলকে আপনার কোড ঠিক করতে একটি চতুর্থাংশ তৈরি করতে হবে। দীর্ঘমেয়াদী সমাধানটি হ'ল অতিরিক্ত প্যারামিটারগুলি সহ একটি অবজেক্ট তৈরি করা এবং তারপরে তৈরি ফাংশন বা বায়ু ফাংশন ব্যবহার করা।