菜鸡学习day20_IO流&OutputStream类&FileOutputStream类&字节输入流（InputStream类&FileInputStream类）&字符流。。。

菜鸡学习day20

package day20;

import java.io.*;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

/*
IO流
Input Output

OutputStream类，是抽象类
输出字节流的所有类的超类
FileOutputStream类
把内存中的数据写入硬盘的文件中
构造方法
FileOutputStream（String name）创建一个向具体指定名称的文件中写入数据的输出文件夹
FileOutputStream（File file）创建一个向指定File对象表示的文件中写入数据的输出文件夹
 String name 目的地是一个文件的路径
 File file目的地是一个文件
 作用：1.创建一个FileOutputStream对象
      2.根据文件/文件路径，创建一个空文件
      3.把FileOutputStream对象指向空文件
 写入数据的原理：程序-JVM-OS（操作系统）-OS调用写数据的方法-写入数据
步骤：1.创建一个FileOutputStream对象
     2.调用对象的方法write，写入数据
     3.释放资源
一些子类共性的成员方法
public void close（）关闭输出流，释放资源
public void flush（）刷新此输出流并强制任何缓冲的输出字节被写入
public void write（byte【】b）一次写多个字节
public void write（byte[]b,int off,int len）
如果写的第一个字节是正数（0-127），则查询asc表
若是负数，则第一二个字节组成中文字符，查询默认码表
public abstract void write（int b）

续写
使用两个参数的构造方法，判断有没有创建过，true就不会覆盖掉，续写
FileOutputStream（String name，boolean append）
FileOutputStream（File file，boolean append）

字节输入流
InputStream类
输入字节流的所有类的超类
一些子类共性的成员方法
int read（）从输入流中读取下一字节,指针，若读取到末尾一直返回-1
int read（byte【】b）一次读取多个字节 读出一段字节，存入b中
void close（）关闭输入流并释放资源
FileInputStream类
文件字节输入流，把硬盘文件中的数据，读取到内存中使用
构造方法
FileInputStream（String name）
FileInputStream（File file）

读取字节数据
读取原理：程序-JVM-OS-OS读取数据的方法-读取文件
步骤：1.创建一个FileInputStream对象
     2.调用对象的方法read，写入数据
     3.释放资源

字符流
使用字节流读取中午呢文件
1个中文 BGK占用2个字节 UTF-8占用3个字节
Reader类     字符输入流
读取字符流的所有类的超类，抽象类
共性的成员方法
int read（）读取单个字符并返回
int read（（char【】cbuf））多个
void close（）

FileReader文件字符输入流
把硬盘文件中的数据一字符形式读取到内存中
构造方法
FileReader（String name）
FileReader（File file）

Writer字符输出流
写入字符流的所有类的超类，抽象类
共性的成员方法
int write（int i）
int write（（char【】cbuf））
abstract void write（char【】cbuf，int off，int len）
void write（String str）
void write（String str，int off，int len）
void flush()
void close（）
注：flush和close的区别
    flush先刷新缓冲区，流对象可以继续使用
    close先刷新缓冲区，然后释放资源，对象不能继续使用

FileWriter文件字符输出流
构造方法
FileWriter（String name）
FileWriter（File file）
注：先将数据写入到内存缓冲区（字符转换为字节），再用flush刷新到文件中
    最后直接使用close也会自动使用flush刷新，所以可以省略

续写和换行

属性集
Properties集合    extends Hashtable
是唯一和IO流相结合的集合
可使用集合中的方法store把集合中的临时数据持久化写入到硬盘中
可使用集合中的方法load把硬盘中的文件读取到集合中使用
属性列表中每个键及其对应值都是一个字符串
Properties集合是一个双列集合，key和value默认都是字符串

操作字符串特有方法
存储和遍历
Object setProperty（String key，String value）调用Hashtable的方法put
String getProperty（String key）通过key找到value值，相当于Map
store数据写入硬盘
void store（IutputStream out，String comments）//字节流，可写中文
void store（Writer writer，String comments）//字符流，不能写中文
Writer writer和IutputStream out为写入的对象
comments注释，不能用中文，一般为空字符串

load把硬盘中的文件，读取到集合中使用
void load（InputStream inStream）字节流，不能读取中文
void load（Reader reader）字符流
注：储存键值对的文件中，键与值默认的连接符号可以使用等号，空格（其他符号）
    ------------------可以使用#进行注释，注释内容不会被读取
    ------------------键与值默认为字符串，不用加引号

 */
