आप जावा में दो इनपुट स्ट्रीम कैसे मर्ज करते हैं?

Question

जावा में दो इनपुटस्ट्रीम होने के कारण, उन्हें मर्ज करने का कोई तरीका है ताकि आप एक इनपुटस्ट्रीम के साथ समाप्त हो जाएं जो आपको दोनों धाराओं का आउटपुट देता है? कैसे?

Answer 1

टिप्पणी के अनुसार, यह स्पष्ट नहीं है कि विलय करके आपका क्या मतलब है।

या तो "यादृच्छिक रूप से" उपलब्ध इनपुट लेना InputStream.available द्वारा जटिल है जो आपको एक उपयोगी उत्तर और धाराओं के व्यवहार को अवरुद्ध करने के लिए आवश्यक नहीं है। आपको धाराओं से पढ़ने के लिए दो धागे की आवश्यकता होगी और फिर java.io.Piped(In|Out)putStream (हालांकि उन वर्गों में समस्याएं हैं) के माध्यम से डेटा वापस गुजरना होगा। वैकल्पिक रूप से कुछ प्रकार की धाराओं के लिए एक अलग इंटरफ़ेस का उपयोग करना संभव हो सकता है, उदाहरण के लिए java.nio गैर-अवरुद्ध चैनल।

यदि आप पहले इनपुट स्ट्रीम की पूर्ण सामग्री चाहते हैं तो दूसरे के बाद: new java.io.SequenceInputStream(s1, s2)।

Answer 2

ऐसा नहीं है कि मैं सोच सकता हूं। आपको शायद दो धाराओं की सामग्री को बाइट [] में पढ़ना होगा और उसके बाद से बाइटएरेइन इनपुट स्ट्रीम बनाएं।

Answer 3

आप एक कस्टम InputStream कार्यान्वयन लिख सकते हैं जो ऐसा करता है। उदाहरण:

import java.io.IOException; 
import java.io.InputStream; 
import java.util.Collections; 
import java.util.Deque; 
import java.util.LinkedList; 

public class CatInputStream extends InputStream { 
    private final Deque<InputStream> streams; 

    public CatInputStream(InputStream... streams) { 
     this.streams = new LinkedList<InputStream>(); 
     Collections.addAll(this.streams, streams); 
    } 

    private void nextStream() throws IOException { 
     streams.removeFirst().close(); 
    } 

    @Override 
    public int read() throws IOException { 
     int result = -1; 
     while (!streams.isEmpty() 
       && (result = streams.getFirst().read()) == -1) { 
      nextStream(); 
     } 
     return result; 
    } 

    @Override 
    public int read(byte b[], int off, int len) throws IOException { 
     int result = -1; 
     while (!streams.isEmpty() 
       && (result = streams.getFirst().read(b, off, len)) == -1) { 
      nextStream(); 
     } 
     return result; 
    } 

    @Override 
    public long skip(long n) throws IOException { 
     long skipped = 0L; 
     while (skipped < n && !streams.isEmpty()) { 
      int thisSkip = streams.getFirst().skip(n - skipped); 
      if (thisSkip > 0) 
       skipped += thisSkip; 
      else 
       nextStream(); 
     } 
     return skipped; 
    } 

    @Override 
    public int available() throws IOException { 
     return streams.isEmpty() ? 0 : streams.getFirst().available(); 
    } 

    @Override 
    public void close() throws IOException { 
     while (!streams.isEmpty()) 
      nextStream(); 
    } 
} 

यह कोड परीक्षण नहीं किया गया है, इसलिए आपका लाभ भिन्न हो सकता है।

Answer 4

java.io.SequenceInputStream आपको जो चाहिए वह हो सकता है। यह धाराओं की गणना स्वीकार करता है, और पहली धारा की सामग्री को आउटपुट करेगा, फिर दूसरा, और तब तक जब तक सभी धाराएं खाली न हों।

Answer 5

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

import java.nio.ByteBuffer; 

public final class MVar { 

    private static enum State { 
    EMPTY, ONE, MANY 
    } 

    private final Object lock; 

    private State state; 

    private byte b; 

    private ByteBuffer bytes; 
    private int length; 

    public MVar() { 
    lock = new Object(); 
    state = State.EMPTY; 
    } 

    public final void put(byte b) { 
    synchronized (lock) { 
     while (state != State.EMPTY) { 
     try { 
      lock.wait(); 
     } catch (InterruptedException e) {} 
     } 
     this.b = b; 
     state = State.ONE; 
     lock.notifyAll(); 
    } 
    } 

    public final void put(byte[] bytes, int offset, int length) { 
    if (length == 0) { 
     return; 
    } 
    synchronized (lock) { 
     while (state != State.EMPTY) { 
     try { 
      lock.wait(); 
     } catch (InterruptedException e) {} 
     } 
     this.bytes = ByteBuffer.allocateDirect(length); 
     this.bytes.put(bytes, offset, length); 
     this.bytes.position(0); 
     this.length = length; 
     state = State.MANY; 
     lock.notifyAll(); 
    } 
    } 

    public final byte take() { 
    synchronized (lock) { 
     while (state == State.EMPTY) { 
     try { 
      lock.wait(); 
     } catch (InterruptedException e) {} 
     } 
     switch (state) { 
     case ONE: { 
     state = State.EMPTY; 
     byte b = this.b; 
     lock.notifyAll(); 
     return b; 
     } 
     case MANY: { 
     byte b = bytes.get(); 
     state = --length <= 0 ? State.EMPTY : State.MANY; 
     lock.notifyAll(); 
     return b; 
     } 
     default: 
     throw new AssertionError(); 
     } 
    } 
    } 

    public final int take(byte[] bytes, int offset, int length) { 
    if (length == 0) { 
     return 0; 
    } 
    synchronized (lock) { 
     while (state == State.EMPTY) { 
     try { 
      lock.wait(); 
     } catch (InterruptedException e) {} 
     } 
     switch (state) { 
     case ONE: 
     bytes[offset] = b; 
     state = State.EMPTY; 
     lock.notifyAll(); 
     return 1; 
     case MANY: 
     if (this.length > length) { 
      this.bytes.get(bytes, offset, length); 
      this.length = this.length - length; 
      synchronized (lock) { 
      lock.notifyAll(); 
      } 
      return length; 
     } 
     this.bytes.get(bytes, offset, this.length); 
     this.bytes = null; 
     state = State.EMPTY; 
     length = this.length; 
     lock.notifyAll(); 
     return length; 
     default: 
     throw new AssertionError(); 
     } 
    } 
    } 
}