javaday16-IO(补充)

一.常用的类

---基类
----InputStream
----OutputStream 
------实现类
---------------------------
-------------FileOutputStream  
-------------FileInputStream
-------------缓冲字节流
-------------BufferedInputStream
-------------BufferedOutputStream
-------------文件字符流
-------------FileWriter
-------------FileReader
-------------缓冲字符流
-------------BufferedWriter
-------------BufferedReder
-------------转换流
-------------InputStreamReader  
-------------OutputStreamWriter
-------------对象数据流
-------------ObjectInputStream
-------------ObjectOutputStream
======================================
-------------PrintStream
-------------DataInputStream (读取基本数据类型)
-------------DataOutputStream

二.常用方法
1.基本概念

字节流：注意事项
包装流：必须先开的后关
缓冲字节流：效率高
    read(byte)
    write(byte,0,len)
字符流：所有的数据存储都是二进制存储的，通过编码----字符-------解码   在字节流的基础上实现
码型转换
/**
ASCII:a  97
GBK:  2个字节是一个字符
UTF-8 ：最多3个字节是一个字符
Unicode ：国际标准的编码
iso-8859-1 javaee
*/

2.————-BufferedInputStream
————-BufferedOutputStream
缓冲字符流速度快的原因是：字符流类自带一个数组存放流

public class BufferedStream_Test {

    public static void main(String[] args) throws IOException {
        File f1=new File("F:/Test/h.txt");
        File f2=new File("F:/Test/w.txt");
        copy(f1,f2);
        System.out.println("复制成功");
    }

    private static void copy(File f1, File f2) throws IOException {
        InputStream inputStream=new FileInputStream(f1);
        BufferedInputStream in= new BufferedInputStream(inputStream);
        OutputStream outputStream=new FileOutputStream(f2);
        BufferedOutputStream out=new BufferedOutputStream(outputStream);
        byte [] buf=new byte[1024];
        int len;//读取的字节个数
        while((len=in.read(buf))!=-1)
        {
            out.write(buf, 0, len);
        }
        //4个流   先开的后关
        out.close();
        in.close();
        outputStream.close();
        inputStream.close();
    }

}

2.文件字符流：FileWriter、FileReader

package day16;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReader_Test {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File f1=new File("F:/Test/h.txt");
        File f2=new File("F:/Test/ww.txt");
        copy(f1,f2);
        System.out.println("复制成功");
    }

    private static void copy(File f1, File f2) throws IOException {
        //字符流
        FileReader in =new FileReader(f1);
        FileWriter out=new FileWriter(f2);
        char [] buf=new char[1024];//缓冲数组
        int len;
        while((len=in.read(buf))!=-1)
        {
            out.write(buf, 0, len);
        }
        out.close();
        in.close();
    }

}

3.缓冲字符流：BufferedWriter、BufferedReder
方法：
注明：缓冲字符流和缓冲字节流的区别在于
类中定义的数组一个是char[],一个是byte[]

readLine();
write(String str);
newLine();//换行

package day16;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Buffer_Reader {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File f1=new File("F:/Test/h.txt");
        File f2=new File("F:/Test/wwww.txt");
        copy(f1,f2);
        System.out.println("复制成功");
    }

    private static void copy(File f1, File f2) throws IOException {
        //缓冲字符流：自带一个缓冲数组
            Reader fileReader=new FileReader(f1);//此处最好使用父类
            BufferedReader in=new BufferedReader(fileReader);//缓冲字符流
            Writer fileWriter=new FileWriter(f2);
            BufferedWriter out=new BufferedWriter(fileWriter);
            String a=null;
            while((a=in.readLine())!=null)//不为null，表示没有到文件末尾  读一行
            {
                out.write(a);//写一行
                out.newLine();//换行
                out.flush();//刷新
            }
            out.close();
            in.close();
            fileWriter.close();
            fileReader.close();
    }

}

