那在JDK中体现最明显的,就是JAVA IO方面的一些类,那在JAVA IO中,我们为了增加缓存,我们使用BufferedReader,
那现在我们来看一下,那因为增加缓存的功能,类有很多,子类也就需要很多,那现在我们看一下,BufferedReader
public class BufferedReader extends Reader
看一下,他首先继承了Reader,进来
public abstract class Reader implements Readable, Closeable
是一个抽象类,接着回来,然后BufferedReader把Reader放到自己的类中,是in
private Reader in;
public BufferedReader(Reader in, int sz) {
super(in);
if (sz <= 0)
throw new IllegalArgumentException("Buffer size <= 0");
this.in = in;
cb = new char[sz];
nextChar = nChars = 0;
}
通过Reader来构造BufferedReader,现在我们来类比一下,抽象的煎饼,抽象的装饰者,构造的时候,用抽象的煎饼来构造他,
和这里是一致的,正因为在JDK中的JAVA IO,采用了装饰者模式,我们可以无限次的进行装饰转换,转换的目标啊,就是为了
得到我们想要的数据类型流对象,
class BufferedInputStream extends FilterInputStream
同理BufferedInputStream也是一样的,
class BufferedOutputStream extends FilterOutputStream
这两个类我们只做一个,首先它继承FilterInputStream,而FilterInputStream又继承FilterInputStream,
class FilterInputStream extends InputStream
那InputStream是一个抽象类,
public abstract class InputStream implements Closeable
接着回来,看一下BufferedInputStream他的构造器,这里有两个,随便看一个就可以,
public BufferedInputStream(InputStream in) {
this(in, DEFAULT_BUFFER_SIZE);
}
public BufferedInputStream(InputStream in, int size) {
super(in);
if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
传入的InputStream,是BufferedInputStream父类的父类,我们看一下fill这个方法,在这个fill这个方法中,
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0; /* no mark: throw away the buffer */
else if (pos >= buffer.length) /* no room left in buffer */
if (markpos > 0) { /* can throw away early part of the buffer */
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
} else if (buffer.length >= marklimit) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
} else if (buffer.length >= MAX_BUFFER_SIZE) {
throw new OutOfMemoryError("Required array size too large");
} else { /* grow buffer */
int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
pos * 2 : MAX_BUFFER_SIZE;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
// Can't replace buf if there was an async close.
// Note: This would need to be changed if fill()
// is ever made accessible to multiple threads.
// But for now, the only way CAS can fail is via close.
// assert buf == null;
throw new IOException("Stream closed");
}
buffer = nbuf;
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
就实现读取流数据,我们再 看一下FileInputStream
class FilterInputStream extends InputStream
那这里的方法相对简单一些,我们看几个关键的,首先是构造器,传入File,然后装饰成FileInputStream,
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.attach(this);
path = name;
open(name);
}
那FileInputStream的父类,我们看一下,InputStream是抽象类,我们现在来看一下他的UML,他有很多子类,
这里面有超多的子类,我们看一下FilterInputStream,再打开几个实现,为了更好地对比,这里面打开三个,
然后我们看一下FilterInputStream他的子类也有很多,例如刚刚讲的BufferedInputStream,还有DataInputStream,
还有很多,比如LineInputStream,那我们可以看到在装饰者模式中,我们的类是非常的多,但是FilterInputStream,
是一个装饰者下面都是实际的装饰者,还有一些类我们就不显示到这里了,那Reader和Writer流中
快速高效用：SET SQL_SAFE_UPDATES = 0；下面的就不要看了！
今日用MySQL Workbench进行数据库的管理更新时，执行一个更新的语句碰到以下错误提示：
Error Code: 1175
You are using safe update mode and you tried to update a table without a WHERE that
Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
Note:You may assume that nums1 has enough space (size that is
