JAVA IO

传统IO流体系

保存用户输入到文件

package io;
import java.io.*;
public class MyFileOutput {
 
    public static void main(String[] args) {
        FileInputStream fin;
        FileOutputStream fout;
        int ch;
        try {
            fin=new FileInputStream(FileDescriptor.in);
            fout=new FileOutputStream("output.txt");
            System.out.println("请输入一行字符:");
            while((ch=fin.read())!='\r')
                fout.write(ch);
            fin.close();
            fout.close();
            System.out.println("文件写入成功！");
        } catch (FileNotFoundException e) {
            System.out.println("不能创建文件!");
        }catch(IOException e){
            System.out.println("输出流有误！");
        }
 
    }
 
}
显示文本文件的内容package io;
import java.io.*;
public class TypeFile {
 
    public static void main(String[] args) {
        FileInputStream fin;
        FileOutputStream fout;
        int ch;
        if(args.length<1){
            System.out.println("请指定文件名！");
            return;
        }
        try {
            fin=new FileInputStream(args[0]);
            fout=new FileOutputStream(FileDescriptor.out);
            while((ch=fin.read())!=-1)
                fout.write(ch);
            fin.close();
            fout.close();
        } catch (FileNotFoundException e) {
            System.out.println("文件没有找到！");
        } catch (IOException e) {
            System.out.println("输入流有误！");
        }
        
    }
 
}
RandomAccessFile类进行文件加密文件加密/解密示例。
package io;
import java.io.*;
public class encrypt {
    private File file; //存储文件对象信息
    byte[] buf;  //缓冲区，存储文件中的所有数据    RandomAccessFile fp;
    //用参数filename指定的文件构造一个filed对象存储
    //同时为缓冲区buf分配与文件长度相等的存储空间
    public encrypt(String filename){
        file=new File(filename);
        buf=new byte[(int)file.length()];
    }
    
    public encrypt(File destfile){
        file = destfile;
        buf = new byte[(int)file.length()];
    }
    
    //按照读写的方式打开文件
    public void openFile()throws FileNotFoundException{
        fp=new RandomAccessFile(file,"rw");
    }
    
    //关闭文件
    public void closeFile()throws IOException{
        fp.close();
    }
    
    //对文件进行加密/解密
    public void coding()throws IOException{
        //将文件内容读到缓冲区中        fp.read(buf);
        //将缓冲区中的内容取反
        for(int i=0;i<buf.length;i++)
            buf[i]=(byte)(~buf[i]);
        //将文件指针定位到文件头部
        fp.seek(0);
        //将缓冲区中的内容写入到文件中        fp.write(buf);
    }
    
    public static void main(String[] args) {
        encrypt oa;
        if(args.length<1){
            System.out.println("你需要指定加密文件的名字！");
            return;
        }
        try {
            oa = new encrypt(args[0]);
            oa.openFile();
            oa.coding();
            oa.closeFile();
            System.out.println("文件加密成功！");
        } catch (FileNotFoundException e) {
            System.out.println("没有找到文件："+args[0]);
        }catch (IOException e){
            System.out.println("文件读写错误:"+args[0]);
        }
        
    }
 
}
Scanner类package io;
import java.util.*;
public class useScanner {
 
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name=in.nextLine();
        System.out.println("请输入你的年龄:");
        int age=in.nextInt();
        System.out.println("请输入你的身高（单位：米）：");
        double height=in.nextDouble();
        System.out.println("姓名："+name+"年龄："+age+"身高："+height);
    }
 
}
从键盘输入package io;
import java.io.*;
public class ReadAndWrite {
 
    public static void main(String[] args) {
        InputStreamReader isr=new InputStreamReader(System.in);
        OutputStreamWriter osr=new OutputStreamWriter(System.out);
        int ch;
        try {
            System.out.print("请输入一行字符：");
            while((ch=isr.read())!='\r')
                osr.write(ch);
            isr.close();
            osr.close();
        } catch (IOException e) {
            System.out.println("输入流有误！");
        }
        
    }
 
}

Java NIO提供了与标准IO不同的IO工作方式：

Channels and Buffers（通道和缓冲区）：标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。
Asynchronous IO（异步IO）：Java NIO可以让你异步的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。
Selectors（选择器）：Java NIO引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。

Java NIO 概述

Java NIO 由以下几个核心部分组成：

Channels
Buffers
Selectors

