Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2007 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.io;
 
 
 import java.io.Reader;
 import java.io.Writer;
 import java.util.List;

Provides utility methods for working with character streams.

All method parameters must be non-null unless documented otherwise.

Some of the methods in this class take arguments with a generic type of Readable & Closeable. A java.io.Reader implements both of those interfaces. Similarly for Appendable & Closeable and java.io.Writer.

Author(s):
Chris Nokleberg
Bin Zhu
Since:
1.0
 
 public final class CharStreams {
   private static final int BUF_SIZE = 0x800; // 2K chars (4K bytes)
 
   private CharStreams() {}

  
Returns a factory that will supply instances of java.io.StringReader that read a string value.

Parameters:
value the string to read
Returns:
the factory
 
       final String value) {
     Preconditions.checkNotNull(value);
     return new InputSupplier<StringReader>() {
       @Override
       public StringReader getInput() {
         return new StringReader(value);
       }
     };
   }

  
Returns a factory that will supply instances of java.io.InputStreamReader, using the given java.io.InputStream factory and character set.

Parameters:
in the factory that will be used to open input streams
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the factory
 
       final InputSupplier<? extends InputStreaminfinal Charset charset) {
     Preconditions.checkNotNull(in);
     Preconditions.checkNotNull(charset);
     return new InputSupplier<InputStreamReader>() {
       @Override
       public InputStreamReader getInput() throws IOException {
         return new InputStreamReader(in.getInput(), charset);
       }
     };
   }

  
Returns a factory that will supply instances of java.io.OutputStreamWriter, using the given java.io.OutputStream factory and character set.

Parameters:
out the factory that will be used to open output streams
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the factory
      final OutputSupplier<? extends OutputStreamoutfinal Charset charset) {
    Preconditions.checkNotNull(out);
    Preconditions.checkNotNull(charset);
    return new OutputSupplier<OutputStreamWriter>() {
      @Override
      public OutputStreamWriter getOutput() throws IOException {
        return new OutputStreamWriter(out.getOutput(), charset);
      }
    };
  }

  
Writes a character sequence (such as a string) to an appendable object from the given supplier.

