IO流与NIO流

JAVA IO流最详解

 

（转自CSDN）

IO流上：概述、字符流、缓冲区(java基础)

 

一、IO流概述

概述：

IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，Java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。

分类：

按操作数据分为：字节流和字符流。 如：Reader和InpurStream

按流向分：输入流和输出流。如：InputStream和OutputStream

IO流常用的基类：

* InputStream    ，    OutputStream

字符流的抽象基类：

* Reader       ，         Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀：

如：FileReader和FileInputStream

二、字符流

1. 字符流简介：

* 字符流中的对象融合了编码表，也就是系统默认的编码表。我们的系统一般都是GBK编码。

* 字符流只用来处理文本数据，字节流用来处理媒体数据。

* 数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter。

2.字符流读写：

注意事项：

* 写入文件后必须要用flush()刷新。

* 用完流后记得要关闭流

* 使用流对象要抛出IO异常

* 定义文件路径时，可以用“/”或者“\\”。

* 在创建一个文件时，如果目录下有同名文件将被覆盖。

* 在读取文件时，必须保证该文件已存在，否则出异常

示例1：在硬盘上创建一个文件,并写入一些文字数据

1. class FireWriterDemo {
2. public static void main(String[] args) throws IOException {             //需要对IO异常进行处理
3. //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
4. //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。
5. FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。
6. //调用write的方法将字符串写到流中
7. fw.write("hello world!");
8. //刷新流对象缓冲中的数据，将数据刷到目的地中
9. fw.flush();
10. //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();
11. fw.write("first_test");
12. fw.close();
13. //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。
14. }
15. }

示例2：FileReader的reade()方法.

要求：用单个字符和字符数组进行分别读取

1. class FileReaderDemo {
2. public static void main(String[] args) {
3. characters();
4. }
5. /*****************字符数组进行读取*********************/
6. private static void characters() {
7. try {
8. FileReader fr = new FileReader("Demo.txt");
9. char []  buf = new char[6];
10. //将Denmo中的文件读取到buf数组中。
11. int num = 0;
12. while((num = fr.read(buf))!=-1) {
13. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
14. sop(new String(buf,0,num));
15. }
16. sop('\n');
17. fr.close();
18. }
19. catch (IOException e) {
20. sop(e.toString());
21. }
22. }
23. /*****************单个字母读取*************************/
24. private static void singleReader() {
25. try {
26. //创建一个文件读取流对象，和指定名称的文件关联。
27. //要保证文件已经存在，否则会发生异常：FileNotFoundException
28. FileReader fr = new FileReader("Demo.txt");
29. //如何调用读取流对象的read方法？
30. //read()方法，一次读取一个字符，并且自动往下读。如果到达末尾则返回-1
31. int ch = 0;
32. while ((ch=fr.read())!=-1) {
33. sop((char)ch);
34. }
35. sop('\n');
36. fr.close();
37. /*int ch = fr.read();
38. sop("ch=" + (char)ch);
39. int ch2 = fr.read();
40. sop("ch2=" + (char)ch2);
41. //使用结束注意关闭流
42. fr.close(); */
43. }
44. catch (IOException e) {
45. sop(e.toString());
46. }
47. }
48. /**********************Println************************/
49. private static void sop(Object obj) {
50. System.out.print(obj);
51. }
52. }

示例3：对已有文件的数据进行续写

1. import java.io.*;
2. class  FileWriterDemo3 {
3. public static void main(String[] args) {
4. try {
5. //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
6. FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);
7. fw.write(" is charactor table?");
8. fw.close();
9. }
10. catch (IOException e) {
11. sop(e.toString());
12. }
13. }
14. /**********************Println************************/
15. private static void sop(Object obj)
16. {
17. System.out.println(obj);
18. }
19. }

练习：

将F盘的一个文件复制到E盘。

思考：

其实就是将F盘下的文件数据存储到D盘的一个文件中。

步骤：

1.在D盘创建一个文件，存储F盘中文件的数据。
2.定义读取流和F：盘文件关联。
3.通过不断读写完成数据存储。
4.关闭资源。

源码：

1. import java.io.*;
2. import java.util.Scanner;
3. class CopyText {
4. public static void main(String[] args) throws IOException {
5. sop("请输入要拷贝的文件的路径:");
6. Scanner in = new Scanner(System.in);
7. String source = in.next();
8. sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");
9. String destination = in.next();
10. in.close();
11. CopyTextDemo(source,destination);
12. }
13. /*****************文件Copy*********************/
14. private static void CopyTextDemo(String source,String destination) {
15. try {
16. FileWriter fw = new FileWriter(destination);
17. FileReader fr = new FileReader(source);
18. char []  buf = new char[1024];
19. //将Denmo中的文件读取到buf数组中。
20. int num = 0;
21. while((num = fr.read(buf))!=-1) {
22. //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
23. fw.write(new String(buf,0,num));
24. }
25. fr.close();
26. fw.close();
27. }
28. catch (IOException e) {
29. sop(e.toString());
30. }
31. }
32. /**********************Println************************/
33. private static void sop(Object obj) {
34. System.out.println(obj);
35. }
36. }

三、缓冲区

1. 字符流的缓冲区：BufferedReader和BufferedWreiter

* 缓冲区的出现时为了提高流的操作效率而出现的.

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader示例：

读取流缓冲区提供了一个一次读一行的方法readline，方便对文本数据的获取。
readline()只返回回车符前面的字符，不返回回车符。如果是复制的话，必须加入newLine()，写入回车符

newLine()是java提供的多平台换行符写入方法。

1. import java.io.*;
2. class BufferedReaderDemo {
3. public static void main(String[] args)  throws IOException {
4. //创建一个字符读取流流对象，和文件关联
5. FileReader rw = new FileReader("buf.txt");
6. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
7. BufferedReader brw = new BufferedReader(rw);
8. for(;;) {
9. String s = brw.readLine();
10. if(s==null) break;
11. System.out.println(s);
12. }
13. brw.close();//关闭输入流对象
14. }
15. }

BufferedWriter示例：

1. import java.io.*;
2. class BufferedWriterDemo {
3. public static void main(String[] args)  throws IOException {
4. //创建一个字符写入流对象
5. FileWriter fw = new FileWriter("buf.txt");
6. //为了提高字符写入效率，加入了缓冲技术。
7. //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
8. BufferedWriter bfw = new BufferedWriter(fw);
9. //bfw.write("abc\r\nde");
10. //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
11. //用到缓冲区就必须要刷新
12. for(int x = 1; x < 5; x++) {
13. bfw.write("abc");
14. bfw.newLine();                  //java提供了一个跨平台的换行符newLine();
15. bfw.flush();
16. }
17. bfw.flush();                                                //刷新缓冲区
18. bfw.close();                                                //关闭缓冲区，但是必须要先刷新
19. //注意，关闭缓冲区就是在关闭缓冲中的流对象
20. fw.close();                                                 //关闭输入流对象
21. }
22. }

2.装饰设计模式

装饰设计模式：：：：

要求：自定义一些Reader类，读取不同的数据(装饰和继承的区别)
MyReader //专门用于读取数据的类
    |--MyTextReader
        |--MyBufferTextReader
    |--MyMediaReader
        |--MyBufferMediaReader
    |--MyDataReader
        |--MyBufferDataReader

如果将他们抽取出来，设计一个MyBufferReader，可以根据传入的类型进行增强
class MyBufferReader {

MyBufferReader (MyTextReader text) {}
    MyBufferReader (MyMediaReader media) {}
    MyBufferReader (MyDataReader data) {}
}

但是上面的类拓展性很差。找到其参数的共同类型，通过多态的形式，可以提高拓展性

class MyBufferReader  extends MyReader{
    private MyReader r;                        //从继承变为了组成模式  装饰设计模式
    MyBufferReader(MyReader r) {}
}

优化后的体系：
    |--MyTextReader
    |--MyMediaReader
    |--MyDataReader
    |--MyBufferReader        //增强上面三个。装饰模式比继承灵活，
                              避免继承体系的臃肿。降低类与类之间的耦合性

装饰类只能增强已有的对象，具备的功能是相同的。所以装饰类和被装饰类属于同一个体系

MyBuffereReader类：  自己写一个MyBuffereReader类，功能与BuffereReader相同

