system.println的源码实现

println方法：

 public void println(String x) {
	synchronized (this) {
	    print(x);
	    newLine();
	}
    }

其实主要是调用了print方法：

  public void print(String s) {
	if (s == null) {
	    s = "null";
	}
	write(s);
    }

  private void write(String s) {
	try {
	    synchronized (this) {
		ensureOpen();
		textOut.write(s);
		textOut.flushBuffer();
		charOut.flushBuffer();
		if (autoFlush && (s.indexOf('\n') >= 0))
		    out.flush();
	    }
	}
	catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	}
	catch (IOException x) {
	    trouble = true;
	}
    }

 private OutputStreamWriter charOut;

 public void write(String str) throws IOException {
	write(str, 0, str.length());
    }

public void write(String str, int off, int len) throws IOException {
	synchronized (lock) {
	    char cbuf[];
	    if (len <= writeBufferSize) {
		if (writeBuffer == null) {
		    writeBuffer = new char[writeBufferSize];
		}
		cbuf = writeBuffer;
	    } else {	// Don't permanently allocate very large buffers.
		cbuf = new char[len];
	    }
	    str.getChars(off, (off + len), cbuf, 0);
	    write(cbuf, 0, len);
	}
    }

 public void write(char cbuf[], int off, int len) throws IOException {
	synchronized (lock) {
	    ensureOpen();
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return;
            } 

	    if (len >= nChars) {
		/* If the request length exceeds the size of the output buffer,
		   flush the buffer and then write the data directly.  In this
		   way buffered streams will cascade harmlessly. */
		flushBuffer();
		out.write(cbuf, off, len);
		return;
	    }

	    int b = off, t = off + len;
	    while (b < t) {
		int d = min(nChars - nextChar, t - b);
		System.arraycopy(cbuf, b, cb, nextChar, d);
		b += d;
		nextChar += d;
		if (nextChar >= nChars)
		    flushBuffer();
	    }
	}
    }

看到write里是用到flushBuffer的。

 void flushBuffer() throws IOException {
	synchronized (lock) {
	    ensureOpen();
	    if (nextChar == 0)
		return;
	    out.write(cb, 0, nextChar);
	    nextChar = 0;
	}
    }

可以看到BufferedWriter做的事情其实就是把一个string转为char数组，然后事情是由

private OutputStreamWriter charOut;

来做的

在这里两者产生关联

 private void init(OutputStreamWriter osw) {
	this.charOut = osw;
	this.textOut = new BufferedWriter(osw);
    }

charOut.flushBuffer();

  void flushBuffer() throws IOException {
	se.flushBuffer();
    }

 public void flushBuffer() throws IOException {
  102           synchronized (lock) {
  103               if (isOpen())
  104                   implFlushBuffer();
  105               else
  106                   throw new IOException("Stream closed");
  107           }
  108       }

再往下就发现调用的是

 out.write(bb.array(), bb.arrayOffset() + pos, rem);

out是OutputStream

再然后就比较纠结了  唉 看代码这么累  后面的部分还是以后再去看了。