Java编程思想：NIO知识点

import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.util.*;

public class Test {
    public static void main(String[] args) {
//        GetChannel.test();
//        BufferToText.test();
//        AvailableCharSets.test();
//        GetData.test();
//        IntBufferDemo.test();
//        ViewBuffers.test();
//        Endians.test();
//        UsingBuffers.test();
        LargeMapperFiles.test();
    }
}

/*
    将字节存放在ByteBuffer的方法：
        1.通过put方法直接对它们进行填充，填入一个或多个字节，或基本数据类型
        2.通过warp方法将已存在的字节数组包装到ByteBuffer中，一旦如此，就不需要复制
        底层的数组，而是把它作为所产生的ByteBuffer的存储器，称之为数组支持的ByteBuff。
 */

/*
    1.对于只读操作，需要显示静态的allocate方法来分配ByteBuffer
    2.对于read方法，调用read告知FileChannel向ByteBuffer存储字节后，需要调用缓冲器上
    的flip，让它做好让别人读取字节的准备。
    3.对于read方法，如果我们打算用缓冲器执行进一步的read操作，则我们必须调用clear方法
    来为每一个read做好准备
 */

class GetChannel {
    private static final int BSIZE = 1024;

    public static void test() {
        try {
            //FileOutputStream测试
            FileChannel fc1 = new FileOutputStream("./src/data").getChannel();
            fc1.write(ByteBuffer.wrap("Some test".getBytes()));
            fc1.close();

            //FileInputStream测试
            FileChannel fc2 = new FileInputStream("./src/data").getChannel();
            ByteBuffer buff = ByteBuffer.allocate(BSIZE);
            fc2.read(buff);
            buff.flip();
            /*
                这个地方和下一个案例的需求是不同的：
                    这个案例中我需要将buff中的数据一个一个字符的打印出出来，get方法
                    就像迭代器中的next方法，每次调用时都会向后移动一个位置：
                       while (buff.hasRemaining())
                            System.out.println((char)buff.get());

                    下一个案例中，是从文件中读取，当文件所有内容都被读取后，调用read
                    放法，就会在buffer中存入一个-1的值：
                       while (fc1.read(buffer) != -1) {
                            buffer.flip();
                            fc2.write(buffer);
                            buffer.clear();
            }
            }
             */
            while (buff.hasRemaining()) {
                System.out.println((char)buff.get());
            }

            //RandomAccessFile测试
            FileChannel fc3 = new RandomAccessFile("./src/data","rw").getChannel();
            fc3.position(fc3.size());
            fc3.write(ByteBuffer.wrap("Some more".getBytes()));
            fc3.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ChannelCopy {
    private static final int BSIZE = 1024;

    public static void test() {
        try{
            FileChannel fc1 = new FileInputStream("./src/data").getChannel();
            FileChannel fc2 = new FileOutputStream("./src/data").getChannel();

            ByteBuffer buffer = ByteBuffer.allocate(BSIZE);

            /*
                FileChannel和ByteBuffer的使用逻辑：
                    1.得到FileChannel，也就是书中说的煤矿
                    2.建立ByteBuffer，也就是书中说的卡车
                    3.通知煤矿向卡车转载货物
                    4.使用卡车中的货物
                    5.清空卡车中的货物
             */
            while (fc1.read(buffer) != -1) {
                buffer.flip();
                fc2.write(buffer);
                buffer.clear();
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/*
    上一个案例并不是理想的使用方式，transferTo和transferFrom则允许我们将一个通道与
    另一个通道直接相连
 */
class TransferTo{
    public static void test() {
        try{
            FileChannel in = new FileInputStream("./src/data").getChannel();
            FileChannel out = new FileOutputStream("./src/data").getChannel();

            //将in中的位置为0，长度为in.size()的数据移动到out这个通道中
            in.transferTo(0,in.size(),out);

            //将in中的位置为0，长度为in.size()的数据移动到out这个通道中
            out.transferFrom(in,0,in.size());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class BufferToText {
    private static final int BSIZE = 1024;
    public static void test() {

        try {
            //第一步，打开一个文件向里面写点东西
            FileChannel fc1 = new FileOutputStream("./src/data1").getChannel();
            fc1.write(ByteBuffer.wrap("some text".getBytes()));
            fc1.close();

            //第二步，读取这个文件，尝试使用buffer的asCharBuffer进行输出
            FileChannel fc2 = new FileInputStream("./src/data1").getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(BSIZE);
            fc2.read(buffer);
            buffer.flip();
            System.out.println("buffer.asCharBuffer(): "+buffer.asCharBuffer());

            //第三步，使用系统默认的方式解码
            buffer.rewind(); //移动光标到开始部分
            String encoding = System.getProperty("file.encoding");
            System.out.println("encoding: "+encoding);
            System.out.println("Decode use "+encoding+" :"+Charset.forName(encoding).decode(buffer));

            //第四步，写入东西时指定编码方式
            FileChannel fc3 = new FileOutputStream("./src/data2").getChannel();
            fc3.write(ByteBuffer.wrap("some text".getBytes("UTF-16BE")));
            fc3.close();

            //第五步，将写入的东西读出来
            FileChannel fc4 = new FileInputStream("./src/data2").getChannel();
            ByteBuffer buffer4 = ByteBuffer.allocate(BSIZE);
            fc4.read(buffer4);
            buffer4.flip();
            System.out.println("buffer4.asCharBuffer(): "+buffer4.asCharBuffer());

            //第六步，使用CharBuffer进行写
            FileChannel fc5 = new FileOutputStream("./src/data2").getChannel();
            ByteBuffer buffer5 = ByteBuffer.allocate(24);
            buffer5.asCharBuffer().put("some Text");
            fc5.write(buffer5);
            fc5.close();

            //第七步，将写入的内容读出来
            FileChannel fc6 = new FileInputStream("./src/data2").getChannel();
            ByteBuffer buffer6 = ByteBuffer.allocate(BSIZE);
            fc6.read(buffer6);
            buffer6.flip();
            System.out.println("buffer6.asCharBuffer(): "+buffer6.asCharBuffer());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class AvailableCharSets {
    public static void test() {
        SortedMap<String,Charset> charset = Charset.availableCharsets();

        Iterator<String> iter_name = charset.keySet().iterator();
        while (iter_name.hasNext()) {
            String charsetName = iter_name.next();
            System.out.print(charsetName);

            Set<String> aliases= charset.get(charsetName).aliases();
            Iterator<String> iter_alia = aliases.iterator();

            if(iter_alia.hasNext())
                System.out.print(":");

            while (iter_alia.hasNext()) {
                System.out.print(iter_alia.next()+"  ");
            }

            System.out.println("");
        }
    }
}

class GetData{
    private static final int BSIZE = 1024;

    public static void test() {
        ByteBuffer b = ByteBuffer.allocate(BSIZE);

        //b在创建是会自动分配0
        int i = 0;
        while (i++ < b.limit()) {
            if (b.get() != 0) {
                System.out.println("not zero.");
            }
        }
        System.out.println("i = "+i);

        //存储并读取一个char
        b.rewind();
        b.asCharBuffer().put("Hello");
        char c;
        while ((c = b.getChar()) != 0) {
            System.out.print(c);
        }
        System.out.println();

        //存储并读取一个short
        b.rewind();
        b.asShortBuffer().put((short) 471142);
        System.out.println("b.getShort(): "+b.getShort());

        //存储并读取一个int
        b.rewind();
        b.asIntBuffer().put(992341);
        System.out.println("b.getInt(): "+b.getInt());

        //存储并读取一个long
        b.rewind();
        b.asLongBuffer().put(234141532234L);
        System.out.println("b.getLong(): "+b.getLong());

        //存储并读取一个float
        b.rewind();
        b.asFloatBuffer().put(23414.134f);
        System.out.println("b.getFloat(): "+b.getFloat());

        //存储并读取一个double
        b.rewind();
        b.asDoubleBuffer().put(234.1432234);
        System.out.println("b.getDouble(): "+b.getDouble());

    }
}

class IntBufferDemo{
    private static final int BSIZE = 1024;
    public static void test() {
        ByteBuffer b = ByteBuffer.allocate(BSIZE);
        IntBuffer ib = b.asIntBuffer();

        ib.put(new int[]{1,2,3,4,5});
        System.out.println(ib.get(3));
        System.out.println(ib.get(4));

        ib.put(3, 100);
        System.out.println(ib.get(3));
        System.out.println(ib.get(4));

        System.out.println("Setting a new limit before rewinding the buffer");
        ib.flip();
        while (ib.hasRemaining()) {
            int i = ib.get();
            System.out.println(i);
        }
    }
}

class ViewBuffers {
    public static void test() {
        ByteBuffer b = ByteBuffer.wrap(new byte[]{0,0,0,0,0,0,0,'a'});

        b.rewind();
        System.out.println("ByteBuffer:");
        while (b.hasRemaining()) {
            System.out.println(b.position()+"-->"+b.get()+".");
        }

        b.rewind();
        CharBuffer cb = b.asCharBuffer();
        System.out.println("CharBuffer:");
        while (cb.hasRemaining()) {
            System.out.println(cb.position()+"-->"+cb.get()+".");
        }
    }
}

class Endians {
    public static void test() {
        ByteBuffer b = ByteBuffer.wrap(new byte[12]);
        b.asCharBuffer().put("abcdef");
        System.out.println(Arrays.toString(b.array()));

        b.rewind();
        b.order(ByteOrder.BIG_ENDIAN);
        b.asCharBuffer().put("abcdef");
        System.out.println(Arrays.toString(b.array()));

        b.rewind();
        b.order(ByteOrder.LITTLE_ENDIAN);
        b.asCharBuffer().put("abcdef");
        System.out.println(Arrays.toString(b.array()));
    }
}

class UsingBuffers {
    private static void symmetricScramble(CharBuffer buffer) {
        while (buffer.hasRemaining()) {
            buffer.mark();
            char c1 = buffer.get();
            char c2 = buffer.get();
            buffer.reset();
            buffer.put(c2).put(c1);
        }
    }

    public static void test() {
        char[] data = "UsingBuffers".toCharArray();
        ByteBuffer bb = ByteBuffer.allocate(data.length * 2);
        CharBuffer cb = bb.asCharBuffer();
        cb.put(data);

        System.out.println(cb.rewind());
        symmetricScramble(cb);
        System.out.println(cb.rewind());
        symmetricScramble(cb);
        System.out.println(cb.rewind());
    }
}

class LargeMapperFiles {
    private static final int length = 0X8FFFFFF; //128 MB

    public static void test() {
        try {
            MappedByteBuffer out = new RandomAccessFile("./src/data", "rw")
                    .getChannel()
                    .map(FileChannel.MapMode.READ_WRITE, 0,length);

            for (int i = 0; i < length; i++) {
                out.put((byte)'x');
            }

            System.out.println("Finished writing...");

            for (int i = length / 2; i < length / 2 + 6; i++) {
                System.out.println((char)out.get(i));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}