JavaIO流基础篇（新手必看）

I/O流

重点：

1. 基本输出和输出
2. 流的分类
3. Java控制台操作
4. Java文件操作
5. 对象的序列化和反序列化

什么是流？

流是一组有序的，有起点（输出）有终点（接收）的数据集合

Java程序中，对于数据的输入输出操作都是以“流”的形式进行

流的本质是数据传输

流所能传输的数据不局限于格式，任何形式的内容都可以流的形式传输

流的分类

• 按照流传输方向
  • 输出流–OutputStream
  • 输入流–InputStream
• 按照处理数据的单位不同
  • 字节流（8位）
  • 字符流（由字节流组成）（16位）
• 按照流的基本功能
  • 节点流
  • 过滤流

JavaIO用途

1. 文件访问
2. 网络访问
3. 内存缓存访问
4. 线程内部通信
5. 缓冲
6. 过滤
7. 解析
8. 读写文本、基本数据类型、对象类型

具体代码案例

控制台读取和输出

public class O1Consle {
    public static void main(String[] args) {
        try{
            InputStreamReader isr = new InputStreamReader(System.in);
            //将一个字符流利用bufferedreader缓冲成一个字符串 成为一行
            BufferedReader bfd = new BufferedReader(isr);
            String reading = "";
            while ((reading=bfd.readLine())!=null){
                System.out.println(reading);
                if (reading.equals("exit")){
                    System.exit(0);
                }
            }
            //归还资源
            isr.close();
            bfd.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文本文件内容的操作（利用字符流）

public class o2ReadAndWrite {
    //利用字节流进行文本操作
    public static void main(String[] args) {
        //输出文本内容
        try{
            FileWriter fw = new FileWriter("c:/hello.txt",true);
            System.out.println("Insert what you want to add into the txt file");
            BufferedReader bfw2 = new BufferedReader(new InputStreamReader(System.in));
            String insert = bfw2.readLine();
            fw.write(insert);
            fw.flush();
            fw.close();
            bfw2.close();
            fw.close();
            System.out.println("Insert Sucesss!");
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("Exception");
        }


        //读取文本内容
        try{
            //选择要读取的文本位置并构建字节流
            FileReader fr = new FileReader("c:/hello.txt");
            //将字节流转换成一行到内存
            BufferedReader bfr = new BufferedReader(fr);

            String reading = "";
            //利用readLine方法读取每一行的内容并判断
            while ((reading=bfr.readLine())!=null) {
                System.out.println(reading);
            }
            bfr.close();
            fr.close();
        }catch(Exception e){
                e.printStackTrace();
                System.out.println("Exception");
        }
    }
}

文件的拷贝

public class copyFile {
    //文件的复制 本质就是先读取在输出 先input 在output
    /*所用到的流
    *FileInputStream===文件输入字节流==确定要读取的流的源文件
    *FileOutputStream ==文件输出字节流===确定要输出的流的文件，如果没有自动new一个
    * BufferedInputStream===缓存字节流===将读取的内容都先存到缓存中
    *
    * 所用到的方法
    * BufferedInputStream.read()  缓存读取数据
    * FileOutputStream.flush     刷新缓存
    *
    * */
    public static void main(String[] args) {
        try{
            FileInputStream fis = new FileInputStream("c:/hello.txt");
            FileOutputStream fos = new FileOutputStream("c:/hellooooo.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            byte []cache = new byte[1024];
            int readnum = 0;
            while ((readnum=bis.read(cache))!=-1){
                fos.write(cache,0,readnum);
            }
            fos.flush();
            fos.close();
            bis.close();
            fis.close();
            System.out.println("Copy Sucess");
        }catch(Exception e){
                e.printStackTrace();
                System.out.println("Exception");
        }


    }
}

JavaBean的冷藏与解冻

public class BeanCar {
    
    /*
    * 冻结所用到的流的种类：
    * FileOutputStream==文件字节输出流
    * ObjectOutputStream==对象字节输出流
    * 方法：
    * ObjectOutputStream.writeObject(Object object);利用输出流，将对象写到要输出的文件上//必须有对象实参
    * 
    * 
    * 解冻流的种类
    * FileInputStream==文件字节输入流
    * ObjectInputStream==对象字节输入流
    * 
    * 
    * 方法
    * ObjectInputStream.readObject();//无参==因为对象输入流在构建时就已经确定了输入流的对象，该方法只需要读即可
    * */
    
//JavaBean的冻结（序列化）与解冻（反序列化） 
    public static void main(String[] args) {
        try{
           //javabean的冻结
            Car car = new Car("BenZ");
            FileOutputStream fos = new FileOutputStream("c:/car.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(car);
            System.out.println("output sucess");

            oos.flush();
            oos.close();
            fos.close();
        }catch(Exception e){
                e.printStackTrace();
                System.out.println("Exception");
        }
        //JavaBean的解冻
        try{
            FileInputStream fis = new FileInputStream("c:/car.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Car car = (Car) ois.readObject();
            System.out.println(car);

        }catch(Exception e){
                e.printStackTrace();
                System.out.println("Exception");
        }


    }

}