1. class MyBufferedReader1  extends Reader{
2. private Reader r;
3. MyBufferedReader1(Reader r){
4. this.r  = r;
5. }
6. //一次读一行数据的方法
7. public String myReaderline()  throws IOException {
8. //定义一个临时容器，原BufferReader封装的是字符数组。
9. //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串
10. StringBuilder sb = new StringBuilder();
11. int ch = 0;
12. while((ch = r.read()) != -1)
13. {
14. if(ch == '\r')
15. continue;
16. if(ch == '\n')                    //遇到换行符\n,返回字符串
17. return sb.toString();
18. else
19. sb.append((char)ch);
20. }
21. if(sb.length()!=0)                    //当最后一行不是以\n结束时候，这里需要判断
22. return sb.toString();
23. return null;
24. }
25. /*
26. 需要覆盖Reader中的抽象方法close()，read();
27. */
28. public void close()throws IOException {
29. r.close();
30. }
31. public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法
32. return r.read(cbuf,off,len);
33. }
34. public void myClose() throws IOException{
35. r.close();
36. }
37. }

 

一、字节流

1.概述：

1、字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。

2、字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）

3、读写字节流：InputStream   输入流（读）和OutputStream  输出流（写）

4、字节流操作可以不用刷新流操作。

5、InputStream特有方法：

int available();//返回文件中的字节个数

注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

练习：

需求：复制一张图片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

1. import java.io.*;
2. class CopyPic {
3. public static void main(String[] args){
4. copyBmp();
5. System.out.println("复制完成");
6. }
7. public static void copyBmp() {
8. FileInputStream fis = null;
9. FileOutputStream fos = null;
10. try {
11. fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp");             //写入流关联文件
12. fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp");            //读取流关联文件
13. byte[] copy = new byte[1024];
14. int len = 0;
15. while((len=fis.read(copy))!=-1) {
16. fos.write(copy,0,len);
17. }
18. }
19. catch (IOException e) {
20. e.printStackTrace();
21. throw new RuntimeException("复制文件异常");
22. }
23. finally {
24. try {
25. if(fis!=null) fis.close();
26. }
27. catch (IOException e) {
28. e.printStackTrace();
29. throw new RuntimeException("读取流");
30. }
31. }
32. }
33. }

2. 字节流缓冲区

* 字节流缓冲区跟字符流缓冲区一样，也是为了提高效率。

注意事项：

1. read()：会将字节byte()提升为int型值

2. write()：会将int类型转换为byte()类型，保留最后的8位。

练习：

1.复制MP3文件   1.MP3 -->  2.MP3

2.自己写一个MyBufferedInputStream缓冲类，提升复制速度

代码：

1. import java.io.*;
2. //自己的BufferedInputStream
3. class MyBufferedInputStream  {
4. private InputStream in;                         //定义一个流对象
5. private byte [] buf = new byte[1024*4];
6. private int count = 0,pos = 0;
7. public MyBufferedInputStream(InputStream in){
8. this.in = in;
9. }
10. public  int MyRead() throws IOException{
11. if(count==0) {              //当数组里的数据为空时候，读入数据
12. count = in.read(buf);
13. pos = 0;
14. byte b = buf[pos];
15. count--;
16. pos++;
17. return b&255;       //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111
18. }
19. else if(count > 0) {
20. byte b = buf[pos];
21. pos++;
22. count--;
23. return b&0xff;      //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111
24. }
25. return -1;
26. }
27. public void myClose() throws IOException{
28. in.close();
29. }
30. }
31. class BufferedCopyDemo {
32. public static void main(String[] args) {
33. long start = System.currentTimeMillis();
34. copy();
35. long end = System.currentTimeMillis();
36. System.out.println("时间:"+(end-start)+"ms");
37. start = System.currentTimeMillis();
38. copy1();
39. end = System.currentTimeMillis();
40. System.out.println("时间:"+(end-start)+"ms");
41. }
42. public static void copy1() {                //    应用自己的缓冲区缓冲数据
43. MyBufferedInputStream bis = null;
44. BufferedOutputStream  bos = null;
45. try {
46. bis = new MyBufferedInputStream(new FileInputStream("马旭东-入戏太深.mp3"));//匿名类，传入一个InputStream流对象
47. bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));
48. int buf = 0;
49. while((buf=bis.MyRead())!=-1) {
50. bos.write(buf);
51. }
52. }
53. catch (IOException e) {
54. e.printStackTrace();
55. throw new RuntimeException("复制失败");
56. }
57. finally {
58. try {
59. if(bis!=null)  {
60. bis.myClose();
61. bos.close();
62. }
63. }
64. catch (IOException e) {
65. e.printStackTrace();
66. }
67. }
68. }
69. }

二、流操作规律

