java：IO流（处理流（缓冲流，转换流，数据流），对象的序列化，Properties）

字节缓冲流：（BufferedInputStream，BufferedOutStream）

*按照流的功能来分:节点流和处理流
*节点流可以直接操作数据源:
*InputStream
*--FileInputStream
*OutputStream
*--FileOutputStream
*Reader
*--FileReader
*Writer
*--FileWriter
*处理流:不能直接操作数据源，要结合节点流进行使用，主要作用是用于简化操作和提高效率。
*--缓冲流
*字节缓冲流:BufferedInputStream/BufferedOutputStream
* 优点:降低对磁盘IO的访问频率，提高读写效率。
*java.io.BufferedInputStream类
*常用构造方法:
* BufferedInputStream(InputStream in):创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用
* BufferedInputStream(InputStream in, int size)创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
*常用方法:
* read() 参见 InputStream 的 read 方法的常规协定。
* read(byte[] b, int off, int len) 从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
* close() 关闭此输入流并释放与该流关联的所有系统资源。
*java.io.BufferdOutputStream类：该类实现缓冲的输出流
* 常用的构造方法:
* BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
* BufferedOutputStream(OutputStream out, int size)
* 常用的方法:
* write(int b)将指定的字节写入此缓冲的输出流。
* write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
* flush()刷新此缓冲的输出流。
*
*字符缓冲流:BufferedReader/BufferedWriter
*--转换流:将字节流转换为字符流
*InputStreamReader:将字节输入流转换为字符输入流。
*OutputStreamWriter:将字节输出流转为字符输出流。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestBufferedStream {
    /**
     * 利用缓冲流将D:/mp3/test.mp3复制E:/
     * @param args
     */
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos =null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos =null;
        try {
            fis = new FileInputStream("D:/mp3/test.mp3");
            fos = new FileOutputStream("E:/test.mp3");
            //创建缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            int i;
            while((i=bis.read())!=-){
                bos.write(i);
            }
            bos.flush();//刷新缓冲流(将缓冲流与磁盘同步)
            System.out.println("复制完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bos.close();
                bis.close();
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符缓冲流：（ BufferedReader/BufferedWriter）

* 字符缓冲流:BufferedReader/BufferedWriter
* java.io.BufferedReader类：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
* 构造方法:
* BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流
* BufferedReader(Reader in, int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流。
* 常用的方法:
* readLine() 读取一个文本行。
*
* java.io.BufferedWriter类:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
* 构造方法:
* BufferedWriter(Writer out): 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
* BufferedWriter(Writer out,int size):创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
* 常用方法:
* newLine()写入一个行分隔符。
* flush()刷新该流的缓冲。
* writer(String str):将写入一个字符串。
* close():关闭此流，但要先刷新它。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferedReaderWriter {
    public static void main(String[] args) {
        FileReader reader=null;
        FileWriter writer=null;
        BufferedReader br=null;
        BufferedWriter bw =null;
        try {
            reader = new FileReader("D:/reader.txt");
            writer = new FileWriter("E:/reader.txt");
            br = new BufferedReader(reader);
            bw = new BufferedWriter(writer);
            String str;
            while((str=br.readLine())!=null){
                bw.write(str);
                bw.newLine();
            }
            bw.flush();
            System.out.println("复制完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bw.close();
                br.close();
                writer.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

* 编写一个代码统计器，统计某个目录下的所有代码的行数

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class CodeCounter {
    static long line;
    /**
     * 统计代码的行数
     */
    public static void calcCounter(File file){
        if(file.exists()){
            if(file.isDirectory()){
                File[] fs = file.listFiles();//获取指定目录下的子目录或子文件
                for (File f : fs) {
                    calcCounter(f);//递归调用
                }
            }else{
                //如果是文件，统计该文件中的行数
                String fileName = file.getName();//获取文件名称
                //判断该文件是否为java源文件(后缀为.java)或c的源文件(后缀为.c)
                if(fileName.endsWith(".java")||fileName.endsWith(".c")){
                    try {
                        //使用输入流读取源文件中行数
                        FileReader fr = new FileReader(file);
                        BufferedReader br = new BufferedReader(fr);
                        String str;
                        while((str=br.readLine())!=null){
                            line++;//统计行数
                        }
                        br.close();
                        fr.close();
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }else{
            System.out.println("目录有误!");
        }
    }

    public static void main(String[] args) {
        File file = new File("D:/CFree");
        calcCounter(file);
        System.out.println("总共有"+line+"行代码");
    }
}

转换流:　（InputStreamReader/OutputStreamWriter）

* InputStreamReader:将字节输入流转换为字符输入流,继承了Reader类
* 常用的构造函数:
* InputStreamReader(InputStream in)创建一个使用默认字符集的 InputStreamReader。
*
* OutputStreamWriter:将字节输出流转换为字符输出流
* System.in---->InputStream:标准输入流
* System.out---->PrintStream:标准输出流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class TestConverterIO {
    public static void main(String[] args) {
//        Scanner input = new Scanner(System.in);
//        String line = input.nextLine();
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        OutputStreamWriter osw =null;
        BufferedWriter bw=null;
        try {
            osw = new OutputStreamWriter(new FileOutputStream("D:/aa.txt"));
            bw = new BufferedWriter(osw);//创建一个字符输出缓冲流
            String str = br.readLine()
            while(!str.equals("exit")){
//                System.out.println(str);
                bw.write(str);//将控制台输入的字符串写入到D:/aa.txt文件中
                bw.newLine();//换行
                str = br.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                br.close();
                isr.close();
                bw.close();
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

常用处理流（关闭处理流使用关闭里面的节点流）

• 缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter

　　   ---增加缓冲功能，避免频繁读写硬盘。

• 　　转换流：InputStreamReader OutputStreamReader实现字节流和字符流之间的转换。
• 　　数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.　　

*处理流:
*DataInputStream/DataOutputStream类:方便对java中的基本数据类型和字符串进行操作。二进制文件
*java.io.DataInputStream类:
* 构造方法:DataInputStream(InputStream in)
*常用的方法:readXxx():xxx代表数据类型。
* readInt():读取int类型的数据
* readDouble():读取double类型的数据
* readBoolean():读取boolean类型的数据
* ...
* readUTF():读取字符串类型的数据。
*java.io.DataOutputStream类:
* 构造方法:DataOutputStream(OutputStream out)
*常用的方法:writeXxx():Xxx代表数据类型
* writeInt(int i):写入一个int类型的值
* writeDouble(double d):写入double类型的值

在使用数据流的时候，必须先写入文件内容，再用输入流去读该文件，不然会出现二进制之前转换的错误。

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestDataInputStream {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("D:/data.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            DataInputStream dis = new DataInputStream(bis);
            int i = dis.readInt();
            System.out.println("i="+i);
            double d = dis.readDouble();
            System.out.println("d="+d);
            String str = dis.readUTF();
            System.out.println("str="+str);
            //关闭资源
            dis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataOutputStream {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("D:/data.txt");
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            DataOutputStream dos = new DataOutputStream(bos);
            dos.writeInt();
            dos.writeDouble(3.14);
            dos.writeUTF("hello");
            dos.flush();
            dos.close();
            System.out.println("写入完毕!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

对象的序列化 ObjectOutputStream：

*对象的反序列化:将字节序列转化为java对象的过程。
*为什么要序列化:将对象序列化后变成字节序列可以保存在磁盘或通过网络传输，以实现对象共享(字节序列可以跨平台)。
*序列化的条件:必须实现Serializable 接口
*序列化需要使用ObjectOutputStream类将对象写入到磁盘或网络
*java.io.ObjectOutputStream类继承了OutputStream类，按照功能划分的话属于处理流。
*构造方法:ObjectOutputStream(OutputStream out)
*常用的方法:
* writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class TestObjectOutputStream {
    public static void main(String[] args) {
        Student stu = new Student("张三", , "郑州尚学堂");
        try {
            OutputStream ops = new FileOutputStream("D:/test.obj");
            ObjectOutputStream oos = new ObjectOutputStream(ops);
            oos.writeObject(stu);
            oos.flush();
            oos.close();
            System.out.println("对象写入完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象的序列化 ObjectInputStream：

*对象的反序列化:将字节序列转化为java对象的过程。
*为什么要序列化:将对象序列化后变成字节序列可以保存在磁盘或通过网络传输，以实现对象共享(字节序列可以跨平台)。
*序列化的条件:必须实现Serializable 接口
*反序列化需要ObjectInputStream使用类将字节序列转化为对象
*java.io.ObjectInputStream类继承了InputStream类，按照功能划分的话属于处理流。
*构造方法:ObjectInputStream(InputStream in)
*常用的方法:
* readObject() 将字节序列转为对象。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;

public class TestObjectInputStream {
    public static void main(String[] args) {
        try {
            InputStream ips = new FileInputStream("D:/test.obj");
            ObjectInputStream ois=  new ObjectInputStream(ips);
            Object obj = ois.readObject();
            Student student = (Student)obj;  //若有多个对象，可以用循环
            System.out.println(student);
            ois.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

Properties：

* java.util.Properties类:继承了Hashtable类，采用键值对的方式进行存储。
* *.properties文件存储方式是按照键值对的方式进行存储:key=value 常用的构造方法:
* Properties():创建一个无默认值的空属性列表。 常用的方法: load(InputStream
* inStream)从输入流中读取属性列表（键和元素对）。 getProperty(String key)用指定的键在此属性列表中搜索属性。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class TestProperties {
    public static void main(String[] args) {
        Properties props = new Properties();
        try {
//            InputStream ips = new FileInputStream("D:\\code\\ioDemo\\jdbc.properties");//绝对路径
            InputStream ips = new FileInputStream("jdbc.properties");//相对路径(相对于当前项目的根目录)
            props.load(ips);
            String driver = props.getProperty("driver");
            String url = props.getProperty("url");
            String username = props.getProperty("username");
            String password = props.getProperty("password");
            System.out.println("驱动名称:" + driver);
            System.out.println("资源路径:" + url);
            System.out.println("用户名:" + username);
            System.out.println("密码:" + password);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

world=
china=
henan=
zhengzhou=asdsa