Java基础—IO流（第三节）

FileInputStream（文件字节输入流）

/**
 * 文件字节输入流
 * 第一个程序：理解操作步骤  标准
 * 1）创建源
 * 2）选择流
 * 3）操作
 * 4）释放资源
 */
public class IOTest02 {
    public static void main(String[] args) {
        //1.创建源
        File src = new File("src/com/sxt/abc");
        //2.选择流
        InputStream is = null;
        try {
            is = new FileInputStream(src);
            //3.操作（读取）
            int temp;
            while ((temp=is.read())!=-1){
                System.out.println((char)temp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //4.释放资源
            try {
                if (null!=is){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 四个步骤：分段读取
 * 1）创建源
 * 2）选择流
 * 3）操作
 * 4）释放资源
 */
public class IOTest04 {
    public static void main(String[] args) {
        //创建源
        File src = new File("src/IO_study02/abc");
        //选择流
        InputStream is = null;
        try {
            is = new FileInputStream(src);
            //操作（分段读取）
            byte[] flush = new byte[1024]; //缓冲容器
            int len = -1;
            //字节数组--->字符串（解码）
            if((len=is.read(flush))!=-1){
                String str = new String(flush,0,len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //释放资源
            try {
                if(null!=is){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileOutputstream（文件字节输出流）

/**
 * 文件字节输出流
 * 1.创建源
 * 2.选择流
 * 3.操作（写出内容）
 * 4.释放资源
 */
public class IOTest04 {
    public static void main(String[] args) {
        //创建源
        File src = new File("dest.txt");
        //选择流
        OutputStream os = null;
        try{
            os = new FileOutputStream(src,true);
            //操作
            String msg = "IO is so easy";
            byte[] datas = msg.getBytes(); //字符串--->字节数组（编码）
            os.write(datas,0,datas.length);
            os.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            //释放资源
            if(null!=os){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

Reader（文件字符输入流）

/**
 * 文件字符输入流
 */
public class IOTest02 {
    public static void main(String[] args) {
        //创建源
        File src = new File("src/IO_study02/abc");
        //选择流
        Reader reader = null;
        try {
           //操作
            reader = new FileReader(src);
            char[] datas = new char[3];
            int len = -1;
            while ((len=reader.read(datas))!=-1){
                String str = new String(datas,0,len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
           //释放资源
            try {
                if(null!=reader){
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
结果：（一次打印三个字符）

Writer（文件字符输出流）

/**
 * 文件字符输出流
 */
public class IOTest03 {
    public static void main(String[] args) {
        //创建源
        File src = new File("src/IO_study02/abc");
        //选择流
        Writer writer = null;
        try {
           //操作
            writer = new FileWriter(src);
            //写法一
            String msg = "总有一天，通过我自己的努力，会得到我想要的东西";
            char[] datas = msg.toCharArray();
            writer.write(datas,0,datas.length);
            
            
            //写法二
            String msg1 = "星光不问赶路人，时光不负有心人";
            writer.write(msg1);
            writer.flush();
            
            //写法三
            writer.append("Everything is possible").append("但行好事，不问前程");
            writer.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
           //释放资源
            try {
                if(null!=writer){
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

ByteArrayInputStream（字节数组输入流）

/**
 * 字节数组输入流（可以不用释放资源）
 */
public class IOTest04 {
    public static void main(String[] args) {
        //创建源
        byte[] src = "I believe I can fly".getBytes();
        //选择流
        InputStream is = null;
        try {
            //操作
            is = new ByteArrayInputStream(src);
            byte[] datas = new byte[1024];
            int len = -1;
            while ((len=is.read(datas))!=-1){
                String str = new String(datas,0,len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //释放资源：可以不要
            try {
                if(null!=is){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

ByteArrayOutputStream（字节数组输出流）

/**
 * 1.创建源：内部维护
 * 2.选择流：不关联源
 * 3.操作（写出内容）
 * 4.释放资源：可以不用
 * 获取数据：toByteArray
 * 字节数组输出流 ByteArrayOutputStream
 */
public class IOTest09 {
    public static void main(String[] args) {
        //创建源:字节数组，不要太大
        byte[] dest = null;
        //选择流
        ByteArrayOutputStream baos = null;
        try{
            baos = new ByteArrayOutputStream();
            //操作(写出）
            String msg = "talk is cheap show me the code";
            byte[] flush = msg.getBytes();//字符串--->字节
            baos.write(flush,0,flush.length);
            baos.flush();
            //获取数据
            dest = baos.toByteArray();
            System.out.println(dest.length+"--->"+new String(dest,0,baos.size()));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //释放资源：可以不要，放在这里是为了风格统一
            if(null!=baos){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}