Parameters:
from the character sequence to write
to the output supplier
Throws:
java.io.IOException if an I/O error occurs
  public static <W extends Appendable & Closeablevoid write(CharSequence from,
      OutputSupplier<W> tothrows IOException {
    Preconditions.checkNotNull(from);
    boolean threw = true;
    W out = to.getOutput();
    try {
      out.append(from);
      threw = false;
    } finally {
      Closeables.close(outthrew);
    }
  }

  
Opens java.lang.Readable and java.lang.Appendable objects from the given factories, copies all characters between the two, and closes them.

Parameters:
from the input factory
to the output factory
Returns:
the number of characters copied
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & Closeable,
      W extends Appendable & Closeablelong copy(InputSupplier<R> from,
      OutputSupplier<W> tothrows IOException {
    int successfulOps = 0;
    R in = from.getInput();
    try {
      W out = to.getOutput();
      try {
        long count = copy(inout);
        successfulOps++;
        return count;
      } finally {
        Closeables.close(outsuccessfulOps < 1);
        successfulOps++;
      }
    } finally {
      Closeables.close(insuccessfulOps < 2);
    }
  }

  
Opens a java.lang.Readable object from the supplier, copies all characters to the java.lang.Appendable object, and closes the input. Does not close or flush the output.

Parameters:
from the input factory
to the object to write to
Returns:
the number of characters copied
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & Closeablelong copy(
      InputSupplier<R> fromAppendable tothrows IOException {
    boolean threw = true;
    R in = from.getInput();
    try {
      long count = copy(into);
      threw = false;
      return count;
    } finally {
      Closeables.close(inthrew);
    }
  }

  
Copies all characters between the java.lang.Readable and java.lang.Appendable objects. Does not close or flush either object.

Parameters:
from the object to read from
to the object to write to
Returns:
the number of characters copied
Throws:
java.io.IOException if an I/O error occurs
  public static long copy(Readable fromAppendable tothrows IOException {
    CharBuffer buf = CharBuffer.allocate();
    long total = 0;
    while (from.read(buf) != -1) {
      buf.flip();
      to.append(buf);
      total += buf.remaining();
      buf.clear();
    }
    return total;
  }

  
Reads all characters from a java.lang.Readable object into a java.lang.String. Does not close the Readable.

Parameters:
r the object to read from
Returns:
a string containing all the characters
Throws:
java.io.IOException if an I/O error occurs
  public static String toString(Readable rthrows IOException {
    return toStringBuilder(r).toString();
  }

  
Returns the characters from a java.lang.Readable & java.io.Closeable object supplied by a factory as a java.lang.String.

Parameters:
supplier the factory to read from
Returns:
a string containing all the characters
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & CloseableString toString(
      InputSupplier<R> supplierthrows IOException {
    return toStringBuilder(supplier).toString();
  }

  
Reads all characters from a java.lang.Readable object into a new java.lang.StringBuilder instance. Does not close the Readable.

Parameters:
r the object to read from
Returns:
a java.lang.StringBuilder containing all the characters
Throws:
java.io.IOException if an I/O error occurs
  private static StringBuilder toStringBuilder(Readable rthrows IOException {
    StringBuilder sb = new StringBuilder();
    copy(rsb);
    return sb;
  }

  
Returns the characters from a java.lang.Readable & java.io.Closeable object supplied by a factory as a new java.lang.StringBuilder instance.

Parameters:
supplier the factory to read from
Throws:
java.io.IOException if an I/O error occurs
  private static <R extends Readable & CloseableStringBuilder toStringBuilder(
      InputSupplier<R> supplierthrows IOException {
    boolean threw = true;
    R r = supplier.getInput();
    try {
      StringBuilder result = toStringBuilder(r);
      threw = false;
      return result;
    } finally {
      Closeables.close(rthrew);
    }
  }

  
Reads the first line from a java.lang.Readable & java.io.Closeable object supplied by a factory. The line does not include line-termination characters, but does include other leading and trailing whitespace.

Parameters:
supplier the factory to read from
Returns:
the first line, or null if the reader is empty
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & CloseableString readFirstLine(
      InputSupplier<R> supplierthrows IOException {
    boolean threw = true;
    R r = supplier.getInput();
    try {
      String line = new LineReader(r).readLine();
      threw = false;
      return line;
    } finally {
      Closeables.close(rthrew);
    }
  }

  
Reads all of the lines from a java.lang.Readable & java.io.Closeable object supplied by a factory. The lines do not include line-termination characters, but do include other leading and trailing whitespace.

Parameters:
supplier the factory to read from
Returns:
a mutable java.util.List containing all the lines
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & CloseableList<StringreadLines(
      InputSupplier<R> supplierthrows IOException {
    boolean threw = true;
    R r = supplier.getInput();
    try {
      List<Stringresult = readLines(r);
      threw = false;
      return result;
    } finally {
      Closeables.close(rthrew);
    }
  }

  
Reads all of the lines from a java.lang.Readable object. The lines do not include line-termination characters, but do include other leading and trailing whitespace.

Does not close the Readable. If reading files or resources you should use the Files.readLines(java.io.File,java.nio.charset.Charset) and Resources.readLines(java.net.URL,java.nio.charset.Charset) methods.

Parameters:
r the object to read from
Returns:
a mutable java.util.List containing all the lines
Throws:
java.io.IOException if an I/O error occurs
  public static List<StringreadLines(Readable rthrows IOException {
    List<Stringresult = new ArrayList<String>();
    LineReader lineReader = new LineReader(r);
    String line;
    while ((line = lineReader.readLine()) != null) {
      result.add(line);
    }
    return result;
  }

  
Streams lines from a java.lang.Readable and java.io.Closeable object supplied by a factory, stopping when our callback returns false, or we have read all of the lines.

Parameters:
supplier the factory to read from
callback the LineProcessor to use to handle the lines
Returns:
the output of processing the lines
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & Closeable, T> T readLines(
      InputSupplier<R> supplierLineProcessor<T> callbackthrows IOException {
    boolean threw = true;
    R r = supplier.getInput();
    try {
      LineReader lineReader = new LineReader(r);
      String line;
      while ((line = lineReader.readLine()) != null) {
        if (!callback.processLine(line)) {
          break;
        }
      }
      threw = false;
    } finally {
      Closeables.close(rthrew);
    }
    return callback.getResult();
  }

  
Joins multiple java.io.Reader suppliers into a single supplier. Reader returned from the supplier will contain the concatenated data from the readers of the underlying suppliers.

Reading from the joined reader will throw a java.lang.NullPointerException if any of the suppliers are null or return null.

Only one underlying reader will be open at a time. Closing the joined reader will close the open underlying reader.

Parameters:
suppliers the suppliers to concatenate
Returns:
a supplier that will return a reader containing the concatenated data
  public static InputSupplier<Readerjoin(
      final Iterable<? extends InputSupplier<? extends Reader>> suppliers) {
    return new InputSupplier<Reader>() {
      @Override public Reader getInput() throws IOException {
        return new MultiReader(suppliers.iterator());
      }
    };
  }

  
Varargs form of join(java.lang.Iterable).
  public static InputSupplier<Readerjoin(
      InputSupplier<? extends Reader>... suppliers) {
    return join(Arrays.asList(suppliers));
  }

  
Discards n characters of data from the reader. This method will block until the full amount has been skipped. Does not close the reader.

Parameters:
reader the reader to read from
n the number of characters to skip
Throws:
java.io.EOFException if this stream reaches the end before skipping all the bytes
java.io.IOException if an I/O error occurs
  public static void skipFully(Reader readerlong nthrows IOException {
    while (n > 0) {
      long amt = reader.skip(n);
      if (amt == 0) {
        // force a blocking read
        if (reader.read() == -1) {
          throw new EOFException();
        }
        n--;
      } else {
        n -= amt;
      }
    }
  }

  
Returns a Writer that sends all output to the given java.lang.Appendable target. Closing the writer will close the target if it is java.io.Closeable, and flushing the writer will flush the target if it is java.io.Flushable.

Parameters:
target the object to which output will be sent
Returns:
a new Writer object, unless target is a Writer, in which case the target is returned
  public static Writer asWriter(Appendable target) {
    if (target instanceof Writer) {
      return (Writertarget;
    }
    return new AppendableWriter(target);
  }
New to GrepCode? Check out our FAQ X