1. 键盘读取，控制台打印。

System.out: 对应的标准输出设备：控制台  //它是PrintStream对象，（PrintStream：打印流。OutputStream的子类）

System.in: 对应的标准输入设备：键盘     //它是InputStream对象

示例：

1. /*================从键盘录入流，打印到控制台上================*/
2. public static void InOutDemo(){
3. //键盘的最常见的写法
4. BufferedReader bufr = null;
5. BufferedWriter bufw = null;
6. try {
7. /*InputStream ips = System.in;        //从键盘读入输入字节流
8. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流
9. bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率
10. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符
11. bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要写入流中的字符编码成字节
12. String line = null;
13. while((line = bufr.readLine())!=null){
14. if("over".equals(line)) break;
15. bufw.write(line.toUpperCase());                     //打印
16. bufw.newLine();                                     //为了兼容，使用newLine()写入换行符
17. bufw.flush();                                       //必须要刷新。不然不会显示
18. }
19. if(bufw!=null) {
20. bufr.close();
21. bufw.close();
22. }
23. }
24. catch (IOException e) {
25. e.printStackTrace();
26. }
27. }
28. }

2. 整行录入

1.从键盘录入数据，并存储到文件中。

2. 我们在键盘录入的是时候，read()方法是一个一个录入的，能不能整行的录入呢？这时候我们想到了BufferedReader中ReadLine()方法。

3. 转换流

为了让字节流可以使用字符流中的方法，我们需要转换流。

1. InputStreamReader:字节流转向字符流；

a、获取键盘录入对象。

InputStream in=System.in;

b、将字节流对象转成字符流对象，使用转换流。

InputStreamReaderisr=new InputStreamReader(in);

c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

BufferedReaderbr=new BufferedReader(isr);

//键盘录入最常见写法

BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字符流通向字节流

示例：

1. /*================把键盘录入的数据存到一个文件中==============*/
2. public static void inToFile() {
3. //键盘的最常见的写法
4. BufferedReader bufr = null;
5. BufferedWriter bufw = null;
6. try {
7. /*InputStream ips = System.in;        //从键盘读入输入字节流
8. InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流
9. bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率
10. bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符
11. bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要写入流中的字符编码成字节
12. String line = null;
13. while((line = bufr.readLine())!=null){
14. if("over".equals(line)) break;
15. bufw.write(line.toUpperCase());                     //打印
16. bufw.newLine();                                     //为了兼容，使用newLine()写入换行符
17. bufw.flush();                                       //必须要刷新。不然不会显示
18. }
19. if(bufw!=null) {
20. bufr.close();
21. bufw.close();
22. }
23. }
24. catch (IOException e) {
25. e.printStackTrace();
26. }
27. }

4. 流操作基本规律

为了控制格式我将其写入了Java代码段中，如下：

示例1：文本 ~ 文本

1. /*
2. 流操作的基本规律。
3. 一、两个明确：(明确体系)
4. 1. 明确源和目的
5. 源：输入流  InputStream  Reader
6. 目的：输出流  OutputStream Writer
7. 2. 操作的数据是否是纯文本
8. 是： 字符流
9. 否： 字节流
10. 二、明确体系后要明确具体使用的对象
11. 通过设备区分：内存，硬盘，键盘
12. 目的设备：内存，硬盘，控制台
13. 示例1：将一个文本文件中的数据存储到另一个文件中: 复制文件
14. 一、明确体系
15. 源：文件-->读取流-->(InputStream和Reader)
16. 是否是文本：是-->Reader
17. 目的：文件-->写入流-->(OutputStream Writer)
18. 是否纯文本：是-->Writer
19. 二、 明确设备
20. 源：Reader
21. 设备：硬盘上一个文本文件 --> 子类对象为：FileReader
22. FileReader fr = new FileReader("Goods.txt");
23. 是否提高效率：是-->加入Reader中的缓冲区：BufferedReader
24. BufferedReader bufr = new BufferedReader(fr);
25. 目的：Writer
26. 设备：键盘上一个文本文件 --> 子类对象：FileWriter
27. FileWriter fw = new FileWriter("goods1.txt");
28. 是否提高效率：是-->加入Writer的缓冲区：BufferedWriter
29. BufferedWriter bufw = new BufferedWriter(fw);
30. 示例2：将一个图片文件数据复制到另一个文件中：复制文件
31. 一、明确体系
32. 源：文件-->读取流-->(InputStream和Reader)
33. 是否是文本：否-->InputStream
34. 目的：文件-->写入流-->(OutputStream Writer)
35. 是否纯文本：否-->OutputStream
36. 二、 明确设备
37. 源：InputStream
38. 设备：硬盘上一个媒体文件 --> 子类对象为：FileInputStream
39. FileInputStream fis = new FileInputStream("Goods.txt");
40. 是否提高效率：是-->加入InputStream中的缓冲区：BufferedInputStream
41. BufferedInputStream bufi = new BufferedInputStream(fis);
42. 目的：OutputStream
43. 设备：键盘上一个媒体文件 --> 子类对象：FileOutputStream
44. FileOutputStream fos = new FileOutputStream("goods1.txt");
45. 是否提高效率：是-->加入OutputStream的缓冲区：BufferedOutputStream
46. BufferedOutputStream bufo = new BufferedOutputStream(fw);
47. 示例3：将键盘录入的数据保存到一个文本文件中
48. 一、明确体系
49. 源：键盘-->读取流-->(InputStream和Reader)
50. 是否是文本：是-->Reader
51. 目的：文件-->写入流-->(OutputStream Writer)
52. 是否纯文本：是-->Writer
53. 二、 明确设备
54. 源：InputStream
55. 设备：键盘 --> 对用对象为：System.in --> InputStream
56. 为了操作方便，转成字符流Reader --> 使用Reader中的转换流：InputStreamReader
57. InputStreamReader isr = new InputStreamReader(System.in);
58. 是否提高效率：是-->加入Reader中的缓冲区：BufferedReader
59. BufferedReader bufr = new BufferedReader(isr);
60. 目的：Writer
61. 设备：键盘上一个文本文件 --> 子类对象：FileWriter
62. FileWriter fw = new FileWriter("goods1.txt");
63. 是否提高效率：是-->加入Writer的缓冲区：BufferedWriter
64. BufferedWriter bufw = new BufferedWriter(fw);

5.指定编码表(转换流可以指定编码表)

要求：用UTF-8编码存储一个文本文件

1. import java.io.*;
2. public class IOStreamLaw {
3. /**
4. * @param args
5. */
6. public static void main(String[] args) throws IOException {
7. //键盘的最常见写法
8. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
9. BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));
10. String line = null;
11. while((line=bufr.readLine())!=null){
12. if("over".equals(line)) break;
13. bufw.write(line.toUpperCase());
14. bufw.newLine();
15. bufw.flush();
16. }
17. bufr.close();
18. }
19. }

 

Java NIO流

对于JavaNIO还是不是很了解，之前认为NIO的N是non-block IO的意思，非阻塞；但是原来是New IO的意思。这个新表示的是和原来的BIO而言是一种新的IO吧。NIO的主要特性就是缓冲区，通道，和选择器（这个可能不是）。

Java在JDK1.4版本呢，引入了NIO这个新的api。Sun公司官方说明NIO的特性如下：

1. 为所有的原始类型提供了（Buffer）缓存支持；

2. 字符集编码解码解决方案

3. Channel（通道）：一个新的原始I/O抽象；

4. 支持锁和内存映射文件的文件访问接口；

5. 提供多路（non-blocking）非阻塞式的高伸缩网络I/O。

对于上面的特性，我是不大了解的。不过，不影响，我们继续介绍。

NIO创建的目的是，实现高速的I/O，而无需编写自定义的本机代码。

那NIO大概是怎么做到的呢？它将最耗时的I/O操作转回操作系统，因而可以极大的提高速度。而最耗时的I/O操作是填充和提取缓冲区。

原来的io和现在NIO最重要的区别就是，数据打包和传输的方式。以前是以流，现在是以块的方式处理数据。

之前用流的方式呢，只能一次一个字节的处理数据。一个输入流产生一个字节的数据，而一个输出流则消耗一个字节的数据。这样的好处是，创建过滤器特别容易，可以创建多个过滤器，每个过滤器处理只处理一部分的数据。坏处就是，比较慢。

而NIO用块的方式呢，可以一次一个块的处理数据。每一步的操作都在产生或者消耗一个块，好处是相对于流快得多，坏处是，不够优雅和简单。

缓冲区

然后开始介绍缓冲区，缓冲区就是上面介绍到的NIO的特性第一条，为所有的原始数据都提供了Buffer缓存的支持。它主要是将所有的原始数据放在数组中，以块的形式处理。

而每种缓冲区的类都有四个属性：容量（Capacity），上界（Limit），位置（Position），以及标记（Mark），用于提供关于其所包含的数据元素的信息。

容量：缓冲区能够容纳的数据元素的最大数量，缓冲区创建时确定，永远不能被改变；

上界：缓冲区第一个不能被读或写的元素，或者说，缓冲区现存元素的计数。

位置：下一个要被读或写的元素的索引。该值会自动由相应的get(),put()函数更新；

标记：一个备忘的位置。调用mark()来设定mark=position。调用reset()来设定position = mark；标记在设定前是未定义的undefined。

缓冲区的分类有，ByteBuffer（字节缓冲区），CharBuffer（字符缓冲区），ShortBuffer（短整型缓冲区），IntBuffer（整型缓冲区），LongBuffer（长整型缓冲区），FloatBuffer（单精度浮点缓冲区），DoubleBuffer（双精度浮点缓冲区），就是没有布尔缓冲区。

他们都是抽象类，所以不能实例化，然后他们都继承了Buffer类，所以都有存get(），取set()方法，也都可以通过各自的静态方法allocation，创建缓冲区。该方法是通过warpping将现有的数组包装到缓冲区中来为缓冲区的内容分配空间，或者通过创建现有字节缓冲区的视图来创建。

下面这是一个简单的实例，从上到下，创建一个整型的缓冲区，然后将现有的数组放到该缓冲区中。可以通过put改变数组中的数据，并且由于缓冲区中的数据对数组是可见的，所以改变缓冲区也会改变数据，可以认为是传引用。flip()，由于get()每调用一次，position位置都会改变，本来pos会等于3的，而用flip可以让pos变为0;clear()效果也一样。而duplicate()可以复制一个缓冲区，一模一样，也是传引用，修改哪个都会影响到另一个。

1.  
   import java.nio.IntBuffer;
2.  
   import java.util.Arrays;
3.  
    
4.  
   /**
5.  
   * Created by liuyanling on 2017/6/30.
6.  
   */
7.  
   public class BufferTest {
8.  
   public static void main(String[] args) {
9.  
   //创建缓冲区，并指定大小
10.  
    IntBuffer intBuffer = IntBuffer.allocate(10);
11.  
     
12.  
    //给缓冲区赋值,建立数组
13.  
    int[] intArray = new int[]{3,5,7};
14.  
    intBuffer = intBuffer.wrap(intArray);
15.  
     
16.  
     
17.  
    //修改元素
18.  
    intBuffer.put(0,9);
19.  
     
20.  
    //打印缓冲区数据
21.  
    for(int i=0;i<intBuffer.limit();i++) {
22.  
    System.out.print(intBuffer.get()+"\t");
23.  
    //System.out.print(intBuffer+"\t"); //
24.  
    }
25.  
     
26.  
    System.out.println("\n缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用");
27.  
    //打印原始数组
28.  
    Arrays.stream(intArray).forEach(temp-> System.out.print(temp+"\t"));
29.  
     
30.  
     
31.  
    //intBuffer.flip();//get()会使pos改变,对缓冲区进行反转,将limit=pos;pos=0; (将当前位置给limit,然后变为0)
32.  
    intBuffer.clear();
33.  
    System.out.println(intBuffer);
34.  
     
35.  
    IntBuffer intBuffer2 = intBuffer.duplicate();
36.  
    System.out.println(intBuffer2);
37.  
     
38.  
    intBuffer2.put(0,11);
39.  
     
40.  
    //0 <= mark <= position <= limit <= capacity
41.  
     
42.  
    //打印缓冲区数据
43.  
    for(int i=0;i<intBuffer.limit();i++) {
44.  
    System.out.print(intBuffer.get()+"\t");
45.  
    }
46.  
     
47.  
    System.out.println("\n复制的缓冲区对原来的缓冲区也是可见的;传引用");
48.  
    //打印原始数组
49.  
    for(int i=0;i<intBuffer2.limit();i++) {
50.  
    System.out.print(intBuffer2.get()+"\t");
51.  
    }
52.  
    }
53.  
    }

结果是这样

9	5	7
缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用
9	5	7	java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
11	5	7
复制的缓冲区对原来的缓冲区也是可见的;传引用
11	5	7	

未完待续！