4.转换流：InputStreamReader OutputStreamWriter(字节流—字符流的一个桥)
InputStreamReader本身属于字符流(为Reader的子类)

package day16;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class InputStreamReader_Test {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File f1=new File("F:/Test/h.txt");
        File f2=new File("F:/Test/wwwwwww.txt");
        copy(f1,f2);

        System.out.println("复制成功");
    }

    private static void copy(File f1, File f2) throws IOException {
        //字节流   读一个纯文本
        InputStream a1=new FileInputStream(f1);
        Reader aReader=new InputStreamReader(a1); //字节流参数----字符流
        BufferedReader a2=new BufferedReader(aReader);
        //
        OutputStream bOutputStream=new FileOutputStream(f2);
        Writer W=new OutputStreamWriter(bOutputStream);
        BufferedWriter writer=new BufferedWriter(W);
        String a=null;
        while((a=a2.readLine())!=null)
        {
            writer.write(a);
            writer.newLine();
            writer.flush();//刷新
        }
        a2.close();
        aReader.close();
        writer.close();
        W.close();
        bOutputStream.close();
    }

}

5.对象数据流：ObjectOutputStream、ObjectInputStream；
对象类必须实现serilizable接口，序列化
//对象写入文件 输出流 序列化
//对象读取到内存 输入流 反序列化

User类
import java.io.Serializable;
import java.util.Date;
//对象写入文件     输出流    序列化
//对象读取到内存   输入流     反序列化
public class User implements Serializable{

    //1.私有化属性
    private String name;
    private int age;

    //2.get   set
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }
}
-----------
-----------
package day16;

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

public class ObjectInputStream {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // TODO Auto-generated method stub
        OutputStream os=new FileOutputStream("F:/Test/hHHH.txt");//字节流
        ObjectOutputStream oos=new ObjectOutputStream(os);
        User user=new User();
        user.setName("张三");
        user.setAge(50);
        oos.writeObject(user);
        System.out.println("写入成功");
        java.io.ObjectInputStream ois=new java.io.ObjectInputStream(new FileInputStream("F:/Test/hHHH.txt"));

        User user2=(User)ois.readObject();//需要强转
        System.out.println(user2.getName()+user2.getAge());
        oos.close();
        os.close();
    }

}

5.PrintStream//打印流
PrintStream i= new PrintStream(“”);
System.in是一个流/Scanner不是一个流

        InputStream  ins = System.in; // 键盘输入
        int num = ins.read();//读取键盘输入
        System.out.println(num);

6.DataInputStream (读取基本数据类型)/DataOutputStream
对对应的数据类型的数据进行读取写入

package day16;
    import java.io.DataInputStream;  
    import java.io.DataOutputStream;  
    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.io.IOException;  
    public class DataInputStream_Test {
        public static void main(String[] args) {  
            // 使用DataInputStream,DataOutputStream写入文件且从文件中读取数据。  
            try {  
                // Data Stream写到输入流中  
                DataOutputStream dos = new DataOutputStream(new FileOutputStream(  
                        "F:/Test/datasteam.txt"));  
                dos.writeBytes("世界"); //按2字节写入，都是写入的低位  
                dos.writeChars("世界"); // 按照Unicode写入  
                // 按照UTF-8写入(UTF8变长，开头2字节是由writeUTF函数写入的长度信息，方便readUTF函数读取)  
                dos.writeUTF("世界");   
                dos.flush(); //刷新 
                dos.close();  

                // Data Stream 读取  
                DataInputStream dis = new DataInputStream(new FileInputStream(  
                        "F:/Test/datasteam.txt"));  
                // 读取字节  
                byte[] b = new byte[2];  
                dis.read(b);  
                System.out.println(new String(b, 0, 2));  

                // 读取字符  
                char[] c = new char[2];  
                for (int i = 0; i < 2; i++) {  
                    c[i] = dis.readChar();  
                }  
                System.out.println(new String(c, 0, 2));  

                // 读取UTF  
                System.out.println(dis.readUTF());  

                dis.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }