IO与NIO

package cn.Fileoperation;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Scanner;

public class TheConduit {
    static Scanner input=new Scanner(System.in);
    public static void main(String[] args) {
            //创建
            //establish();
            //复制转移
            //transfer();
    }
  //复制转移
    private static void transfer() {
        System.out.println("文件的路径+文件名");
        String one=input.next();
        System.out.println("想要文件信息的文件的路径+文件名");
        String two=input.next();
        //创建file对象 ，两个路径
        File onefile=new File(one);
        File twofile=new File(two);
        //创建 输入 输出流
        FileInputStream fileInputStream=null;//输入
        FileOutputStream fileOutputStream=null;//输出
        //创建管道 用于 输入 输出
        FileChannel onechannel=null;//输入
        FileChannel twochannel=null;//输出
        //实例化 输入 输出
        try {
            fileInputStream=new FileInputStream(onefile);
            fileOutputStream=new FileOutputStream(twofile);
            //实例化管道
            onechannel=fileInputStream.getChannel();
            twochannel=fileOutputStream.getChannel();
            //创建缓冲区
            ByteBuffer  buffer= ByteBuffer.allocate(1024);
            //定义变量接去a文件的数据
            int num=0;
            while ((num=onechannel.read(buffer))!=-1){
                //切换模式
                buffer.flip();
                twochannel.write(buffer);//真实写入
                //清除缓冲
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                twochannel.close();
                onechannel.close();
                fileOutputStream.close();
                fileInputStream.close();
                System.out.println("完事！！！！");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 //创建
    private static void establish() {
        //写模式
        System.out.println("需要一个路径+文件名");
        String name=input.next();
        //创建一个文件对象
        File file=new File(name);
        //创建一个输出流对象
        FileOutputStream fileOutputStream=null;
        //创建一管道对应的实体类
        FileChannel fileChannel=null;
        try {
            fileOutputStream=new FileOutputStream(file);//封装
            fileChannel=fileOutputStream.getChannel();//获取到管道
            ByteBuffer buffer=ByteBuffer.allocate(1024);//创建一个1024的缓冲区
            //创建一个数组来为缓冲区赋值
            String [] nams={"你","我","它","他","她"};
            //因为缓冲区是ByteBuffer 所以这里需要转化下
            for (String s:nams){
                buffer.put(s.getBytes());//把数组中的值循环添加到缓冲区中
            }
            //重置缓冲区  切换读模式
            buffer.flip();
            //真正的写入到文件中
            try {
                fileChannel.write(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    //关闭
                    fileChannel.close();
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package cn.Fileoperation;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Scanner;

public class Memorymappings {
    static Scanner input=new Scanner(System.in);
    public static void main(String[] args) {
        mappings();
    }
    private static void mappings() {
        //创建一个管道
        FileChannel fileChannel=null;
        System.out.println("给个地址：");
        String file=input.next();
        try {
            RandomAccessFile randomAccessFile=new RandomAccessFile(file,"rw");
            //实例化一个管道
            fileChannel=randomAccessFile.getChannel();
            try {
                //创建一个内存文件映射
                MappedByteBuffer   buffer=fileChannel.map(FileChannel.MapMode.READ_ONLY,0,fileChannel.size());
                //创建一个缓冲区
                ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
                //创建一个byte数组，便于后续获取数据
                byte [] bytes=new byte[1024];
                //获取文件的大小
                long length=randomAccessFile.length();
                //设置开始时间
                long bageTime=System.currentTimeMillis();
                //循环
                for (int i=0;i<length;i+=1024){
                    if(length-i>1024){
                        buffer.get(bytes);
                    }else{
                        byteBuffer.get(new byte[(int)length-i]);
                    }
                }
                //设置结束时间
              long endTime=System.currentTimeMillis();
                System.out.println("使用内存映射的时间"+(bageTime-endTime));

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

                bageTime=System.currentTimeMillis();//开始时间
                int num=0;
                while ((num=fileChannel.read(byteBuffer))!=-1){
                    byteBuffer.flip();  //重置缓冲区
                    byteBuffer.clear();//清空缓冲区
                }
                endTime=System.currentTimeMillis();//结束时间
                System.out.println("使用io的时间"+(bageTime-endTime));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package cn.Fileoperation;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.Scanner;
public class Lock {
    static Scanner input=new Scanner(System.in);
    public static void main(String[] args) {
       lock();
    }
    private static void lock() {
        FileChannel channel=null;
        FileLock lock=null;
        //获取文件
        System.out.println("路径：");
        String file=input.next();
        try {
            RandomAccessFile randomAccessFile=new RandomAccessFile(file,"rw");
            //获取管道
            channel=randomAccessFile.getChannel();
            try {
                lock=channel.lock();//独占锁
                lock=channel.lock(0,channel.size(),true);//共享锁
                System.out.println(lock.isShared());
                System.out.println(lock.isValid());
                //创建缓冲区
                ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
                System.out.println("写：");
                String name=input.next();
                //向缓冲区写入数据
                byteBuffer.put(name.getBytes());
                //切换模式
                byteBuffer.flip();
                //通道写入数据
                channel.write(byteBuffer);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    lock.close();
                    channel.close();
                    System.out.println("完事！！！！");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}