IO流使用示例,文件拷贝demo

一、字节流FileInputStream OutputStream

        1. 创建一个输入流
        InputStream fin = new FileInputStream("e:\\igeek\\abc.txt");

        1.2 从流中读取数据
        方式1:一个字节一个字节的读
        int data = 0;
        while(data!=-1)
        {
            data = fin.read();
            System.out.println(data+" ");
        }
        System.out.println();

       方式2:将内容读入到字节数组

        byte[] by = new byte[1024];// 定义一个字节数组(缓冲区)
        int len = fin.read(by);// 从流中读取数据存放到by中,返回具体读了多长数据
        System.out.println("读了"+len+"字节,内容:"+Arrays.toString(by));
        
        byte[] by = new byte[5];
        int len = 0;
        while(len!=-1)
        {
            len = fin.read(by);
            System.out.println("读了"+len+"字节,内容:"+Arrays.toString(by));
        }
        
        关闭文件
        fin.close();

       2. 创建一个输出流
        OutputStream fos = new FileOutputStream("e:\\igeek\\abc.txt");

        21 往流中写入数据
         方式1:
       fos.write('a');
       方式2:
       byte[] by1 = {97,98,99,100,101};// a b c d e
       fos.write(by1);
       方式3:
        fos.write(by1, 2, 3);
       2.3.关闭流
        fos.close();

二、字符流 Writer Reader

 字符流 Writer Reader

      1. 打开文件（读取文件）
        Reader r = new FileReader("e:\\igeek\\a1.txt");
        2. 读取内容
       读取单个字符将字符读入数组。 

       方式1:一个一个读
        int d=0;
        while(d!=-1)
        {
            d = r.read();
            if(d>0)
            {
                char c = (char)d;
               System.out.print(c);
            }
        }
        方式2:读到字符数组中
        char[] buf = new char[1024];// 缓冲区
        int len = 0;
        while(len>-1)
        {
            len = r.read(buf);
            System.out.println("读到长度="+len);
            if(len>0)
            {
                String str = new String(buf);
                System.out.println(str);
            }
        }        
        
         3. 关闭文件
        r.close();

      // 1. 打开文件（写入文件）
        Writer w = new FileWriter("e:\\igeek\\a1.txt");
        // 2. 写入信息
        w.write("Hello,你好!小胖!");
        // 3. 关闭文件
        w.close();

三、缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter

缓冲字节输入流 缓冲字节输出流 BufferedInputStream BufferedOutputStream 处理流    (只是一个辅助的处理流,不能单独存在)；

缓冲字符输入流 缓冲字符输出流 BufferedReader BufferedWriter；

public static void main(String[] args) throws IOException 
    {
        long t1 = System.currentTimeMillis();
        InputStream f1 = new BufferedInputStream(new FileInputStream("e:\\igeek\\test.mp4"));
        OutputStream f2 = new BufferedOutputStream(new FileOutputStream("e:\\igeek\\test2.mp4"));
        byte[] by = new byte[1024];
        int len = 0;
        while(len!=-1)
        {
            // 读取数据到by中,返回的是具体读了多长的数据
            len = f1.read(by);
            if(len>0)
            {
                // 将读取出来的数据写入到新文件中            
                f2.write(by, 0, len);
            }
        }
        f1.close();
        f2.close();
        long t2 = System.currentTimeMillis();
        System.out.println("耗费了"+(t2-t1)+"ms");
        
        // 256 耗费了1824ms
        // 1024 耗费了537ms
        // 2048 耗费了338ms
        // 10240 耗费了144ms
        // 102400 耗费了105ms
        // 1024000 耗费了162ms
        
        // 1024 耗费了289ms
        // 10240 耗费了207ms
    }

四、数据流 DataInputStream DataOutputStream

数据流 (处理流)DataInputStream DataOutputStream

private static void testReadData() throws IOException 
    {
    
        // 1. 打开文件
        DataInputStream input = new DataInputStream(new FileInputStream("e:\\igeek\\data1.txt"));
        
        // 2. 读取数据

        int i = input.readInt();
        byte b = input.readByte();
        float f = input.readFloat();
        boolean b2 = input.readBoolean();
        double d = input.readDouble();
        String str = input.readUTF();
        
        System.out.println(i);
        System.out.println(b);
        System.out.println(f);
        System.out.println(b2);
        System.out.println(d);
        System.out.println(str);
        
        // 3. 关闭文件
        input.close();
    }

    private static void testWriteData() throws IOException {
        // TODO Auto-generated method stub
        
        // 1. 打开文件
        DataOutputStream output = new DataOutputStream(new FileOutputStream("e:\\igeek\\data1.txt"));
        
        // 2. 写入数据
        output.writeInt(10);
        output.writeByte(3);
        output.writeFloat(3.1415F);
        output.writeBoolean(true);
        output.writeDouble(3.1415);
        output.writeUTF("你好");
        
        // 3. 关闭文件
        output.close();
        
        
    }