虽然Java NIO 中除此之外还有很多类和组件，但在我看来，Channel，Buffer 和 Selector 构成了核心的API。其它组件，如Pipe和FileLock，只不过是与三个核心组件共同使用的工具类。因此，在概述中我将集中在这三个组件上。其它组件会在单独的章节中讲到。

Channel 和 Buffer

基本上，所有的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。

Channel和Buffer有好几种类型。下面是JAVA NIO中的一些主要Channel的实现：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

以下是Java NIO里关键的Buffer实现：

ByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

这些Buffer覆盖了你能通过IO发送的基本数据类型：byte, short, int, long, float, double 和 char。

Java NIO 还有个 Mappedyteuffer，用于表示内存映射文件。

Selector

Selector允许单线程处理多个 Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。

要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。

通道（Channel）

Java NIO的通道类似流，但又有些不同：

既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。
通道可以异步地读写。
通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。

正如上面所说，从通道读取数据到缓冲区，从缓冲区写入数据到通道。

缓冲区（Buffer）

数据是从通道读入缓冲区，从缓冲区写入到通道中的。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

Buffer的基本用法

使用Buffer读写数据一般遵循以下四个步骤：

写入数据到Buffer
调用flip()方法
从Buffer中读取数据
调用clear()方法或者compact()方法

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要通过flip()方法将Buffer从写模式切换到读模式。在读模式下，可以读取之前写入到buffer的所有数据。

一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

Buffer的capacity,position和limit

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

为了理解Buffer的工作原理，需要熟悉它的三个属性：

capacity
position
limit

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。

capacity

作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。

position

当你写数据到Buffer中时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1。

当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

limit

在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。写模式下，limit等于Buffer的capacity。

当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

向Buffer中写数据

写数据到Buffer有两种方式：

从Channel写到Buffer。
通过Buffer的put()方法写到Buffer里。

从Buffer中读取数据

从Buffer中读取数据有两种方式：

从Buffer读取数据到Channel。
使用get()方法从Buffer中读取数据。

NIO代码

public void selector() throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Selector selector = Selector.open();
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.socket().bind(new InetSocketAddress(8080));
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            Set selectedKeys = selector.selectedKeys();
            Iterator it = selectedKeys.iterator();
            while (it.hasNext()) {
                SelectionKey key = (SelectionKey) it.next();
                if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
                    ServerSocketChannel ssChannel = (ServerSocketChannel) key.channel();
                    SocketChannel sc = ssChannel.accept();
                    sc.configureBlocking(false);
                    sc.register(selector, SelectionKey.OP_READ);
                }
                else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
                    SocketChannel sc = (SocketChannel) key.channel();
                    while (true) {
                        buffer.clear();
                        int n = sc.read(buffer);
                        if (n <= 0) {
                            break;
                        }
                        buffer.flip();
                    }
                }
                it.remove();
            }
        }
    }

NIO FileChannel

NIO提供了比传统的文件访问更好的访问方法，NIO有两个优化的方法：一个是 FIleChannel.transferTo FileChannel.transferFrom，另一个是FileChannel.map，均提供了数据在内核空间的直接移动，减少了内核空间和用户空间的复制损耗

下面是FileChannel.map使用示例：

    public static void main(String[] args) {
        int BUFFER_SIZE = 1024;
        String filename = "teset.db";
        long fileLength = new File(filename).length();
        int bufferCount = 1 + (int) fileLength / BUFFER_SIZE;
        MappedByteBuffer[] buffers = new MappedByteBuffer[bufferCount];
        long remaining = fileLength;
        for (int i=0; i<bufferCount; i++) {
            RandomAccessFile file;
            try {
                file = new RandomAccessFile(filename, "r");
                buffers[i] = file.getChannel().map(FileChannel.MapMode.READ_ONLY, i*BUFFER_SIZE, (int) Math.min(remaining, BUFFER_SIZE));
            } catch (Exception e) {
                e.printStackTrace();
            }
            remaining -= BUFFER_SIZE;
        }
    }

posted on 2017-07-24 09:26 啊哈咧阅读(129) 评论(0) 编辑收藏举报

刷新页面返回顶部

JAVA IO

传统IO流体系

保存用户输入到文件

显示文本文件的内容

RandomAccessFile类进行文件加密

Scanner类

从键盘输入

Java NIO提供了与标准IO不同的IO工作方式：

Java NIO 概述

通道（Channel）

缓冲区（Buffer）

NIO FileChannel

公告