扯淡:

　　我觉得不断的重复学习基础才是成长的关键。可能有一天我们拥有几十个框架的经验，可是却一个组件也无法设计一下，应该算不是很好吧。

主题：

知识点：

1.byte 类型

Java byte 类型的取值范围是-128～127

　　byte是1个字节，也就是8位

　　最高位是符号位，其它七位来表示它的值

　　最大的应该是0111 1111，因为第一位是符号位，0表示正数。0111 1111即127

　　负数部分是由补码体现的，补码的是绝对值，取反，加上符号位，加1。

　　-1表示：1000 0001 它的补码是：1111 1111。

　　1000 0000 也就是数字-128。


2，java的IO中衍生出这么多类，主要是因为使用了装饰模式，这种模式是在调用对象的构造函数把被装饰对象传入，利用这样的方式实现的。

具体可以参照：简单的装饰模式解释

3，IO结构可以参照：容易理解的IO图



IO是java基础。

来自《learning java》的图：

java源码中涉及都IO的有很多类，可能是学习的障碍，有时候我会烦恼到底用哪个stream才是正确的呢？这也是本文需要解决的问题：如何去学习IO类呢？

我们来看下IO的基本类图：


我需要牢牢抓住的就是4个主类：InputStream，OutputStream，Reader，Writer，这里我只学习下InputStream，这样OutputStream也可以解决了。

所有在InputStream下面的类都是为了配合一种流，也就可以理解为什么要衍生出这么多类了，毕竟数据流的类型太多了。
来看下InputStream的三个read方法源码：

有一点好记，所有的read方法返回-1就算读完啦。

InputStream 中的read()方法：一个抽象方法，让子类实现去了。

1. public abstract int read() throws IOException;

复制代码

read(byte b[])方法：

1. public int read(byte b[]) throws IOException {
   
2.     // 调用了read(byte b[], int off, int len)
   
3.     return read(b, 0, b.length);
   
4. }

复制代码

read(byte b[], int off, int len)方法：

看下它的API：

将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。
在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。
如果 b 为 null，则抛出 NullPointerException。
如果 off 为负，或 len 为负，或 off+len 大于数组 b 的长度，则抛出 IndexOutOfBoundsException。
如果 len 为 0，则没有字节可读且返回 0；否则，要尝试读取至少一个字节。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。
将读取的第一个字节存储在元素 b[off] 中，下一个存储在 b[off+1] 中，依次类推。读取的字节数最多等于 len。让 k 为实际读取的字节数；这些字节将存储在元素 b[off] 至 b[off+k-1] 之间，其余元素 b[off+k] 至 b[off+len-1] 不受影响。
在任何情况下，元素 b[0] 至 b[off] 和元素 b[off+len] 至 b[b.length-1] 都不会受到影响。
如果不是因为流位于文件末尾而无法读取第一个字节，则抛出 IOException。特别是，如果输入流已关闭，则抛出 IOException。

1. public int read(byte b[], int off, int len) throws IOException {
   
2.     // 对参数进行check，写方法前要确定输入和输出，对于输入的限制是必要的
   
3.     if (b == null) {
   
4.         throw new NullPointerException();
   
5.     } else if ((off < 0) || (off > b.length) || (len < 0) ||
   
6.            ((off + len) > b.length) || ((off + len) < 0)) {
   
7.         throw new IndexOutOfBoundsException();
   
8.     } else if (len == 0) {
   
9.         return 0;
   
10.     }
    
11.     // 内部实现还是使用read()方法一个一个去读的
    
12.     int c = read();
    
13.     if (c == -1) { // 1
    
14.         return -1;
    
15.     }
    
16.     // 第一个放置的位置
    
17.     b[off] = (byte)c;
    
18.     int i = 1;
    
19.     try {
    
20.         for (; i < len ; i++) {
    
21.         c = read();
    
22.         if (c == -1) {// 2
    
23.             break;
    
24.         }
    
25.         if (b != null) {
    
26.             // 第二个以后的就在off后面进位
    
27.             b[off + i] = (byte)c;
    
28.         }
    
29.         }
    
30.     } catch (IOException ee) {
    
31.     }
    
32.     // 返回的是i，举个例子：比如我每次去1024个byte，那么到最后的时候剩下200个byte，
    
33.     // 取到201个的时候，上面的1处判断出来，break;后就返回了i
    
34.     // 需要再一次调用的时候，在1出判断返回-1，才通知没有数据了
    
35.     // 所以呢，如果数据可以分为5段byte数组取，就要进这个方法6次啦。
    
36.     return i;
    
37.     }

