IO流

#    流
####    InputStream
InputStream表示字节输入流的父类,这是个抽象类，我们可以使用其子类FileInputStream

    InputStream in = null;
    try {
        //1、创建一个输入流（字节输入）跟文件关联
        in = new FileInputStream("E:\\abc\\123.txt");
        int content;
        //2、读取内容
        while ((content = in.read()) != -1) { // 如果读到末尾会返回-1
            // 处理读出来的内容
            System.out.print((char) content);
        }
        // 读完了
    }catch(Exception e){

    }finally{
        //3、关闭流
        if (null != in) {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
第二种读取方式：自定义一个缓冲大小（读的过程）

    //用byte数组来定义缓冲区
    byte[] buffer = new byte[1024];
    int num;
    while ((num = in.read(buffer)) != -1) {
        //处理数据... 数据在buffer中从0-num有效
    }

			InputStream in = null;
		try {
			in = new FileInputStream(new File("E:\\abc\\123\\wm.txt"));
			// 读取内容
			byte[] buffer = new byte[3];  //6
			int count = 0;
			// 缓冲区中的数据总量
			int num;
			while ((num = in.read(buffer)) != -1) {
				count++;
				for (int i = 0; i < num; i++) {
					System.out.println((char) buffer[i]);
				}
				System.out.println("第"+count+"次");
			}
			// 读完了
			System.out.println("总共读取了"+count+"次");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != in) {
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

####    OutputStream
将内容从程序中写到文件中

    //1、创建一个输出流（跟文件关联通道）
    OutputStream out = null;
    try {
        //输出的目标文件夹一定要存在
        out = new FileOutputStream("E:\\abc\\456.txt");
        String str = "Hello123";
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //将内容按字节写到文件中
            out.write(c);
        }
        //写完了
        System.out.println("写完了");
    }catch(Exception e){

    }finally{
        //关闭流
        out.close();
    }
####    缓冲流
辅助流，字节输入有BufferenInputStream，字节输出BufferedOutputStream,使用方式：套在原始流上

    InputStream in = null;
    BufferedInputStream bi = null;
    // 缓冲输出流
    BufferedOutputStream bOut = null;
    ...
    // 直接对接磁盘
    in = new FileInputStream("E:\\abc\\123.txt");
    // 输入流上加缓冲流
    bi = new BufferedInputStream(in);
    bOut = new BufferedOutputStream(new FileOutputStream("E:\\abc\\def\\hello.txt"));
        //读写操作跟普通流一样
注意：缓冲输出流在关闭之前建议加上flush

    bOut.flush();
    bOut.close();

####    装饰者模式
实现辅助其他对象提升功能的效果,需要的元素

    1、抽象角色（Person,InputStream）
    2、具体的角色类（干活的）(Coder，FileInputStream)
    3、装饰者角色（Manager，FilterInputStream）
    4、具体的装饰角色（ZuZhang,JingLi,BufferedInputStream,DataInputStream）

4可以套2来提升2的功能

####    DataOutputStream & DataInputStream
原子类型（基本数据类型）输出流，辅助流（装饰者），辅助InputStream实现按原子类型输出，DataInputStream也一样，辅助原子类型输入

    //写操作
    DataOutputStream out = new DataOutputStream(
        new    FileOutputStream("E:\\abc\\data.txt"));
    //输出内容（按类型）
    out.writeInt(50);
    out.writeBoolean(true);
    out.writeUTF("你好abc");

    //关闭
    out.close();

    //读操作（注意顺序要和写的顺序一致）
    DataInputStream in = new DataInputStream(new FileInputStream("E:\\abc\\data.txt"));

    //读内容
    int a = in.readInt();
    boolean b = in.readBoolean();
    String str = in.readUTF();

    //关闭
    in.close();

####    字符流
按字符的大小输入或者输出，输入用Reader的子类，输出用Writer子类

    Reader r = new FileReader("E:\\abc\\123.txt");
    //使用缓冲字符输入流
    BufferedReader br = new BufferedReader(r);
    //读取内容（普通的读取方式，一次一个字符）
    int content;
    while((content = br.read())!=-1){
        System.out.print((char)content);
    }

基于缓冲读取（可以按行来读取）

    String str ;
    while((str = br.readLine())!=null){
        System.out.println(str);
    }

关闭流

    r.close();
    br.close();
#####    字符输出流

    Writer w = new FileWriter("E:\\abc\\www.txt");
    
    如果要在原来的基础上添加内容那么可以在构造时添加append变量值为true
    Writer w = new FileWriter("E:\\abc\\www.txt",true);    

    //加上缓冲输出
    BufferedWriter bw = new BufferedWriter(w);

    //写内容到磁盘
    bw.write("你好你好阿大使大赛肯德基阿萨德");

    //缓冲流关闭之前要flush
    bw.flush();
    
    //关闭
    bw.close();
    w.close();
####    流关系

                字节流                    字符流
    输入流        InputStream                Reader
    输出流        OutputStream            Writer
用他们的子类：FileInputStream，FileOutputStream，FileReader，FileWriter

缓冲流

                字节                        字符
    输入        BufferedInputStream        BufferedReader
    输出        BufferedOutputStream    BufferedWriter
#####    RandomAccessFile
随机存取的二进制文件

    //构造的第二参数表示操作的模式，r表示读 w表示写 
    RandomAccessFile ra = new RandomAccessFile(new File("E:\\abc\\ra.txt"),"rw");

    //设置大小为2k
    ra.setLength(2048);

    ra.writeInt(500);
    ra.writeUTF("你好");
    //从1k的位置开始写
    ra.seek(1024);
    ra.writeUTF("abc");

####    Properties
键值对存取文件（一般可以用作一些配置文件）

读：
    
    FileInputStream in = new FileInputStream("E:\\abc\\config.ini");
    //创建Properties
    Properties p = new Properties();
    //加载文件
    p.load(in);
    //按键取值
    String color = p.getProperty("color");
    //带默认值的读取
    String abc = p.getProperty("abc", "默认值"); 
    String fontSizeStr = p.getProperty("fontSize");

    //关闭流
    in.close();

写：

    //输出流关联要写到的文件
    FileOutputStream out = new FileOutputStream("E:\\abc\\config.ini");
    Properties p = new Properties();
            
    //设置要保存的属性(键值对)
    p.setProperty("fontSize", "2000");
    p.setProperty("color", "blue");
    p.setProperty("mode", "night");
    p.setProperty("menuType", "right");
    //保存
    p.store(out, "122222");

    //关闭流
    out.flush();
    out.close();
注意：修改内容不覆盖原来的内容一定要先用输入流加载文件到Properties中，关闭输入流之后修改再保存，如：

    FileInputStream in = new FileInputStream("E:\\abc\\config.ini");
    //创建Properties
    Properties p = new Properties();
    //加载文件
    p.load(in);
    in.close();  //修改之前关闭
    
    //设置要保存的属性(键值对)
    p.setProperty("fontSize", "20");
    p.setProperty("color", "red");
    FileOutputStream out = new FileOutputStream("E:\\abc\\config.ini");
    //保存
    p.store(out, "aaaaaa");
    
    out.flush();
    out.close();

		File file=new File("D:\\abc\\qwe.txt");
		Properties p=new Properties();
		if(file.exists()){
			FileInputStream in=null;
			try {
				 in=new FileInputStream(file);
				p.load(in);
			} catch (Exception e) {
				e.printStackTrace();
			}finally{
				try {
					in.close();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			try {
				FileOutputStream out=new FileOutputStream(file);
				p.setProperty("fontSize", "2000");
				p.store(out, "修改的备注");
				System.out.println("保存成功");
				out.flush();
				out.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

####    PrintWriter

    //创建打印机对象,第二个参数autoFlush可以省略，加上为true的意思是自动刷新缓冲区
    PrintWriter pw = new PrintWriter(new FileOutputStream(
                    "E:\\abc\\print.txt"),true);
    //输出内容（不换行）
    pw.print("Hello123");

    //换行输出
    pw.println("你好abc");

    //关闭
    pw.close();