public class D2001 {
    public static void main(String[] args) throws IOException {
       // output01();//输出字节流
       // input01();//输入字节流
        //fuZhi01();//复制文件
        //reader01();
       // write01();
        shuXingJi01();//属性集方法
    }

    private static void output01() throws IOException {
        FileOutputStream fos1 = new FileOutputStream("day20\\a.txt");
        fos1.write(42);
        byte[] b1 = {65,66,66,67,68,69};
        fos1.write(b1);
        fos1.write(b1,2,2);
        byte[] b2 = "你好!\n".getBytes();//字符串
        fos1.write(b2);
        fos1.close();

        FileOutputStream fos2 = new FileOutputStream("day20\\a.txt",true);
        fos2.write(b2);
        fos2.close();
    }

    private static void input01() throws IOException {
        FileInputStream fis = new FileInputStream("day20\\a.txt");
//        int i= 0;
//        while((i = fis.read()) != -1){
//            System.out.println((char)i);//你好变成了奇怪的东西
//        }

//        byte[]b = new byte[1024];
//        fis.read(b);
//        System.out.println(new String(b));//转为字符串，你好出现了

        byte[]b = new byte[1024];
        int i = 0;
        while((i = fis.read(b)) != -1){
            System.out.println(new String(b));
        }
        fis.close();
    }

    private static void fuZhi01() throws IOException {//复制文件
        long s = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("day20\\b.txt");
        FileOutputStream fos = new FileOutputStream("day20\\c.txt");
        byte[]b = new byte[1024];
        int i = 0;
        while((i = fis.read(b)) != -1){
            System.out.println(new String(b));
        }
        fos.write(b);
        fos.close();//先关读取
        fis.close();
        long e = System.currentTimeMillis();
        System.out.println("共耗时" + (e - s) + "ms.");//0ms???
    }

    private static void reader01() throws IOException {
        FileReader fr = new FileReader("day20\\b.txt");
        char[] c = new char[1024];
        int i =0;
        while(( i =fr.read(c)) != -1){
            System.out.println(new String(c,0,i));
        }
        fr.close();
    }

    private static void write01() throws IOException {
        FileWriter fw = new FileWriter("day20\\b.txt",true);
        fw.write(97);
        fw.write("12345\n");
        fw.write("a bcde",1,3);
        //fw.flush();
        fw.close();
    }

    private static void shuXingJi01() throws IOException {
        Properties pro1 = new Properties();
        pro1.setProperty("小明","18");
        pro1.setProperty("小红","14");
        pro1.setProperty("小周","17");
        Set<String> set = pro1.stringPropertyNames();
        Iterator<String> iter = set.iterator();
        String key;
        while (iter.hasNext()){//遍历
            key = iter.next();
            String value = pro1.getProperty(key);
            System.out.println(key + "," + value);
        }

        FileWriter fw = new FileWriter("day20\\c.txt",true);
        pro1.store(fw,"save data");//在fw中写入pro1的数据
        fw.close();

        FileReader fr = new FileReader("day20\\c.txt");
        pro1.load(fr);
        Set<String> set1 = pro1.stringPropertyNames();
        for(String key1 : set1){
            String value = pro1.getProperty(key1);
            System.out.println(key1 + "," + value);
        }
    }
}