Java: accéder à une liste de chaînes en tant que InputStream

Est-il de toute façon InputStream emballage une liste de UTF-8 String? J'aimerais faire quelque chose comme:

InputStream in = new XyzInputStream( List<String> lines )

source d'informationauteur Marc Polizzi

  1. 3

    Vous pouvez concaténer toutes les lignes ensemble pour créer une Chaîne, puis de le convertir en un tableau d'octets à l'aide de String#getBytes et la passer dans ByteArrayInputStream. Cependant, ce n'est pas le moyen le plus efficace de le faire.

  2. 6

    Vous pouvez lire à partir d'un ByteArrayOutputStream et vous pouvez créer votre source byte[] tableau à l'aide d'un ByteArrayInputStream.

    Afin de créer le tableau comme suit:

     List<String> source = new ArrayList<String>();
 source.add("one");
 source.add("two");
 source.add("three");
 ByteArrayOutputStream baos = new ByteArrayOutputStream();

 for (String line : source) {
   baos.write(line.getBytes());
 }

 byte[] bytes = baos.toByteArray();

    Et la lecture de c'est aussi simple que:

     InputStream in = new ByteArrayInputStream(bytes);

    Alternativement, en fonction de ce que vous essayez de faire, un StringReader peut-être mieux.

  3. 4

    En bref, non, il n'y a pas moyen de faire cela en utilisant les classes du JDK. Vous pouvez, cependant, de mettre en œuvre votre propre InputStream que la lecture d'une Liste de Chaînes de caractères.

    EDIT: Dave Web a une réponse ci-dessus, je pense que c'est le chemin à parcourir. Si vous avez besoin d'une classe réutilisable, alors quelque chose comme cela pourrait faire:

    
public class StringsInputStream<T extends Iterable<String>> extends InputStream {
private ByteArrayInputStream bais = null;
public StringsInputStream(final T strings) throws IOException {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
for (String line : strings) {
outputStream.write(line.getBytes());
}
bais = new ByteArrayInputStream(outputStream.toByteArray());
}
@Override
public int read() throws IOException {
return bais.read();
}
@Override
public int read(byte[] b) throws IOException {
return bais.read(b);
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
return bais.read(b, off, len);
}
@Override
public long skip(long n) throws IOException {
return bais.skip(n);
}
@Override
public int available() throws IOException {
return bais.available();
}
@Override
public void close() throws IOException {
bais.close();
}
@Override
public synchronized void mark(int readlimit) {
bais.mark(readlimit);
}
@Override
public synchronized void reset() throws IOException {
bais.reset();
}
@Override
public boolean markSupported() {
return bais.markSupported();
}
public static void main(String[] args) throws Exception {
List source = new ArrayList();
source.add("foo ");
source.add("bar ");
source.add("baz");
StringsInputStream<List<String>> in = new StringsInputStream<List<String>>(source);
int read = in.read();
while (read != -1) {
System.out.print((char) read);
read = in.read();
}
}
}

    Fondamentalement un adaptateur pour ByteArrayInputStream.

  4. 0

    vous pouvez aussi le faire de cette façon créer un Serializable Liste

    List<String> quarks = Arrays.asList(
"up", "down", "strange", "charm", "top", "bottom"
);
//serialize the List
//note the use of abstract base class references
try{
//use buffering
OutputStream file = new FileOutputStream( "quarks.ser" );
OutputStream buffer = new BufferedOutputStream( file );
ObjectOutput output = new ObjectOutputStream( buffer );
try{
output.writeObject(quarks);
}
finally{
output.close();
}
}  
catch(IOException ex){
fLogger.log(Level.SEVERE, "Cannot perform output.", ex);
}
//deserialize the quarks.ser file
//note the use of abstract base class references
try{
//use buffering
InputStream file = new FileInputStream( "quarks.ser" );
InputStream buffer = new BufferedInputStream( file );
ObjectInput input = new ObjectInputStream ( buffer );
try{
//deserialize the List
List<String> recoveredQuarks = (List<String>)input.readObject();
//display its data
for(String quark: recoveredQuarks){
System.out.println("Recovered Quark: " + quark);
}
}
finally{
input.close();
}
}
catch(ClassNotFoundException ex){
fLogger.log(Level.SEVERE, "Cannot perform input. Class not found.", ex);
}
catch(IOException ex){
fLogger.log(Level.SEVERE, "Cannot perform input.", ex);
}
  5. 0

    Vous pouvez faire quelque chose de similaire à ceci:

    https://commons.apache.org/sandbox/flatfile/xref/org/apache/commons/flatfile/util/ConcatenatedInputStream.html

    Juste implémente la méthode read() de InputStream et a une liste de InputStreams c'est la concaténation. Une fois qu'il lit un EOF il commence la lecture à partir de la prochaine InputStream. Il suffit de convertir les Chaînes de caractères à ByteArrayInputStreams.