Source相当于输入流（InputStream）。把硬盘中的数据输入到内存中。

wKiom1UTcZTSZNnCAABUplp4Pnk401.jpg

例子：

 try {
      File file = new File("test.txt");

      BufferedSource source = Okio.buffer(Okio.source(file));

      //byte[] data = source.readByteArray();
      //System.out.println(new String(data, Charset.forName("UTF-8")));

      BufferedSink sink = Okio.buffer(Okio.sink(new File("test2.txt")));
      source.readAll(sink);
      sink.close();

      source.close();
 } catch (IOException e) {
      e.printStackTrace();
 }


Api文档

 /**
     * Returns this source's internal buffer.
     */
    Buffer buffer();

    /**
     * Returns true if there are no more bytes in this source. This will block
     * until there are bytes to read or the source is definitely exhausted.
     */
    boolean exhausted() throws IOException;

    /**
     * Returns when the buffer contains at least {@code byteCount} bytes. Throws
     * an {@link java.io.EOFException} if the source is exhausted before the
     * required bytes can be read.
     */
    void require(long byteCount) throws IOException;

    /**
     * Returns true when the buffer contains at least {@code byteCount} bytes,
     * expanding it as necessary. Returns false if the source is exhausted before
     * the requested bytes can be read.
     */
    boolean request(long byteCount) throws IOException;

    /**
     * Removes a byte from this source and returns it.
     */
    byte readByte() throws IOException;

    /**
     * Removes two bytes from this source and returns a big-endian short.
     */
    short readShort() throws IOException;

    /**
     * Removes two bytes from this source and returns a little-endian short.
     */
    short readShortLe() throws IOException;

    /**
     * Removes four bytes from this source and returns a big-endian int.
     */
    int readInt() throws IOException;

    /**
     * Removes four bytes from this source and returns a little-endian int.
     */
    int readIntLe() throws IOException;

    /**
     * Removes eight bytes from this source and returns a big-endian long.
     */
    long readLong() throws IOException;

    /**
     * Removes eight bytes from this source and returns a little-endian long.
     */
    long readLongLe() throws IOException;

    /**
     * Reads a long from this source in signed decimal form (i.e., as a string in base 10 with
     * optional leading '-'). This will iterate until a non-digit character is found.
     *
     * @throws NumberFormatException if the found digits do not fit into a {@code long} or a decimal
     *                               number was not present.
     */
    long readDecimalLong() throws IOException;

    /**
     * Reads a long form this source in hexadecimal form (i.e., as a string in base 16). This will
     * iterate until a non-hexadecimal character is found.
     *
     * @throws NumberFormatException if the found hexadecimal does not fit into a {@code long} or
     *                               hexadecimal was not found.
     */
    long readHexadecimalUnsignedLong() throws IOException;

    /**
     * Reads and discards {@code byteCount} bytes from this source. Throws an
     * {@link java.io.EOFException} if the source is exhausted before the
     * requested bytes can be skipped.
     */
    void skip(long byteCount) throws IOException;

    /**
     * Removes all bytes bytes from this and returns them as a byte string.
     */
    ByteString readByteString() throws IOException;

    /**
     * Removes {@code byteCount} bytes from this and returns them as a byte string.
     */
    ByteString readByteString(long byteCount) throws IOException;

    /**
     * Removes all bytes from this and returns them as a byte array.
     */
    byte[] readByteArray() throws IOException;

    /**
     * Removes {@code byteCount} bytes from this and returns them as a byte array.
     */
    byte[] readByteArray(long byteCount) throws IOException;

    /**
     * Removes up to {@code sink.length} bytes from this and copies them into {@code sink}.
     * Returns the number of bytes read, or -1 if this source is exhausted.
     */
    int read(byte[] sink) throws IOException;

    /**
     * Removes exactly {@code sink.length} bytes from this and copies them into {@code sink}.
     * Throws an {@link java.io.EOFException} if the requested number of bytes cannot be read.
     */
    void readFully(byte[] sink) throws IOException;

    /**
     * Removes up to {@code byteCount} bytes from this and copies them into {@code sink} at
     * {@code offset}. Returns the number of bytes read, or -1 if this source is exhausted.
     */
    int read(byte[] sink, int offset, int byteCount) throws IOException;

    /**
     * Removes exactly {@code byteCount} bytes from this and appends them to
     * {@code sink}. Throws an {@link java.io.EOFException} if the requested
     * number of bytes cannot be read.
     */
    void readFully(Buffer sink, long byteCount) throws IOException;

    /**
     * Removes all bytes from this and appends them to {@code sink}. Returns the
     * total number of bytes written to {@code sink} which will be 0 if this is
     * exhausted.
     */
    long readAll(Sink sink) throws IOException;

    /**
     * Removes all bytes from this, decodes them as UTF-8, and returns the string.
     */
    String readUtf8() throws IOException;

    /**
     * Removes {@code byteCount} bytes from this, decodes them as UTF-8, and
     * returns the string.
     */
    String readUtf8(long byteCount) throws IOException;

    /**
     * Removes and returns characters up to but not including the next line break.
     * A line break is either {@code "\n"} or {@code "\r\n"}; these characters are
     * not included in the result.
     * <p/>
     * <p><strong>On the end of the stream this method returns null,</strong> just
     * like {@link java.io.BufferedReader}. If the source doesn't end with a line
     * break then an implicit line break is assumed. Null is returned once the
     * source is exhausted. Use this for human-generated data, where a trailing
     * line break is optional.
     */
    String readUtf8Line() throws IOException;

    /**
     * Removes and returns characters up to but not including the next line break.
     * A line break is either {@code "\n"} or {@code "\r\n"}; these characters are
     * not included in the result.
     * <p/>
     * <p><strong>On the end of the stream this method throws.</strong> Every call
     * must consume either '\r\n' or '\n'. If these characters are absent in the
     * stream, an {@link java.io.EOFException} is thrown. Use this for
     * machine-generated data where a missing line break implies truncated input.
     */
    String readUtf8LineStrict() throws IOException;

    /**
     * Removes all bytes from this, decodes them as {@code charset}, and returns
     * the string.
     */
    String readString(Charset charset) throws IOException;

    /**
     * Removes {@code byteCount} bytes from this, decodes them as {@code charset},
     * and returns the string.
     */
    String readString(long byteCount, Charset charset) throws IOException;

    /**
     * Returns the index of the first {@code b} in the buffer. This expands the
     * buffer as necessary until {@code b} is found. This reads an unbounded
     * number of bytes into the buffer. Returns -1 if the stream is exhausted
     * before the requested byte is found.
     */
    long indexOf(byte b) throws IOException;

    /**
     * Returns the index of the first {@code b} in the buffer at or after {@code
     * fromIndex}. This expands the buffer as necessary until {@code b} is found.
     * This reads an unbounded number of bytes into the buffer. Returns -1 if the
     * stream is exhausted before the requested byte is found.
     */
    long indexOf(byte b, long fromIndex) throws IOException;

    /**
     * Returns the index of the first byte in {@code targetBytes} in the buffer.
     * This expands the buffer as necessary until a target byte is found. This
     * reads an unbounded number of bytes into the buffer. Returns -1 if the
     * stream is exhausted before the requested byte is found.
     */
    long indexOfElement(ByteString targetBytes) throws IOException;

    /**
     * Returns the index of the first byte in {@code targetBytes} in the buffer
     * at or after {@code fromIndex}. This expands the buffer as necessary until
     * a target byte is found. This reads an unbounded number of bytes into the
     * buffer. Returns -1 if the stream is exhausted before the requested byte is
     * found.
     */
    long indexOfElement(ByteString targetBytes, long fromIndex) throws IOException;

    /**
     * Returns an input stream that reads from this source.
     */
    InputStream inputStream();