Java输入输出流

Java输入输出流

1. 字节输入流和输出流

• • 字节输入流

    /**
     * 测试字节输入流的使用：
     * 新建一个文件字节输入流对象，读取imooc.txt文件中内容，输出到控制台
     */
    public class FileInputDemo1 {
        public static void main(String[] args) throws IOException {
            
            //实例化字节输入流对象，使用read方法读取一个字节的数据，返回为int，自动往下接着读取
            //返回为-1时，读取到文件末尾
            FileInputStream fis = new FileInputStream("test.txt");
            int n = fis.read();     
            while(n!=-1) {
                System.out.print((char)n);
                n =fis.read();
            }
            //关闭系统资源
            fis.close();
        }
    }

     

• • 字节输出流

    /**
     * 例1、实例化字节输出流对象，输出到文件imooc.txt，然后用输入流对象读取文件中的数据
     */
    public class FileOutputDemo1 {
        
        public static void main(String[] args) throws IOException {
            //实例化字节输出流对象，输出到文件imooc.txt
            FileOutputStream fos =  new FileOutputStream("test2.txt");
            //用输入流对象读取文件中的数据
            FileInputStream fis = fis = new FileInputStream("test2.txt");    
            //写到imooc文件中，一个int数据，一个字符数据
            fos.write(50);
            fos.write('a');    
            System.out.println((char)fis.read());
            //关闭资源
            fis.close();
            fos.close();        
        }
    }

    /**
     * 例2、把happy.jpg复制一份，名字为happycopy.jpg
     */
    public static void main(String[] args) throws IOException {
        
        FileInputStream fis = new FileInputStream("happy.jpg");
        FileOutputStream fos = new FileOutputStream("happycopy.jpg");
        
        //n作为读方法的返回值，如果读取到-1，就到了文件末尾
        int n = 0;
        
        //新建一个字节(B)数组，用来缓存图像数据的部分数据，大小为1kB
        //图像数据大小为24k，相当于24个b数组，才能存放得下去
        byte[] b = new byte[1024];
        
        //循环使用read(byte [] b )，从输入流（图片数据流）中读取b.length(即1024)个字节到数组b中
        //read(byte [] b)返回值为实际读取的字节数，即就是n，使得复制后的图片大小和原来的一样
        //如果读取到-1，就到了文件末尾
        while((n=fis.read(b))!= -1) {
            //将b数组中，从0开始，到输入流-图像数据最后的字节数n，读取到输出流中
            fos.write(b, 0, n);
        }
        
        fis.close();
        fos.close();
        
    }

     

　　2.字符输出流和输入流

• • 字符输出流

    /**
     * 测试字符输出流
     * 使用方法：实例化字节输入流对象，根据字节输入流对象，实例化字符输入流对象
     * 字符输入流的构造方法中的第一个参数数字节输入流
     * 计算机把file文件载入计算机，在计算机中用字节流传输
     * 输出让人看的时候，再用字符流输出为字符形式
     */
    public class ReaderDemo {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("imooc.txt");
            FileOutputStream fos = new FileOutputStream("imooc1.txt");
            //InputStreamReader的构造方法中需要传进去一个字节输入流
            InputStreamReader isr = new InputStreamReader(fis);
            //OutputStreamReader的构造方法中需要传进去一个字节输出流
            OutputStreamWriter osw = new OutputStreamWriter(fos);
            int n =0;
            //新建字符数组，用来存放输入流的字符
            char[] cbuf = new char[10];
            /**
             * 测试一、输出数据的第一种方法
             */
            //字符输入流的reader(空)方法，返回值为当前输入流的一个字符，如果已经达到流的结尾，则为-1
    //        while((n=isr.read())!=-1) {
    //            System.out.print((char)n);
    //        }
            /**
             * 测试二、第二种方法，使用字符数组，输出文件中内容
             */
            //read(字符数组)方法返回的是实际读取的字符个数
    //        while((n=isr.read(cbuf))!=-1) {
    //            String s = new String(cbuf,0,n);
    //            System.out.print(s);
    //        }
            /**
             * 测试三、读取数据，存储到imooc1.txt
             */
            //read(字符数组)方法返回的是实际读取的字符个数，
            //把输入流中的数据while循环读取到字符数组中，并且一次10个字符的输出
            while((n=isr.read(cbuf))!=-1) {
                osw.write(cbuf, 0, n);
                osw.flush();
            }    
            fis.close();
            fos.close();
            isr.close();    
        }
    }

     

　　3.对象序列化和反序列化

• • 使用对象输出流ObjectOutputStream将java对象数据写入到imooc2.txt文件中

    /**
     * 对象序列化过程，使用对象输出流ObjectOutputStream将java对象数据写入到imooc2.txt文件中
     * 再使用对象输入流ObjectInputStream将Java对象数据读取出来*/
    public class GoodsTest {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            
            Goods goods1 = new Goods("gd001","电脑",3000);
            try {
                //将java对象数据写入到imooc2.txt文件中
                //ObjectOutputStream是字节输出流OutputStream的子类
                FileOutputStream fos = new FileOutputStream("imooc2.txt");
                //构造方法需要传入字节输出流OutputStream
                //构造方法为：ObjectOutputStream(OutputStream out)
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                //创建输入流，读取对象数据
                FileInputStream fis = new FileInputStream("imooc2.txt");
                ObjectInputStream ois =new ObjectInputStream(fis);
                //将Goods对象信息写入文件
                oos.writeObject(goods1);
                oos.flush();
                //读取对象信息
                Goods goods2 = (Goods) ois.readObject();
                System.out.println(goods2);
                
                //关闭输入和输入流
                fos.close();
                oos.close();
                fis.close();
                ois.close();            
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }        
        }
    }