五、对象流 ObjectInputStream ObjectOutputStream

对象流 ObjectInputStream ObjectOutputStream

类对象要能够写入到对象流需要序列化必须要实现Serializable接口！

 创建一个Dog类

public class Dog implements Serializable{

    String name;
    int age;
    
    // 这个属性不想存档,前面加transient关键字
    transient boolean isOut;
    
    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }
    
    
}
 

对象写入读出：

public class ObjectStreamDemo {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        // TODO Auto-generated method stub

        
        testWrite();
        
        testRead();
    }

    private static void testRead() throws FileNotFoundException, IOException, ClassNotFoundException {
        
        
        // 1. 创建流
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("e:\\igeek\\data2.txt"));
        
        // 2. 读取数据
        Dog d1 = (Dog)in.readObject();
        Dog d2 = (Dog)in.readObject();
        System.out.println(d1);
        System.out.println(d2);
        
        // 3. 关闭流
        in.close();
    }

    private static void testWrite() throws FileNotFoundException, IOException {

        Dog d1 = new Dog("小白",3);
        Dog d2 = new Dog("小黑",5);
        
        // 1. 创建流
        ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("e:\\igeek\\data2.txt"));  
                
        // 2. 写入数据
        o.writeObject(d1);
        o.writeObject(d2);
        
        // 3. 关闭流
        o.close();
        
    }

}

六、内存流 ByteArrayInputStream ByteArrayOutputStream  CharArrayWriter CharArrayReader

      ByteArrayInputStream ByteArrayOutputStream

       // 用流的方式处理字节数组
        ByteArrayOutputStream o = new ByteArrayOutputStream();
         while(o.size()<10)
        {
            // 从我们输入的内容中读一个字节的数据
            int data = System.in.read();
           // 将这个数据写入到o中
            o.write(data);
        }
        byte[] bytes = o.toByteArray();
        System.out.println(Arrays.toString(bytes));
        
        // 原本:
        // 1. 定义数组(先定了数组的大小)
        // 2. 将信息放入数组(自己得确定索引)
        
        // 流的方式:
        // 1. 创建一个字节输出流对象
        // 2. 往里面写入字节信息
        // 3. 通过toByteArray()得到一个字节数组
        
        
        // 输入流:
        byte[] arr = {100,101,102,103,104};
        ByteArrayInputStream in = new ByteArrayInputStream(arr); 
        
        int b = 0;
        while(b!=-1)
        {
            b = in.read();
            if(b!=-1)
            {
                System.out.print(b+" ");
            }
        }
        System.out.println();

       用流的方式操作字符数组 CharArrayWriter CharArrayReader：
        CharArrayWriter w = new CharArrayWriter();
        w.write("你好");
        w.write("I love you!");
        char[] data  = w.toCharArray();
        System.out.println(Arrays.toString(data));
        
        char[] charArr = {'哈','喽','I','l'};
        CharArrayReader r = new CharArrayReader(charArr);
        System.out.println((char)r.read());
        System.out.println((char)r.read());

    StringWriter StringReader ：

      // 输出流
       StringWriter w = new StringWriter();
        w.write("你好");
        w.write(",祖国");
       System.out.println(w.toString());
        
        
        // 输入流
        StringReader r = new StringReader("你好,123abc");
        int d = 0;
        while(d>-1)
        {
            d = r.read();
            System.out.println(d);
            if(d>0)
            {
                char c= (char)d;
                System.out.println(c);
            }
        }
        r.close();// 可以省略

七.文件拷贝demo

/*
 * 使用字符流拷贝一个文件
 * 字符流：字节流+默认编码
 * 使用字符输入流取出文件的信息，字符输入流会自动对读到的数据进行解码（解码方式默认是UTF-8）
 * 之后使用字符输出流将读取到的数据写出到文件中，写出之前会自动对数据进行编码（UTF-8）
 * 因此，如果拷贝图片，会在编码解码过程中出现数据的丢失，导致拷贝后的图片无法打开
 * 使用字节流可以拷贝任意类型的文件，字节流直接拷贝底层二进制文件，不做任何处理
 * 总结：什么时候使用字符流
 * 如果可以使用系统自带的文本编辑工具打开并且不乱码的文件，都可以使用字符流
 * 其余的均使用字节流
 * */
public class Demo4 {

    public static void main(String[] args) throws IOException{
        //1、创建字符输入流对象
        FileReader fr = new FileReader(new File("shi.jpg"));
        //2、创建字符输出流对象
        FileWriter fw = new FileWriter(new File("/Users/igeekhome/shishi.jpg"));
        /*int hasRead = -1;
        while((hasRead = fr.read())!=-1) {
            //hasRead :读到的内容
            fw.write(hasRead);
        }*/
        
        char[] c = new char[1024];
        int length = -1;
        while((length = fr.read(c)) != -1) {
            fw.write(c, 0, length);
        }
        
        fw.close();
        fr.close();
    }

}