Java中的IO流

i/o流
        流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。

File类
概述 
File类：是文件和目录路径名的抽象表示形式。

即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可。

常用方法：
案例

File f=new File("D:\\hello.txt");
        try{
            f.createNewFile();
            f.delete();
            String fileName="D:"+File.separator+"hello";
            File f=new File(fileName);
            f.mkdir();
        }catch (Exception e) {
            e.printStackTrace();
        }
    public static void main(String[] args) {
        File file = new File("D:\\test.txt");
 
        try {
            System.out.println("创建一个新的文件："+ file.createNewFile());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
//
//        System.out.println("判断是否是文件夹: "+ file.isDirectory());
//        System.out.println("判断是否是文件: "+ file.isFile());
//        System.out.println("判断文件是否存在："+file.exists());
//        System.out.println("获取绝对路径："+file.getAbsoluteFile());
//        System.out.println("获取相对路径："+file.getPath());
//        System.out.println("获取文件名："+file.getName());
//        System.out.println("获取文件字节长度："+file.length());
 
//        File directory = new File("D:\\idea_test");
//        System.out.println("创建文件夹"+directory.mkdir());
 
//        File directory1 = new File("D:\\idea_test\\idea");
//        System.out.println("创建多层文件夹"+directory1.mkdirs());
 
    }

字节输入/输出流
字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。
字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）
读写字节流：InputStream 输入流（读）和OutputStream 输出流（写）
//字节输入流
 

  File f=new File("aaa.txt"); //定位文件位置
　　InputStream in=new FileInputStream(f); //创建字节输入流连接到文件
　　byte[] b=new byte[1024]; //定义一个数组，用来存放读入的数据 byte数组的大小也可以           根据文件大小来定 (int)f.length()
　　int count =0; 
　　int temp=0;
　　while((temp=in.read())!=(-1)){ //in.read（）是逐字节读的。当读到文件末尾时候返回-1
　　b[count++]=(byte)temp; //将读到的字节存储到byte数组中 
　　}
　　in.close(); //关闭流
　　System.out.println(new String(b)); //打印读取到的字节
 
//字节输出流
 
    File f = new File("xinzhi.txt"); // 定位文件位置
　　OutputStream out = new FileOutputStream(f); // 创建字节输出流连接到文件
　　String str = "aaa"; 
　　byte[] b = str.getBytes(); //将数据存入byte数组
　　out.write(b); //写数据 
　　out.close(); //关闭流

 文件复制

 //读入文件到程序
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(文件路径));
//写入数据到文件
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(文件路径));
    byte[] b = new byte[1024];
    int len = 0;
    while((len = bis.read(b)) != -1){
        bos.write(b, 0, len);
    }
    bis.close();
    bos.close();
    System.out.println("复制文件完成！");

字符输入/输出流
字符流是可以直接读写字符的IO流，字符流读取字符，就要先读取到字节数据，然后转为字符.；如果要写出字符，需要把字符转为字节再写出。
读写字节流：Reader输入流（读）和Writer 输出流（写）

//字符输入流
File f = new File("hello.txt"); // 定位文件位置
char[] ch = new char[100]; //定义一个数组，用来存放读入的数据
Reader read = new FileReader(f); //创建字符输入流连接到文件
int count = read.read(ch); //读操作
read.close(); //关闭流
System.out.println("读入的长度为：" + count);
System.out.println("内容为" + new String(ch, 0, count));
 
//字符输出流
File f=new File("hello.txt"); // 定位文件位置
Writer out =new FileWriter(f); //创建字符输出流连接到文件
String str="你好"; 
out.write(str); //写操作 
out.close(); //关闭流    

 字符缓冲输入/输出流
从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。

//字符缓冲输入流
File f = new File("xz.txt"); // 定位文件位置
char[] ch = new char[100]; //定义一个数组，用来存放读入的数据
Reader read = new FileReader(f); //创建字符输入流连接到文件
BufferedReader bfr=new BufferedReader(read); //创建缓冲流
int count = bfr.read(ch); //读操作
bfr.close(); //关闭缓冲流
read.close(); //关闭流
System.out.println("读入的长度为：" + count);
System.out.println("内容为" + new String(ch, 0, count));
 
 
//字符缓冲输出流
File f=new File("xz.txt"); // 定位文件位置
Writer out =new FileWriter(f); //创建字符输出流连接到文件
BufferedWriter bfw =new BufferedWriter(out); //创建缓冲流
String str="大数据"; 
bfw.write(str); //写操作 
bfw.close(); //关闭缓冲流
out.close(); //关闭流

 案例：
 

   public static void main(String[] args) {
        //字节输入流  硬盘-内存
        InputStream inputStream = null;
        BufferedInputStream bufferedInputStream = null;
        //字节输出流  内存-硬盘
        OutputStream outputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
 
        try {
            inputStream = new FileInputStream("E:\\前端框架.zip");
            bufferedInputStream = new BufferedInputStream(inputStream);
            outputStream = new FileOutputStream("D:\\test\\前端框架.zip");
            bufferedOutputStream = new BufferedOutputStream(outputStream);
//            分批次复制文件
            byte[] bytes = new byte[1024 * 30];
            long l = System.currentTimeMillis();
            //从硬盘读取数据存放到数组里面
            int read = bufferedInputStream.read(bytes);
            while (read !=-1){
                //每次写入只写入读取到的数组长度，就不会造成空间浪费
                bufferedOutputStream.write(bytes,0,read);
                read = bufferedInputStream.read(bytes);
            }
//            for (int i = 0; i < bytes.length; i++) {
//                System.out.println(bytes[i]);
//            }
            //从内存写入数据到硬盘里面
            bufferedOutputStream.flush();
            long l1 = System.currentTimeMillis();
            System.out.println(l1-l);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                if (bufferedOutputStream != null)
                    bufferedOutputStream.close();
                //先来者后关 后来者先关
                if (outputStream != null)
                    outputStream.close();
                if (bufferedInputStream != null)
                    bufferedInputStream.close();
                //开了的流必须关闭
                if (inputStream != null)
                    inputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }