java将流写到本地生成Excel

一.写入 又称:输出流

1.2创建

:
1/不带追加的格式:FileOutputStream 自定义对象名 = new FileOutputStream(字符串路径或File对象) 列如:FileOutputStream fileOutputStreamObj = new FileOutputStream("day08-Senior-code/test.txt");

2/带追加的格式:
FileOutputStream 自定义对象名 = new FileOutputStream(字符串路径或File对象,true/flash); 列如:FileOutputStream fileOutputStreamObjTwo = new FileOutputStream("\\testTwo.txt", true ); 区别
1/不带追加格式: 对某个文件写入数据时,会直接先清空(也可以理解为覆盖)所有数据.
2/带追加格式: 对某个文件写入数据时,不会覆盖原有的数据.但是追加规则有二种
规则一:如果参数为true,则每次写入的数据追加到文件末尾;
规则二:如果参数为flash,则每次写入的数据追加到文件最前.

注意:
1/如果文件已经存在,则new对象时不覆盖.
2/执行写入操作后,需要用close进行资源释放,如果不释放,文件将会被一直占用.

1.3写入数据

换行符:
如果你写入的是一个字符串文本,你想要在这里头进行换行操作,那么就需要用到一些符号.
换行符因系统不同而不同:
Windows为:\r\n
Linux为:/n
Mac为:/r

方式一:整数型Unicode码直写

格式1:对象名.write(码表所对应的int值); 列如:fileOutputStreamObj.write(5361);

方式二:直接以底层byte字节集表示
步骤1/声明byte数组
格式:byte[] 自定义变量名 = "字符串".getBytes(); 列如:byte[] byteArray = “zhongguo”.getBytes();
步骤2/写入内容
格式:对象名.write(byte变量名); 列如:fileOutputStreamObj.write(byteArray);

