java中的IO流

一直对java中的IO流掌握的不是很好，今天正好看见一篇非常好的博客(https://www.cnblogs.com/xdp-gacl/p/3634409.html)，就再学习了一下，下面是测试代码：

1、节点流的测试

/*节点流测试*/   
    //字符流 FileInputStream与FileOutputStream的测试
    public static void copyIo() {
        try {
            FileInputStream in = new FileInputStream("1.txt");
            FileOutputStream out=new FileOutputStream("3.txt");
            int ch;
            while((ch=in.read())!=-1) {
                //System.out.print((char)ch);//输出结果为乱码
                out.write(ch);//可以正确写入文件

            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //字节流 FileWriter与FileReader的测试 
    public static void copyWr() {
        //String path="";//F:\eclipse-workspace\TestStream 得到的是项目的根路径
                //String path="/";F:\  得到的是磁盘跟路径
                String path="1.txt";
                String path1="3.txt";
                File file=new File(path);
                //System.out.println(file.exists());
                //System.out.println(file.getAbsolutePath());
                try {
                    FileReader in=new FileReader(file);
                    //FileReader也可以像下面一样直接使用路径创建对象
                    FileWriter out=new FileWriter(path1);

                    int ch=0;
                    while((ch=in.read())!=-1) {

                        //System.out.print((char)ch);   
                        //可以正确的将1.txt中的汉字输出
                        out.write(ch);
                    }
                    //没有写下面这句的话你会发现文本并没有写进去  意思是将数据由缓冲区写入内存
                    out.flush();
                    out.close();
                    in.close();


                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

    }

2、处理流测试

（1）缓冲流测试

/*处理流实验*/
    //缓冲流测试
    /*
     *缓冲流其实就是增加了缓冲 减少访问磁盘的次数  读取的规则  即按照字节还是字符依赖于绑定的节点流 
     * */
    public static void testBuffer() {
        try {
            FileInputStream fis=new FileInputStream("1.txt");
            FileOutputStream fos=new FileOutputStream("3.txt");
            FileReader fr=new FileReader("1.txt");
            FileWriter fw=new FileWriter("3.txt");

            BufferedInputStream bis=new BufferedInputStream(fis);
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            BufferedReader br=new BufferedReader(fr);
            BufferedWriter bw=new BufferedWriter(fw);
            /*
            int ch;
            while((ch=bis.read())!=-1) {
                //System.out.print((char)ch);//输出与FileInputStream 一样也为乱码
                bos.write(ch);//正确写入
            }
            bos.flush();*/
            String line=null;
            //BufferedReader可以按行读取  写入的时候可以使用 newLine()进行换行
            while((line=br.readLine())!=null) {
                System.out.println(line);
                bw.write(line);
                bw.newLine();
            }
            bw.flush();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
}

（2）转换流测试

/*
     * 转换流的测试
     * InputStreamReader  需要与 InputStream 套接
       OutputStreamWriter 需要与OutputStream套接 ，在构造的时候可以指定其编码集合
             将字节流转换为字符流之后  我们就可以使用字符流中的 readLine()与 write(String str) 按照字符串读取和写入  大大的减少了访问磁盘的次数
     * */
    public static void changeIo() {

        try {

            FileInputStream fis=new FileInputStream("1.txt");//字节流
            InputStreamReader ir=new InputStreamReader(fis);//字节流转换为字符流
            BufferedReader br=new BufferedReader(ir);//再将其绑定到缓冲流上面

            FileOutputStream fos=new FileOutputStream("3.txt");
            OutputStreamWriter osw=new OutputStreamWriter(fos);
            BufferedWriter bw=new BufferedWriter(osw);
            String s=null;
            while((s=br.readLine())!=null) {
                //System.out.println(s);
                bw.write(s);
            }
            bw.flush();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

（3）打印流测试

/*
     * 打印流测试
     * */
    public static void testPrint() {
        try {
            FileOutputStream fos=new FileOutputStream("3.txt");
            PrintStream ps=new PrintStream(fos);
            if(ps!=null) {
                //原来 System.out.println(x)默认是输出到了命令行中去  setOut(ps)更改的输出流  输出到了ps绑定的文件中去
                System.setOut(ps);
            }

            //这些数据会被输入到3.txt文件中去   
            for(int i=0;i<100;i++) {
                System.out.println(i);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

（4）对象流测试

/*
     * 对象流测试
     * 可以直接将一个对象写入文件中去  再读取出来  需要注意的是写进去的类对象必须可以序列化
     * */
    public static void testObject() {
        User user=new User("zhangsan","1234");
        try {
            FileOutputStream fos=new FileOutputStream("3.txt");
            ObjectOutputStream oos=new ObjectOutputStream(fos);

            FileInputStream fis=new FileInputStream("3.txt");
            ObjectInputStream ois=new ObjectInputStream(fis);
            oos.writeObject(user);
            oos.flush();


            //将文件中的对象再读取出来
            User user1=(User)ois.readObject();
            System.out.println(user1.username+"  "+user1.password);

            oos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

（5）数据流测试

public static void testDataStream(){
        //数据流   为处理流
        /*
        DataInputStream(InputStream in) 
          使用指定的底层 InputStream 创建一个 DataInputStream
          方法
          readByte
          readInt
          readLong
          readShort等
        */

        DataInputStream dis=null;//输入流
        DataOutputStream dos=null;//输出流

        ByteArrayInputStream bais=null;//字节输入流
        ByteArrayOutputStream baos=null;//字节输出流
        byte b[]=new byte[1024];
        //bais=new ByteArrayInputStream(b);
        //dis=new DataInputStream(bais);

        //baos=new ByteArrayOutputStream();
        //dos=new DataOutputStream(baos);

        try{
            baos=new ByteArrayOutputStream();
            dos=new DataOutputStream(baos);
            dos.writeInt(100);//往字节数组中写Int类型的值
            dos.writeDouble(121.0);//往字节数组中写Double类型的值
            dos.writeBoolean(true);//往字节数组中写Boolean类型的值

            bais=new ByteArrayInputStream(baos.toByteArray());
            dis=new DataInputStream(bais);
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            try{
                if(dos!=null){
                    dos.close();
                }
                if(baos!=null){
                    baos.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
}

主函数调用

    public static void main(String[] args) {
        /*项目目录下
         *  1.txt存放的是汉字
            2.txt存放的是英文
            通过将两个文件的内容拷贝到3.txt进行测试
            */
        //copyWr();
        //copyIo();
        //testBuffer();
        //changeIo();
        //testPrint();
        testObject();

    }