IO和NIO

一.创建IO

System.out.println( "*************欢迎进入文件操作系统*************" );
        System.out.println( "*************1.创建文件*************" );
        System.out.println( "*************2.删除文件*************" );
        System.out.println( "*************3.修改文件*************" );
        System.out.println( "*************4.创建文件夹*************" );
        System.out.println( "*************5.查询文件夹下所有的文件列表*************" );
        System.out.println( "*************请选择：*************" );

        //获取用户的输入
        int choose = input.nextInt();
        switch (choose){
            case ://创建文件
                 createNewFile();
                break;
            case ://删除文件
                 deleteFile();
                break;
            case ://修改文件
                 updateFile();
                break;
            case ://创建文件夹
                 mkdirs();
                break;
            case ://查询文件夹下所有的文件列表
                 findFileList();
                break;
        }
    }
   // 查询文件夹下所有的文件列表
    private static void findFileList() {
        System.out.println("请您输入查询的文件夹名称：（默认是E：/）");
        String fileName = input.next();
        //创建File对象
        File file=new File("E:/"+fileName);
        File[] files = file.listFiles();
        int dirNums=;
        int fileNums=;
        //遍历集合
        for (File f:files){
            if (f.isDirectory()){
                dirNums++;
            }
            if (f.isFile()){
               fileNums++;
                System.out.println(f.getName());
            }
        }
        System.out.println("有多少个文件夹?"+dirNums);
        System.out.println("有多少个文件?"+fileNums);
    }

    //创建文件夹
    private static void mkdirs() {
        System.out.println("请您输入创建的文件夹名称：（默认是E：/）");
        String fileName = input.next();
        //创建File对象
        File file=new File("E:/"+fileName);
        if (file.mkdirs()){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
    }

    //修改文件
    private static void updateFile() {
        System.out.println("请您输入需要修改文件的名称：（默认是E：/）");
        String oldFileName = input.next();
        System.out.println("请您输入文件的新名称：（默认是E：/）");
        String newFileName = input.next();
        //创建File对象
        File oldFile=new File("E:/"+oldFileName);
        File newFile=new File("E:/"+newFileName);
        if(oldFile.renameTo(newFile)){
            System.out.println("修改成功");
        }else{
            System.out.println("修改失败");
        }

    }

    //删除文件
    private static void deleteFile() {
        System.out.println("请您输入删除文件的名称：（默认是E：/）");
        String fileName = input.next();
        //创建File对象
        File file=new File("E:/"+fileName);
        if (file.exists()){  //文件存在才能删除
            boolean flag = file.delete();
            if (flag){
                System.out.println("文件删除成功！");
            }else{
                System.out.println("文件删除失败！");
            }
        }else{
            System.out.println("该文件不存在！");
        }
    }

    //创建文件
    private static void createNewFile() {
        System.out.println("请您输入文件的名称：（默认是E：/）");
        String fileName = input.next();
        //创建File对象
        File file=new File("E:/"+fileName);
        if (file.exists()){  //文件已经存在
            System.out.println("该文件已经存在！");
        }else{
            try {
             boolean  flag= file.createNewFile();
             if (flag){
                 System.out.println("文件创建成功！");
             }else{
                 System.out.println("文件创建失败！");
             }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

二.流

　　1.字节流

//创建输出流和输出流对象
InputStream inputStream=null
OutputStream outputStream=null
try{
    inputStream=new InputStream("e:/a.txt");
　　//true 代表是否向文件中拼接，不删除之前的内容
    outputStream=new OutputStream("e:/a.txt"，true);
　　//先向文件写入内容
    outputStream.write("".getBytes());
　　//read 方法将返回0~255之间的数字如果流读到了最后，将返回-1
　　 int num=0;
　　　while((num=inputStream.read())!=-1){
　　　　System.out.println((char)num);
　　}
}catch(Exception e){
    e.printStackTrace();
}finally{
    try{
        inputStream.close();
        outputStream.close();
   }catch(Exception e){
    e.printStackTrace();
}

}

　　　　

　　2.字符流

//创建输出流和输入流
Reader reader=null;
Writer writer=null;
try{
　　reader=new FileReader("e:/a.txt");
　　writer=new FileWriter("e:/a.txt",true);
　　writer.write("我是小明");
　　writer.flush();
　　writer.write("我是小刚");
　　writer.write("我是小红");
　　writer.close();
　　int num=0;
　　char[]data=new char{1024};
　　StringBuffer sb=new StringBuffer();
　　while((num=reader.read(data))!=-1){
　　　　sb.append(data);
　　}
　　System.out.println(sb.toString())
　　catch(Exception e){
　　　　e.prinrStackTrace();
　　}finally{
　　　　　　try {　　　　　
　　　　　　　　reader.close();
　　　　　　} catch (IOException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}　　
　　　}
}

　　3.二进制流

//创建输出流和输入流对象
InputStream inputStream=null；
OutputStream outputStream=null;
DataInputStream dis=null;
DataOutputStream dos=null;
try{
    //获取输入流
    inputStream=new InputStream("e:/a.txt");
    dis=new DataInputStream(inputStream);
    //获取输出流
    outputStream=new OutputStream("e:/a.txt");
    dos=new DataOutputStream(outputStream);
    int num=;
    while((num=dis.read())!=-){
        dos.write(num);//复制
    }

}catch (Exception e) {
        e.printStackTrace();
 }finally{
    dos.close();
    dis.close();
    outputStream.close();
    inputStream.close();
}

　　4.缓冲流

Reader reader=null;
        Writer writer=null;
        BufferedReader  br=null;
        BufferedWriter bw=null;
        try {
            writer=new FileWriter("e:/a.txt",true);
            bw=new BufferedWriter(writer); //封装
            bw.write("我是小明！");
            bw.newLine();  //换行
            bw.write("我是小刚！");
            bw.flush();
            bw.write("我是小红！");
            bw.close();
            writer.close();  //如果不关闭  后续两句话没法获取
            //读取
            reader=new FileReader("e:/a.txt");
            br=new BufferedReader(reader);//封装
            String line=null;
            StringBuffer sb=new StringBuffer();
            while ((line=br.readLine())!=null){
                sb.append(line);
            }
            System.out.println(sb.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

　　5.序列化和反序列化

static Scanner  input=new Scanner(System.in);
    //创建需要的输入和输出流对象
    static   InputStream inputStream=null;
    static  OutputStream outputStream=null;
    static ObjectInputStream objectInputStream=null;
    static ObjectOutputStream  objectOutputStream=null;

    public static void main(String[] args) {
         //注册   序列化
        //register();
        //登录  反序列化
        login();
    }

    //注册
    private static void register()  {
        User user=new User();
        System.out.println("请输入您的用户名：");
        user.setUserName(input.next());
        System.out.println("请输入您的密码：");
        user.setPassword(input.next());

        try {
            outputStream=new FileOutputStream("e:/user.txt");
            objectOutputStream=new ObjectOutputStream(outputStream);
            //把对象输出到文件中
            objectOutputStream.writeObject(user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                objectOutputStream.close();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //登录
    private static void login() {
        try {
            inputStream=new FileInputStream("e:/user.txt");
            objectInputStream=new ObjectInputStream(inputStream);
            //读取对象
            User user= (User) objectInputStream.readObject();
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                objectInputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

三.NIO

　　1.buffer

　　　　01.buffer   缓冲区：存储的是相同类型的数据集！

　　　　　　本质是一个可以写入数据，并且从中读取数据的内存！

　　　　02.position：写入或者读取的数据的当前指针

　　　　　　最大值是：capacity-1

　　　　03.limit：有多少数据可以写或者可以读

　　　　　　在write模式下，我们的limit和capacity的值一致！

　　　　　　在read模式下，我们的limit和write模式下的position的值一致

　　　　　　　　　　position变成了0！

　　　　03.capation：缓冲区的最大容量；

//创建一个容量为20的int类型缓冲区
IntBuffer buffer=IntBuffer.allocate();
System.out.println("capacity====>"+buffer.capacity());
System.out.println("position====>"+buffer.position());
System.out.println("limit====>"+buffer.limit());
//创建一个int类型的数组，便于放进缓冲区
int[]nums={,,,,,};
buffer.put(nums);
System.out.println("*************************");
System.out.println("capacity====>"+buffer.capacity());
System.out.println("position====>"+buffer.position());
System.out.println("limit====>"+buffer.limit());
//重设缓冲区  切换到 读模式
buffer.flip();
System.out.println("*************************");
System.out.println("capacity====>"+buffer.capacity());
System.out.println("position====>"+buffer.position());
System.out.println("limit====>"+buffer.limit());
//读取数据
while(buffer.hasremaining()){
    System.out.println(buffer.get());
}

2.channel通道

　　1.概念

　　　　01.基于缓冲区对数据进行读取或者是写入

　　　　02.通道是双向的,流是单向的

　　　　03.可以异步的读写

　　2.常用的实现类

　　　　01.FileChannel:从文件中读写数据

　　　　02.DatagrarmChannel:通过UDP读写网络中的数据

　　　　03.Socketchannel:通过TCP读写网络中的数据

　　　　04.ServerSocketchannel:可以监听新来的TCP连接,每进来一个都会创建一个新的 Socketchannel。

　　3.内存映射：就是把文件映射到电脑中的内存中，道过探作内存从而达到操作文件的目的内存中操作速度是最快的

　　4.java中读取文件的方式:
　　　　01. RandomAccessFile随机读取，速度最慢82.F ile Inputstream 流的方式读取
　　　　03. BufferReader 缓存的方武读取
　　　　04. MappedByteBuffer内存映射，速度是最快的! ***零*米
　　5.内存映射的种模式: MapMode
　　　　01. READ ONLY 对缓冲区的内容只读B

　　　　02.READ WRITE茶对绊冲义的内容读写

　　　　03. PRIVATE 只会对缓冲区的内容进行修改，不会影响到真实的文件
　　　　(通常活用于文件的读取!一般不会涉及到文件的写入)
　　6.文件锁:
　　　　01.FileLock基于FileChanne1对 文件捉供锁的功能!
　　　　02.共享锁共享读的操作，只能有个写操作 !防止其他线程获取独占锁!适合读取数据!
　　　　03.独占锁:读写不能同时，只能有一个读或者一个写!适合写数据!
　　　　lock():阻塞

　　　　无参的默认是独占锁:

　　　　有参的为共享锁!
　　　　tryLock():非阻塞

//创建需要读取和写入的文件地址
File filea=new File("d:/a.txt”);
File fileb=new File("d:/b.txt");
//创建输入流和输出流
FileInputStream input=new FileInputStream(filea);
FileOutputStream output=new FileOutputStream(fileb);
//创建输入流和输出流通道
FileChannel inChannel=input.getChannel();
FileChannel outChannel=outputgetChannel();
//创建缓冲区
ByteBuffer buffer=ByteBuffer.allocate(1024);

int num=0;
while((num=outchannel.read())!=-1){
    buffer.flip();
    outChannel.write(buffer);
    buffer.close();
}
outChannel.close();
inChannel.close();
output.close();
input.close();