जावा जेनरिक: जेनेरिक फ़ंक्शन ऑब्जेक्ट को एक साथ जोड़ना

यहां ऐसा करने का एक तरीका है। रन विधि टाइपएफ़ नहीं है, लेकिन यह देखते हुए कि पाइप को जोड़ने का एकमात्र तरीका इसे एक प्रकार से सुरक्षित तरीके से करना है, पूरी श्रृंखला टाइप-सुरक्षित है।

public class Chain<S, T> { 
    private List<Pipe<?, ?>> pipes; 

    private Chain() { 
    } 

    public static <K, L> Chain<K, L> start(Pipe<K, L> pipe) { 
     Chain<K, L> chain = new Chain<K, L>(); 
     chain.pipes = Collections.<Pipe<?, ?>>singletonList(pipe);; 
     return chain; 
    } 

    public <V> Chain<S, V> append(Pipe<T, V> pipe) { 
     Chain<S, V> chain = new Chain<S, V>(); 
     chain.pipes = new ArrayList<Pipe<?, ?>>(pipes); 
     chain.pipes.add(pipe); 
     return chain; 
    } 

    @SuppressWarnings({ "rawtypes", "unchecked" }) 
    public T run(S s) { 
     Object source = s; 
     Object target = null; 
     for (Pipe p : pipes) { 
      target = p.transform(source); 
      source = target; 
     } 
     return (T) target; 
    } 

    public static void main(String[] args) { 
     Pipe<String, Integer> pipe1 = new Pipe<String, Integer>() { 
      @Override 
      public Integer transform(String s) { 
       return Integer.valueOf(s); 
      } 
     }; 
     Pipe<Integer, Long> pipe2 = new Pipe<Integer, Long>() { 
      @Override 
      public Long transform(Integer s) { 
       return s.longValue(); 
      } 
     }; 
     Pipe<Long, BigInteger> pipe3 = new Pipe<Long, BigInteger>() { 
      @Override 
      public BigInteger transform(Long s) { 
       return new BigInteger(s.toString()); 
      } 
     }; 
     Chain<String, BigInteger> chain = Chain.start(pipe1).append(pipe2).append(pipe3); 
     BigInteger result = chain.run("12"); 
     System.out.println(result); 
    } 
}

स्रोत

2011-12-30 16:48:12

वास्तव में अच्छा है, और सभी अच्छे समाधानों की तरह, यह ज्ञात होने के बाद यह स्पष्ट है :) – downer

आपके उत्तर के लिए धन्यवाद :) मैं आपके [github प्रोजेक्ट] (https://github.com/smartorigin/Dynamic-Workflow) को आपके आधार पर बना देता हूं जवाब है कि async कार्यक्षमता और समानांतर निष्पादन जोड़ें। उम्मीद है कि यह किसी की मदद करेगा। –

यहां ऐसा करने का एक और तरीका है: इस तरह एक सूची में परिवर्तन के लिए एक परिवर्तन चरण की अनुमति देता है। उदाहरण के लिए, एक परिवर्तन एक स्ट्रिंग को एकाधिक सबस्ट्रिंग में विभाजित कर सकता है। इसके अलावा, यह किसी भी मूल्य को बदलने के अपवाद उत्पन्न करने पर सामान्य अपवाद हैंडलिंग कोड की अनुमति देता है। यह एक खाली सूची के उपयोग को एक अस्पष्ट शून्य मूल्य के बजाय रिटर्न वैल्यू के रूप में भी अनुमति देता है जिसे NullPointerException से बचने के लिए परीक्षण किया जाना है। इस के साथ मुख्य समस्या यह है कि यह अगले चरण में जाने से पहले प्रत्येक परिवर्तन चरण को पूरी तरह से करता है, जो स्मृति कुशल नहीं हो सकता है।

public class Chain<IN, MEDIAL, OUT> { 
    private final Chain<IN, ?, MEDIAL> head; 
    private final Transformer<MEDIAL, OUT> tail; 

    public static <I, O> Chain<I, I, O> makeHead(@Nonnull Transformer<I, O> tail) { 
     return new Chain<>(null, tail); 
    } 

    public static <I, M, O> Chain<I, M, O> append(@Nonnull Chain<I, ?, M> head, @Nonnull Transformer<M, O> tail) { 
     return new Chain<>(head, tail); 
    } 

    private Chain(@Nullable Chain<IN, ?, MEDIAL> head, @Nonnull Transformer<MEDIAL, OUT> tail) { 
     this.head = head; 
     this.tail = tail; 
    } 

    public List<OUT> run(List<IN> input) { 
     List<OUT> allResults = new ArrayList<>(); 

     List<MEDIAL> headResult; 
     if (head == null) { 
      headResult = (List<MEDIAL>) input; 
     } else { 
      headResult = head.run(input); 
     } 

     for (MEDIAL in : headResult) { 
      // try/catch here 
      allResults.addAll(tail.transform(in)); 
     } 

     return allResults; 
    } 

    public static void main(String[] args) { 

     Transformer<String, Integer> pipe1 = new Transformer<String, Integer>() { 
      @Override 
      public List<Integer> transform(String s) { 
       return Collections.singletonList(Integer.valueOf(s) * 3); 
      } 
     }; 
     Transformer<Integer, Long> pipe2 = new Transformer<Integer, Long>() { 
      @Override 
      public List<Long> transform(Integer s) { 
       return Collections.singletonList(s.longValue() * 5); 
      } 
     }; 
     Transformer<Long, BigInteger> pipe3 = new Transformer<Long, BigInteger>() { 
      @Override 
      public List<BigInteger> transform(Long s) { 
       return Collections.singletonList(new BigInteger(String.valueOf(s * 7))); 
      } 
     }; 
     Chain<String, ?, Integer> chain1 = Chain.makeHead(pipe1); 
     Chain<String, Integer, Long> chain2 = Chain.append(chain1, pipe2); 
     Chain<String, Long, BigInteger> chain3 = Chain.append(chain2, pipe3); 
     List<BigInteger> result = chain3.run(Collections.singletonList("1")); 
     System.out.println(result); 
    } 
}

स्रोत

2014-04-08 17:18:40 Shannon

जाहिर है, यदि आप जावा 8 का उपयोग करने में सक्षम हैं, तो आप इसके बजाय स्ट्रीम का उपयोग करना चाहते हैं। या, आरएक्सजेवा की तरह कुछ। – Shannon

जावा जेनरिक: जेनेरिक फ़ंक्शन ऑब्जेक्ट को एक साथ जोड़ना

उत्तर

संबंधित मुद्दे