方式三:取指定的byte字节集.
步骤1/声明byte数组
格式:byte[] 自定义变量名 = "字符串".getBytes(); 列如:byte[] byteArrayTwo = “yongyuanheping”.getBytes();
**步骤2/**定义要取的内容,并写入
格式:对象名.write(byte变量名,起始位置,取字节的数量); 取指定的byte字节集.
列如:fileOutputStreamObjTwo.write(byteArrayTwo, 3, 6);
解释:
1/先将字符串转换为一组一组的字节集,并用byte数组保存这些’一组一组的字节集’
然后输入参数去取指定内容的字符串,接着根据字符串的索引值获取byte数组中其对应着的byte字节集元素.
2/起始位置的初始索引值以0计算,起始位置的索引值包括其对应的元素,
列如此处’byteArrayTwo’byte数组变量的内容为’yongyuanheping’.而括号内为3,
依照以0为初始位置,索引值’3’对应的就是’g’.
2/而’6’表示要取的数量,初始索引值为1,初始位置为索引值所对应的位置,
那么此处所取的内容就是g(1)y(2)u(3)a(4)n(5)h(6)

1.3释放资源

格式:对象名.close();

二.读取 又称:输入流

1/创建对象 - 开启读入流管道

格式: FileInputStream 自定义对象名= new FileInputStream(字符串路径或File对象); 列如: FileInputStream fileInputStreamObj = new FileInputStream("\InputTest");

2/读取

格式:自定义对象名.read(); 列如:fileInputStreamObj.read();
注意:
1/read方法的括号内不需要参数,每调用一次就会读取一个字节数据,因此想要完全读取下来,需要用到循环.
1/每次调用都会返回一个Int值,如果int值为’-1’则说明这是个空数据.不为’-1’则说明是个字节集数据.

3/释放资源 - 关闭读入流管道 close
格式:自定义对象名.close(); 列如:fileInputStreamObj.close();

三.字节流的缓冲流(推荐多用)

缓冲流意义:
缓冲流的[缓冲输入流]和[缓冲输出流]之方法跟普通的输入流输出流方法没什么区别,但是底层逻辑不同.
缓冲流对大文件的读取,或大文件的数据写入时,能提高效率.
使用:字节流之缓冲流的方法名称与其用法几乎与普通的字节流无异.

1/缓冲输入流的创建

第一种方式 — 包裹匿名对象式创建:
格式:BufferedInputStream 自定义对象名 = new BufferedInputSteam(new FileInputSteam(路径/File对象)); 列如:BufferedInputStream bufferedInputStreamObj = new BufferedInputStream(new FileInputStream(“C:\Users\1\Pictures\”));
第二种方式 — 分离式创建:
步骤一/格式:FileInputStream 自定义原始输入流对象名 = new FileInoutStream(路径/File对象); 步骤一/列如:FileInputStream fileInputStreamObj = new FileInputStream(“C:\Users\1\Documents\aaacc - 副本.txt”);

步骤二/格式:BufferedInputStream 自定义缓冲输入流对象名 = new BufferedInoputStream(自定义原始输入流对象名); 步骤二/列如:BufferedInputStream bufferedInputStreamObjTwo = new BufferedInputStream(fileInputStreamObj);

2/缓冲输出流的创建

第一种方式 — 包裹式匿名对象式创建:

格式:BufferedOutputStream 自定义对象名 = new BufferedOutputStream(new FileOutputStream(路径/File对象)); 列如:BufferedInputStream bufferedInputStreamObj = new BufferedInputStream(new FileInputStream(“C:\Users\1\Pictures”));

第二种方式 — 分离式创建:

步骤一/格式:FileOutputStream 自定义原始输出流对象名 = new FileOutputStream(路径/File对象);

步骤一/列如:FileOutputStream fileOutputStreamObj = new FileOutputStream("\bufferedOutputStream - 副本.txr");

步骤二/格式:BufferedOutputStream 自定义缓冲输出流对象名 = new BufferedOutputStream(自定义原始输出流对象名); 步骤二/列如:BufferedOutputStream bufferedOutputStreamObjTwo = new BufferedOutputStream(fileOutputStreamObj);

3/缓冲流的一个特殊方法

缓冲输出流对象名.flush();

顾名思义,这是一个刷新的方法.

它刷新的是被写入文件的缓冲数据,因为每次用缓冲输出流的write方法进行数据写出后,数据的’缓冲区’就需要缓存新的数据,所以这个时候就需要刷新缓冲区了.

保险起见,还是在每次用write语句刷新后用上它.
如果不用它,那么在调用释放资源的’close’方法时,close方法会自动触发’flush’的刷新机制.

四.复制多媒体文件的固定格式

byte[] byte数组变量 = new byte[1024];
        int 被充填了的数组数量之变量;
        while ((被充填了的数组数量之变量 = 输入流对象.read(byte数组变量)) != -1) 
            输出流变量.write(byte数组变量, 0, 被充填了的数组数量之变量;    
                                                                     }

列如:

byte[] byteArray = new byte[1024];
        int lengthInt;
        while ((lengthInt = fileInputStreamObj.read(byteArray)) != -1) {
            fileOutputStreamObj.write(byteArray, 0, lengthInt);
        }

讲解:
byte数组在read方法的括号内,其目的是要将读取到的数据元素充填到byte数组的个个数组里头.
而后read方法返回一个数值,这个数值标识的是其数组变量中有多少个数组充填了元素.
而lengthInt就是接收这个read返回的数值.这样子的话,就可以运用write(byte变量,0, 数组长度)这个形式来输出字节;
此时lengthInt这个变量就可用来表示其中的’数组长度’了
这么做的好处是:可以准确输出数据,不必输出不必要的空数据.如果不这样做,那多媒体文件也是可以用的,但是文件大小要比这个大

缓冲流演示类BufferedOutputAndInputStream.java

public class BufferedOutputAndInputStream {
    public static void main(String[] args) throws IOException {
      //创建 第一种方式 包囊式

        //创建缓冲输入流 读写流
        BufferedInputStream bufferedInputStreamObj = new BufferedInputStream(new FileInputStream("D:\\传智播客感恩节短片.mp4"));

        //创建缓冲输出流 写入流
        BufferedOutputStream bufferedOutputStreamObj = new BufferedOutputStream(new FileOutputStream("\\bufferedOutputStream.avi"));

        //写入数据 单个
        bufferedOutputStreamObj.write("china".getBytes());

        //复制多媒体文件
        byte[] byteTemp = new byte[1024];
        int lengthInt;
        while ((lengthInt = bufferedInputStreamObj.read(byteTemp))!=-1){//每次读取数据都会将数据元素充填到byte数组,每个数组最大128字节,如果没有任何元素被充填,则返回-1,视为无数据.
            bufferedOutputStreamObj.write(byteTemp,0,lengthInt);

 bufferedOutputStreamObj.flush();//保险起见,每输入一次数据,进行一次刷新.
        }

        //释放资源
        bufferedOutputStreamObj.close();

     //创建 第二种方式 分离式
        //创建缓冲输入流 读写流
        FileInputStream fileInputStreamObj = new FileInputStream("C:\\Users\\1\\Documents\\aaacc - 副本.txt");
        BufferedInputStream bufferedInputStreamObjTwo = new BufferedInputStream(fileInputStreamObj);

        //创建缓冲输出流 写入流
        FileOutputStream fileOutputStreamObj = new FileOutputStream("\\bufferedOutputStream - 副本.txr");
        BufferedOutputStream bufferedOutputStreamObjTwo = new BufferedOutputStream(fileOutputStreamObj);



    }
}

输出流演示类OutPutIo.java

public class OutPutIo {
    public static void main(String[] args) throws IOException {


        //创建并打开字节输入流(即对其写入数据流)   "\\test.txt" d:\test.txt
        FileOutputStream fileOutputStreamObj = new FileOutputStream("\\test.txt");
        //此处new对象有3个动作,1/判断目标文件是否存在,如果存在则不创建,反之则创建.
        //                     2/启动输入流
        //                     3/将对象指针指向其括号内路径中的文件.

        //以字节形式写入数据.如果该文件本就存在,将直接覆盖为写入的内容.
        //方式1 插入字符(?)
        fileOutputStreamObj.write(5361);//其实是Unicode码

        //方式2 插入全部byte字节流
        byte[] byteArray = "zhongguo".getBytes(); //将每个字符转为其对应的码(可以是Unicode,也可以是ASCII,总之当作Byte数据类型存入里头)
       fileOutputStreamObj.write(byteArray);
       
        //追加写入 格式:FileOutputStream 自定义对象名 = new FileOutputStream(字符串路径或File对象,true/flash);
        FileOutputStream fileOutputStreamObjTwo = new FileOutputStream("\\testTwo.txt", true );
        
        //方式3  插入指定byte字节流
        byte[] byteArrayTwo = "yongyuanheping".getBytes();
        fileOutputStreamObjTwo.write(byteArrayTwo, 3, 6);//gyuanh
        //换行
        fileOutputStreamObjTwo.write("\r\n".getBytes());
        fileOutputStreamObjTwo.write("世界の平和を望んでいる".getBytes());
        //释放资源 关闭输出流以解除占用.
        fileOutputStreamObj.close();
    }
}

输入流演示类:InPutIo.java

public class InPutIo {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStreamObj = new FileInputStream("\\InputTest.txt");
        //读取内容 越读取越靠后,获取的原始数据为int类型.如果读到了文件最后(也就是没有了),则返回的数值为'-1'.
        int read =  fileInputStreamObj.read();
       while ((read = fileInputStreamObj.read())!=-1){
           System.out.println((char) read);//将其从int强制转换为char
       }
       //释放资源 关闭读取流以解除占用
       fileInputStreamObj.close();
    }
}

应用:文本文件/多媒体文件的复制

实现:1/读入某个txt文件内容,创建一个文件,将其写入到该文件内容.
2/将某个多媒体文件(如图片)复制到另一处.
目的:锻炼IO的写入(Output)和读入(Input).

public class InputAndOutputOfIo {
    public static void main(String[] args) throws IOException {

 //=============================复制文本文件===================================
        //创建读入流
        FileInputStream fileInputStreamObj = new FileInputStream("\\test.txt");

        //创建输出流
        FileOutputStream fileOutputStreamObj = new FileOutputStream("\\paramOutput.txt");

        int intOfInputParam;


        //开始读取数据,但是想要得到数据内容,还需要转换,这个过程为
        while ((intOfInputParam=fileInputStreamObj.read())!=-1){

            System.out.println((char)intOfInputParam);


            fileOutputStreamObj.write(intOfInputParam);



        }


        //复制完毕后,再在接收文件内插入字符串内容.这个过程需要转换,顺序为: String字符串 ----> Byte数组
        byte[] stringOutput = "写入成功!".getBytes();

        fileOutputStreamObj.write(stringOutput);
        System.out.println("====================================");


//=============================复制其它文件(如多媒体)===================================

                   media();
    }

   //复制图片
    public static void media() throws IOException {
        //创建读入流
        FileInputStream fileInputStreamObj = new FileInputStream("C:\\Users\\1\\Pictures\\暴风截图20191119246824265.jpg");

        //创建输出流
        FileOutputStream fileOutputStreamObj = new FileOutputStream("\\JAVA复制版本暴风截图20191119246824265.jpg");


   //读入
        byte[] byteArray = new byte[1024];//定义一个长度为1024的静态byte型数组.
        int lengthInt;
        while ((lengthInt = fileInputStreamObj.read(byteArray)) != -1) { //read方法的括号内,其目的是要将读取到的数据元素充填到byte的个个数组里头.
            fileOutputStreamObj.write(byteArray, 0, lengthInt);     //而后read方法返回处一个数值,这个数值标识的是其数组变量中有多少个数组充填了元素
                                                                         //而lengthInt就是接收这个read返回的数值.这样子的话,就可以运用write(byte变量,索引值, 数组长度)这个形式来输出字节;
                                                                         //此时lengthInt这个变量就可用来表示其中的'数组长度'了
                                                                         //这么做的好处是:可以准确输出数据,不必输出不必要的空数据.如果不这样做,那多媒体文件也是可以用的,但是文件大小要比这个大
        }

        System.out.println("复制完成!");
        fileInputStreamObj.close();//关闭读取流
        fileOutputStreamObj.close();//关闭写入流


    }
}