Java8 विधि कार्यों

Question

गठबंधन करने के लिए समारोह वस्तु के रूप में इस्तेमाल संदर्भ वहाँ अपने तरीकों का उपयोग करने के लिए एक Function वस्तु के रूप में एक विधि संदर्भ का उपयोग करने के Java8 में एक रास्ता है:

Stream.of("ciao", "hola", "hello") 
    .map(String::length.andThen(n -> n * 2)) 

इस सवाल से संबंधित नहीं है

Stream.of("ciao", "hola", "hello").map(String::length).map(n -> n * 2); 

Answer 1

आप यह करने के लिए एक स्थिर विधि लिख सकते हैं:

import java.util.function.*; 

class Test { 
    public static void main(String[] args) { 
     Function<String, Integer> function = combine(String::length, n -> n * 2); 
     System.out.println(function.apply("foo")); 
    } 

    public static <T1, T2, T3> Function<T1, T3> combine(
     Function<T1, T2> first, 
     Function<T2, T3> second) { 
     return first.andThen(second); 
    } 
} 

फिर आप एक उपयोगिता में रख सकता है कक्षा और इसे स्थिर रूप से आयात करें।

import java.util.function.*; 

class Test { 
    public static void main(String[] args) { 
     Function<String, Integer> function = asFunction(String::length).andThen(n -> n * 2); 
     System.out.println(function.apply("foo")); 
    } 

    public static <T1, T2> Function<T1, T2> asFunction(Function<T1, T2> function) { 
     return function;  
    } 
} 

Answer 2

आप लिख सकते हैं करना चाहते हैं बस इसे एक चर में बचा सकते हैं:

Function<String, Integer> toLength = String::length; 
Stream.of("ciao", "hola", "hello") 
     .map(toLength.andThen(n -> n * 2)); 

या आप एक डाली उपयोग कर सकते हैं, लेकिन यह भी कम पठनीय है, IMO:

Stream.of("ciao", "hola", "hello") 
     .map(((Function<String, Integer>) String::length).andThen(n -> n * 2)); 

Answer 3

आप: Stream, यह सिर्फ उदाहरण के रूप में प्रयोग किया जाता है, मैं विधि संदर्भ के बारे में जवाब

Answer 4

आप को प्राप्त करने के लिए आप क्या डाले उपयोग करके इनलाइन चाहते सक्षम होना चाहिए:

Stream.of("ciao", "hola", "hello") 
     .map(((Function<String, Integer>) String::length).andThen(n -> n * 2)) 

वहाँ केवल संकलक के लिए 'प्रकार संकेत' हैं, इसलिए वे नहीं वास्तव में वस्तु 'डाली' करते हैं और एक वास्तविक कलाकारों के भूमि के ऊपर नहीं है।

---

वैकल्पिक रूप से, आप पठनीयता के लिए एक स्थानीय चर का उपयोग कर सकते हैं:

Function<String, Integer> fun = String::length 

Stream.of("ciao", "hola", "hello") 
     .map(fun.andThen(n -> n * 2)); 

---

एक तीसरा रास्ता है कि अधिक संक्षिप्त हो सकता है एक उपयोगिता विधि के साथ है:

public static <T, X, U> Function<T, U> chain(Function<T, X> fun1, Function<X, U> fun2) 
{ 
    return fun1.andThen(fun2); 
} 

Stream.of("ciao", "hola", "hello") 
     .map(chain(String::length, n -> n * 2)); 

कृपया ध्यान दें कि यह परीक्षण नहीं किया गया है, इस प्रकार मुझे नहीं पता कि इस मामले में टाइप अनुमान सही तरीके से काम करता है या नहीं।

Answer 5

तुम एक डाली उपयोग कर सकते हैं

Stream.of("ciao", "hola", "hello") 
     .map(((Function<String, Integer>) String::length) 
       .andThen(n -> n * 2)) 
     .forEach(System.out::println); 

प्रिंट

8 
8 
10 

Answer 6

तुम भी

Function.identity().andThen(String::length).andThen(n -> n * 2) 

उपयोग कर सकते हैं:

वैकल्पिक रूप से, यह जानकर आप क्या कर रहे एक सरल तरीका है जिसके स्थिर सिर्फ समारोह में यह दिया है देता है, संकलक की खातिर बनाने

समस्या है, String::length आवश्यक नहीं है Function; यह कई कार्यात्मक इंटरफेस के अनुरूप हो सकता है। इसका उपयोग उस संदर्भ में किया जाना चाहिए जो लक्ष्य प्रकार प्रदान करता है, और संदर्भ हो सकता है - असाइनमेंट, विधि आमंत्रण, कास्टिंग।Function सिर्फ लक्ष्य टाइपिंग के लिए एक स्थिर विधि प्रदान कर सकता है

, तो हम

Function.by(String::length).andThen(n->n*2) 

static <T, R> Function<T, R> by(Function<T, R> f){ return f; } 

---

उदाहरण के लिए, मैं a functional interface

static <T> AsyncIterator<T> by(AsyncIterator<T> asyncIterator) 

में इस तकनीक का प्रयोग कर सकता है एक लैम्ब्डा अभिव्यक्ति या विधि संदर्भ से एक AsyncIterator बनाने के लिए सिंटेक्स चीनी।

यह विधि केवल asyncIterator तर्क देता है, जो थोड़ा अजीब लगता है। स्पष्टीकरण:

के बाद से AsyncIterator एक कार्यात्मक इंटरफ़ेस है, एक उदाहरण 3 संदर्भों में एक लैम्ब्डा अभिव्यक्ति या एक विधि संदर्भ, द्वारा बनाया जा सकता:

// Assignment Context 
AsyncIterator<ByteBuffer> asyncIter = source::read; 
asyncIter.forEach(...); 

// Casting Context 
((AsyncIterator<ByteBuffer>)source::read) 
    .forEach(...); 

// Invocation Context 
AsyncIterator.by(source::read) 
    .forEach(...); 

3 विकल्प अन्य की तुलना में बेहतर लग रहा है दो, और यह इस विधि का उद्देश्य है।