java学习之输入，输出流

输入流与输出流

1,流的分类：字节流和字符流 区别如下：

1，字节流（8位Unicode）在操作的时候本身是不会用到缓冲区（内存）的byte，是与文件本身直接操作的，而字符流(16位Unicode)在操作的时候是使用到缓冲区的char

2，字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，

并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

3，在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。

2,File类

3,I\O流

1,

输入流：从其他数据源写入到代码内存

输出流：从代码内存写入到指定数据源中

2，流分类：

1，节点流有：FileInputStream,FileReader,ArrayInputStream等，对接数据源

处理流：套接在节点流（或处理流）之上的

2，缓存流有：BufferedInputStream,BufferedReader等加快读写速率

3，数据流有：DataInputStream减少数据类型的转换，在网络编程多

4，对象流有：ObjectInputStream,需要对对象序列化，网络编程多

5，打印流有：Print，控制输入，输出的目的地。

3，案例

3.1 字节流进行文件copy

static void testByte(String source ,String target){
        final int SIZE=1024;
        try {
            InputStream in=new FileInputStream(source);// 快捷键：ctrl+alt+t try..catch
            BufferedInputStream bufIn=new BufferedInputStream(in,SIZE);
            OutputStream out=new FileOutputStream(target,true);
            BufferedOutputStream bufOut=new BufferedOutputStream(out);
            byte [] byteArr=new byte[SIZE];// if inbuf.size>byte.length ,will have Exception:String index out of range: 105
            int len;
            while((len=bufIn.read(byteArr))!=-1){
                //in.read(buf) 注意点：read()为原生方法，该方法能记录住你上次读取的位置，所以while不会每次都重头开始读文件
                //in.read(buf) 将读取的文件字节保存到buf中，并返回读取了多少字节
                //Buffer的作用即将文件中先读入缓存,需要先满足Buff的数组容量，（所以byteArr的容量要大于BuffSize)然后将缓存中一起读入byteArr中，
                  避免一字节一字节来读到byteArr中
                bufOut.write(byteArr,0,len);//如果没有len,会按SIZE来写，不足用NULL填充
            }
            bufOut.flush();
            bufOut.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.2 字符流进行文件copy

//通过字符进行copy文件，使用Buffer和File
    static void testChar(String source ,String target){
        final int SIZE=1024;
        try {
            Reader in=new FileReader(source);// 快捷键：ctrl+alt+t try..catch
            BufferedReader bufIn=new BufferedReader(in,SIZE);
            Writer out=new FileWriter(target, true);//是否对文件进行追加处理
            BufferedWriter bufOut=new BufferedWriter(out);
            String temp;
            bufOut.write("使用字符操作的结果");
            while((temp=bufIn.readLine())!=null){
                bufOut.write(temp);//不包括换行符，这里
                bufOut.newLine();//没该句就不会换行
            }
            bufOut.flush();
            bufOut.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.3 byteArray和DataInput测试

//数据流 byteArray和Data
    static  void testByteData(){
        ByteArrayOutputStream byteOut=new ByteArrayOutputStream();
        DataOutputStream dataOut=new DataOutputStream(byteOut);

        try {
            dataOut.writeUTF("你好啊");//用writeChars,导致后面无法读
            dataOut.writeDouble(0.33334);
            dataOut.close();
            System.out.println(byteOut.size()+""+byteOut.toByteArray().length);//19 19即字节的个数
            ByteArrayInputStream byteIn=new ByteArrayInputStream(byteOut.toByteArray());//需要在写完后读，即需要读取最新的
            DataInputStream dataIn=new DataInputStream(byteIn);
            System.out.println(dataIn.readUTF());
            System.out.println(dataIn.readDouble());
            dataIn.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.4 File字节流和Data字符流

//数据流 Data和File
    static void testeFileData(String target){
        String[] name={"知识","zsf","succ"};
        double[] hig={13.4,34.4,43,24};
        int[] age={34,243,34};
        try {
            OutputStream out=new FileOutputStream(target);
            BufferedOutputStream buf=new BufferedOutputStream(out,1024);
            DataOutputStream dataOut=new DataOutputStream(buf);
            for(int i=0;i<3;i++){
                dataOut.writeUTF(name[i]);
                dataOut.writeChar('\t');
                dataOut.writeDouble(hig[i]);
                dataOut.writeChar('\t');
                dataOut.writeInt(age[i]);
                dataOut.writeChar('\n');
            }
            dataOut.close();
            InputStream in=new FileInputStream(target);
            BufferedInputStream bufIn=new BufferedInputStream(in,1024);
            DataInputStream dataIn=new DataInputStream(bufIn);
            String str=null;
            for(int i=0;i<3;i+=1){//需要事先知道文件中存储的格式和行数
                System.out.print(dataIn.readUTF());
                dataIn.readChar();
                System.out.print(dataIn.readDouble());
                dataIn.readChar();
                System.out.print(dataIn.readInt());
                dataIn.readChar();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3.5 对象流和byteArray流

void testObjectByte(){
        User user1=new User("知识",4);
        User user2=new User("知识",4);
        ByteArrayOutputStream byteOut=new ByteArrayOutputStream();
         try {
             ObjectOutputStream objOut=new ObjectOutputStream(byteOut);
             objOut.writeObject(user1);
             objOut.writeObject(user2);
             byte[] data=byteOut.toByteArray();//
             ByteArrayInputStream byteIn=new ByteArrayInputStream(data);
             ObjectInputStream objIn=new ObjectInputStream(byteIn);
             User u=(User)objIn.readObject();
             System.out.println(u.age+"\t"+u.name);
            System.out.println(objIn.readObject());
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 class User implements Serializable{
        private static final long serialVersionUID = 1L;
        public String name;
        public int age;
        public User(String name,int age){
            this.name=name;
            this.age=age;
        }
        public String toString(){
            return name+"\t"+age;
        }
    }

3,6 文件流和对象流

 class User implements Serializable{
        private static final long serialVersionUID = 1L;
        public String name;
        public int age;
        public User(String name,int age){
            this.name=name;
            this.age=age;
        }
        public String toString(){
            return name+"\t"+age;
        }
    }
//对象流和文件 字符型没有该方法
    void testObjectFile(String source){
        User user1=new User("你好",5);
        User user2=new User("你好",5);
        try {
            OutputStream outputStream=new FileOutputStream(source);
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(user1);
            objectOutputStream.writeObject(user2);
            InputStream inputStream=new FileInputStream(source);
            ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
            User user=(User)objectInputStream.readObject();
            System.out.println(user.name+"\t"+user.age);
            System.out.println(objectInputStream.readObject());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

3.7 转换流

//转换流
    static void testSteamReader(String source,String target){
        try {
            InputStream in=new FileInputStream(source);
            Reader reader=new InputStreamReader(in,"utf-8");
            BufferedReader bufRead=new BufferedReader(reader);
            CharArrayWriter charArr=new CharArrayWriter();
            FileWriter writer=new FileWriter(target);
            String line;
            while((line=bufRead.readLine())!=null){
                System.out.println(line+"okl");
                charArr.write(line);
                System.out.println(charArr.toString());
                writer.write(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4 小结

1，关键总结输出流和输入流

2，节点流和处理流的应用场景

3，多看api