复制代码

FileInputStream类用来对付文件流的，可以这么想把它可以把一个文件变成InputStream。

来看下它的read()方法：

1. public native int read() throws IOException;
   

复制代码

好吧，都到native了，（native方法是指本地方法，当在方法中调用一些不是由java语言写的代码或者在方法中用java语言,直接操纵计算机硬件时要声明为native方法，java中，通过JNI(Java Native Interface，java本地接口）来实现本地化）
据说是交给c库实现了...

关于它的使用比较常见吧：

以前写的拷贝的方法：

1. 
   
2.     private void copyFile(String fromPath, String toPath) throws IOException {
   
3.         // input
   
4.         File fromFile = new File(fromPath);
   
5.         InputStream is = new FileInputStream(fromFile);
   
6.         BufferedInputStream bis = new BufferedInputStream(is);
   
7.         // output
   
8.         File toFile = new File(toPath);
   
9.         OutputStream os = new FileOutputStream(toFile);
   
10.         BufferedOutputStream bos = new BufferedOutputStream(os);
    
11.         // transfer station
    
12.         byte b[] = new byte[(int) fromFile.length()];
    
13.         while (bis.read(b, 0, b.length) != -1) {
    
14.             bos.write(b, 0, b.length);
    
15.         }
    
16.         bis.close();
    
17.         bos.close();
    
18.     }

复制代码

DataInputStream类是来对付读取基本 Java 数据类型的。

它有：

1. readBoolean()
   
2. readByte()
   
3. readChar()
   
4. readDouble()
   
5. readFloat()

复制代码

FilterInputStream下面两个重要的派生类：

ByteArrayInputStream是为了把内存中的数据读到字节数组中。

网上共享的代码：是DataInputStream结合ByteArrayInputStream的使用

1. import java.io.ByteArrayInputStream;
   
2. import java.io.ByteArrayOutputStream;
   
3. import java.io.DataInputStream;
   
4. import java.io.DataOutputStream;
   
5. import java.io.IOException;
   
6. 
   
7. public class ByteArrayTest {
   
8.     public static void main(String[] args) throws IOException {
   
9.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
   
10.         DataOutputStream dout = new DataOutputStream(bout);
    
11.         String name = "dc";
    
12.         int age = 94;
    
13.         dout.writeUTF(name);
    
14.         dout.writeInt(age);
    
15.         byte[] buff = bout.toByteArray();// byte数组作为中间值了
    
16.         ByteArrayInputStream bin = new ByteArrayInputStream(buff);
    
17.         DataInputStream dis = new DataInputStream(bin);
    
18.         String newName = dis.readUTF();
    
19.         int newAge = dis.readInt();
    
20.         System.out.println(newName + ":" + newAge);
    
21.     }
    
22. }

复制代码

类似上面一层层包着的感觉提供张图更直观：

我们甚至可以一层层的装饰下去。



BufferedInputStream 可以说是装饰了内存缓存的功能。

总结：

1，通过查看他们的源码，我渐渐明白其实也不是那么复杂，各自的类都有自己的使命，我们只要可以理解他们各自的作用，使用起来就不那么迷茫了。

2，对装饰模式的理解，可以设计出灵活的东西


---------------------------------------------------------------------------------
此贴原出处：cnblogs.com

扯淡:

　　我觉得不断的重复学习基础才是成长的关键。可能有一天我们拥有几十个框架的经验，可是却一个组件也无法设计一下，应该算不是很好吧。

主题：

知识点：

1.byte 类型

Java byte 类型的取值范围是-128～127

　　byte是1个字节，也就是8位

　　最高位是符号位，其它七位来表示它的值

　　最大的应该是0111 1111，因为第一位是符号位，0表示正数。0111 1111即127

　　负数部分是由补码体现的，补码的是绝对值，取反，加上符号位，加1。

　　-1表示：1000 0001 它的补码是：1111 1111。

　　1000 0000 也就是数字-128。


2，java的IO中衍生出这么多类，主要是因为使用了装饰模式，这种模式是在调用对象的构造函数把被装饰对象传入，利用这样的方式实现的。

具体可以参照：简单的装饰模式解释

3，IO结构可以参照：容易理解的IO图



IO是java基础。

来自《learning java》的图：

java源码中涉及都IO的有很多类，可能是学习的障碍，有时候我会烦恼到底用哪个stream才是正确的呢？这也是本文需要解决的问题：如何去学习IO类呢？

我们来看下IO的基本类图：


我需要牢牢抓住的就是4个主类：InputStream，OutputStream，Reader，Writer，这里我只学习下InputStream，这样OutputStream也可以解决了。

所有在InputStream下面的类都是为了配合一种流，也就可以理解为什么要衍生出这么多类了，毕竟数据流的类型太多了。
来看下InputStream的三个read方法源码：

有一点好记，所有的read方法返回-1就算读完啦。

InputStream 中的read()方法：一个抽象方法，让子类实现去了。

1. public abstract int read() throws IOException;

复制代码

read(byte b[])方法：

1. public int read(byte b[]) throws IOException {
   
2.     // 调用了read(byte b[], int off, int len)
   
3.     return read(b, 0, b.length);
   
4. }

复制代码

read(byte b[], int off, int len)方法：

看下它的API：

将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。
在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。
如果 b 为 null，则抛出 NullPointerException。
如果 off 为负，或 len 为负，或 off+len 大于数组 b 的长度，则抛出 IndexOutOfBoundsException。
如果 len 为 0，则没有字节可读且返回 0；否则，要尝试读取至少一个字节。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。
将读取的第一个字节存储在元素 b[off] 中，下一个存储在 b[off+1] 中，依次类推。读取的字节数最多等于 len。让 k 为实际读取的字节数；这些字节将存储在元素 b[off] 至 b[off+k-1] 之间，其余元素 b[off+k] 至 b[off+len-1] 不受影响。
在任何情况下，元素 b[0] 至 b[off] 和元素 b[off+len] 至 b[b.length-1] 都不会受到影响。
如果不是因为流位于文件末尾而无法读取第一个字节，则抛出 IOException。特别是，如果输入流已关闭，则抛出 IOException。

1. public int read(byte b[], int off, int len) throws IOException {
   
2.     // 对参数进行check，写方法前要确定输入和输出，对于输入的限制是必要的
   
3.     if (b == null) {
   
4.         throw new NullPointerException();
   
5.     } else if ((off < 0) || (off > b.length) || (len < 0) ||
   
6.            ((off + len) > b.length) || ((off + len) < 0)) {
   
7.         throw new IndexOutOfBoundsException();
   
8.     } else if (len == 0) {
   
9.         return 0;
   
10.     }
    
11.     // 内部实现还是使用read()方法一个一个去读的
    
12.     int c = read();
    
13.     if (c == -1) { // 1
    
14.         return -1;
    
15.     }
    
16.     // 第一个放置的位置
    
17.     b[off] = (byte)c;
    
18.     int i = 1;
    
19.     try {
    
20.         for (; i < len ; i++) {
    
21.         c = read();
    
22.         if (c == -1) {// 2
    
23.             break;
    
24.         }
    
25.         if (b != null) {
    
26.             // 第二个以后的就在off后面进位
    
27.             b[off + i] = (byte)c;
    
28.         }
    
29.         }
    
30.     } catch (IOException ee) {
    
31.     }
    
32.     // 返回的是i，举个例子：比如我每次去1024个byte，那么到最后的时候剩下200个byte，
    
33.     // 取到201个的时候，上面的1处判断出来，break;后就返回了i
    
34.     // 需要再一次调用的时候，在1出判断返回-1，才通知没有数据了
    
35.     // 所以呢，如果数据可以分为5段byte数组取，就要进这个方法6次啦。
    
36.     return i;
    
37.     }

复制代码

FileInputStream类用来对付文件流的，可以这么想把它可以把一个文件变成InputStream。

来看下它的read()方法：

1. public native int read() throws IOException;
   

复制代码

好吧，都到native了，（native方法是指本地方法，当在方法中调用一些不是由java语言写的代码或者在方法中用java语言,直接操纵计算机硬件时要声明为native方法，java中，通过JNI(Java Native Interface，java本地接口）来实现本地化）
据说是交给c库实现了...

关于它的使用比较常见吧：

以前写的拷贝的方法：

1. 
   
2.     private void copyFile(String fromPath, String toPath) throws IOException {
   
3.         // input
   
4.         File fromFile = new File(fromPath);
   
5.         InputStream is = new FileInputStream(fromFile);
   
6.         BufferedInputStream bis = new BufferedInputStream(is);
   
7.         // output
   
8.         File toFile = new File(toPath);
   
9.         OutputStream os = new FileOutputStream(toFile);
   
10.         BufferedOutputStream bos = new BufferedOutputStream(os);
    
11.         // transfer station
    
12.         byte b[] = new byte[(int) fromFile.length()];
    
13.         while (bis.read(b, 0, b.length) != -1) {
    
14.             bos.write(b, 0, b.length);
    
15.         }
    
16.         bis.close();
    
17.         bos.close();
    
18.     }

复制代码

DataInputStream类是来对付读取基本 Java 数据类型的。

它有：

1. readBoolean()
   
2. readByte()
   
3. readChar()
   
4. readDouble()
   
5. readFloat()

复制代码

FilterInputStream下面两个重要的派生类：

ByteArrayInputStream是为了把内存中的数据读到字节数组中。

网上共享的代码：是DataInputStream结合ByteArrayInputStream的使用

1. import java.io.ByteArrayInputStream;
   
2. import java.io.ByteArrayOutputStream;
   
3. import java.io.DataInputStream;
   
4. import java.io.DataOutputStream;
   
5. import java.io.IOException;
   
6. 
   
7. public class ByteArrayTest {
   
8.     public static void main(String[] args) throws IOException {
   
9.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
   
10.         DataOutputStream dout = new DataOutputStream(bout);
    
11.         String name = "dc";
    
12.         int age = 94;
    
13.         dout.writeUTF(name);
    
14.         dout.writeInt(age);
    
15.         byte[] buff = bout.toByteArray();// byte数组作为中间值了
    
16.         ByteArrayInputStream bin = new ByteArrayInputStream(buff);
    
17.         DataInputStream dis = new DataInputStream(bin);
    
18.         String newName = dis.readUTF();
    
19.         int newAge = dis.readInt();
    
20.         System.out.println(newName + ":" + newAge);
    
21.     }
    
22. }

复制代码

类似上面一层层包着的感觉提供张图更直观：

我们甚至可以一层层的装饰下去。



BufferedInputStream 可以说是装饰了内存缓存的功能。

总结：

1，通过查看他们的源码，我渐渐明白其实也不是那么复杂，各自的类都有自己的使命，我们只要可以理解他们各自的作用，使用起来就不那么迷茫了。

2，对装饰模式的理解，可以设计出灵活的东西


---------------------------------------------------------------------------------
此贴原出处：cnblogs.com