Java API —— IO流

package iodemos;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
* 需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
*         A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
*         B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
* 通过上面的分析后我们知道要使用：OutputStream
* 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
* 所以，我们要找一个具体的子类。
* 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
* 文件是哪个单词：File
* 然后用的是字节输出流，联起来就是：FileOutputStream
* 注意：每种基类的子类都是以父类名作为后缀名。
*         XxxOutputStream
*         XxxInputStream
*         XxxReader
*         XxxWriter
* 查看FileOutputStream的构造方法：
*         FileOutputStream(File file)
*        FileOutputStream(String name)
*
* 字节输出流操作步骤：
*         A:创建字节输出流对象
*         B:写数据
*         C:释放资源
*/
public class IODemo01 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        // FileOutputStream(File file)
//        File file = new File("fos.txt");
//        FileOutputStream fos = new FileOutputStream(file);
        // FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("fos.txt");
        /*
         * 创建字节输出流对象了做了几件事情：
         * A:调用系统功能去创建文件
         * B:创建fos对象
         * C:把fos对象指向这个文件
         */
        //写数据
        fos.write("hello,IO".getBytes());
        fos.write("java".getBytes());
        //释放资源
        //关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
        /*
         * 为什么一定要close()呢?
         * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
         * B:通知系统去释放跟该文件相关的资源
         */
        //java.io.IOException: Stream Closed
        //fos.write("java".getBytes());
    }
}

package iodemos;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 字节输出流操作步骤：
 * A:创建字节输出流对象
 * B:调用write()方法
 * C:释放资源
 *
 * public void write(int b):写一个字节
 * public void write(byte[] b):写一个字节数组
 * public void write(byte[] b,int off,int len):写一个字节数组的一部分
 */
public class IODemo02 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        // OutputStream os = new FileOutputStream("fos2.txt"); // 多态
        FileOutputStream fos = new FileOutputStream("fos2.txt");
        // 调用write()方法
        //fos.write(97); //97 -- 底层二进制数据    -- 通过记事本打开 -- 找97对应的字符值 -- a
        // fos.write(57);
        // fos.write(55);
        //public void write(byte[] b):写一个字节数组
        byte[] bys = {97,98,99,100,101};
        fos.write(bys);
        //public void write(byte[] b,int off,int len):写一个字节数组的一部分
        fos.write(bys,1,3);
        //释放资源
        fos.close();
    }
}

package iodemos;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 如何实现数据的换行?
 *         为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
 *         如何实现呢?写入换行符号即可。
 *         有些文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
 *         因为不同的系统针对不同的换行符号识别是不一样的?
 *         windows:\r\n
 *         linux:\n
 *         Mac:\r
 *         而一些常见的个高级记事本，是可以识别任意换行符号的。
 *
 * 如何实现数据的追加写入?
 *         用构造方法带第二个参数是true的情况即可
 */
public class IODemo03 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        //FileOutputStream fos = new FileOutputStream("fos3.txt");
        // 创建一个向具有指定 name 的文件中写入数据的输出文件流。
        // 如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
        FileOutputStream fos = new FileOutputStream("fos3.txt",true);
        // 写数据
        for (int x = 0; x < 10; x++) {
            fos.write(("hello"+x).getBytes());
            fos.write("\r\n".getBytes());
        }
        // 释放资源
        fos.close();
    }
}

package iodemos;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 加入异常处理的字节输出流操作
 */
public class IODemo04 {
    public static void main(String[] args) {
        // 分开做异常处理
//        FileOutputStream fos = null;
//        try {
//            fos = new FileOutputStream("fos04.txt");
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        }
//        try {
//            fos.write("java".getBytes());
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        try {
//            fos.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
        // 一起做异常处理
//        try {
//            FileOutputStream fos = new FileOutputStream("fos04.txt");
//            fos.write("java".getBytes());
//            fos.close();
//        }catch (FileNotFoundException e){
//            e.printStackTrace();
//        }catch (IOException e){
//            e.printStackTrace();
//        }
        // 改进版
        // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream("fos04.txt");
            fos.write("java".getBytes());
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            // 如果fos不是null，才需要close()
            if(fos != null){
                // 为了保证close()一定会执行，就放到这里了
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package inputstream;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 字节输入流操作步骤：
 * A:创建字节输入流对象
 * B:调用read()方法读取数据，并把数据显示在控制台
 * C:释放资源
 *
 * 读取数据的方式：
 * A:int read():一次读取一个字节
 * B:int read(byte[] b):一次读取一个字节数组
 */
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        // FileInputStream(String name)
        FileInputStream fis = new FileInputStream("fis.txt");
        // 调用read()方法读取数据，并把数据显示在控制台
        // 用循环改进
//        int by = fis.read();
//        while (by != -1) {
//            System.out.print((char) by);
//            by = fis.read();
//        }
        // 最终版代码
        int b = 0;
        // 读取，赋值，判断
        while ((b = fis.read()) != -1) {
            System.out.print((char) b);
        }
        //释放资源
        fis.close();
    }
}

package iodemos;
import java.util.Arrays;
/*
 * 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
 * 在计算机中中文的存储分两个字节：
 *         第一个字节肯定是负数。
 *         第二个字节常见的是负数，可能有正数。但是没影响。
 */
public class IODemo06 {
    public static void main(String[] args) {
        //String s = "abcde";
        //[97, 98, 99, 100, 101]
        String s = "我爱你中国";
        //[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
        
        byte[] bys = s.getBytes();
        System.out.println(Arrays.toString(bys));
    }
}

package iodemos;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
public class IODemo10 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream fis = new FileInputStream("fis2.txt");
        // 数组的长度一般是1024或者1024的整数倍
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len)); //千万要带上len的使用
        }
        // 释放资源
        fis.close();
    }
}

package iodemos;
import inputstream.FileInputStreamDemo01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 复制文本文件。
 *
 * 数据源：从哪里来
 * a.txt    --    读取数据    --    FileInputStream
 *
 * 目的地：到哪里去
 * b.txt    --    写数据        --    FileOutputStream
 *
 * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
 *
 * 这一次复制中文没有出现任何问题，为什么呢?
 * 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
 * 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
 * 它会自己做转换。
 */
public class IODemo05 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("a.txt");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("b.txt");
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        // 释放资源(先关谁都行)
        fis.close();
        fos.close();
    }
}

package iodemos;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
public class IODemo11 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\a\\a.txt");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("c:\\b\\b.txt");
        // 复制数据
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

package iodemos;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 需求：把c:\\aa.jpg内容复制到当前项目目录下的mn.jpg中
 *
 * 数据源：
 *         c:\\aa.jpg    --读取数据--FileInputStream
 * 目的地：
 *         mn.jpg--写出数据--FileOutputStream
 */
public class IODemo08 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\aa.jpg");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("mn.jpg");
        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

package iodemos;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 需求：把c:\\abc.mp4复制到当前项目目录下的copy.mp4中
 *
 * 数据源：
 *         c:\\abc.mp4--读取数据--FileInputStream
 * 目的地：
 *         copy.mp4--写出数据--FileOutputStream
 */
public class IODemo09 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\abc.mp4");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("copy.mp4");
        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

package iodemos;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
public class IODemo12 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\abc.mp4");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("copy.mp4");
        // 复制数据
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

package iodemos;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
 */
public class IODemo14 {
    public static void main(String[] args) throws IOException {
        // BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
        // 读取数据
//        int by = 0;
//        while ((by = bis.read()) != -1) {
//            System.out.print((char) by);
//        }
        int len = 0;
        byte[] bys = new byte[1024];
        while ((len = bis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }
        // 释放资源
        bis.close();
    }
}

package cn.itcast_06;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节：    共耗时：117235毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
 * 高效字节流一次读写一个字节： 共耗时：1141毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
 */
public class CopyMp4Demo {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        // method1("e:\\哥有老婆.mp4", "copy1.mp4");
        // method2("e:\\哥有老婆.mp4", "copy2.mp4");
        // method3("e:\\哥有老婆.mp4", "copy3.mp4");
        method4("e:\\哥有老婆.mp4", "copy4.mp4");
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
    // 高效字节流一次读写一个字节数组：
    public static void method4(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
    // 高效字节流一次读写一个字节：
    public static void method3(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));
        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
    // 基本字节流一次读写一个字节数组
    public static void method2(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }
    // 基本字节流一次读写一个字节
    public static void method1(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}