黑马程序员_java语言_IO流

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

###13.01_IO流(IO流概述及其分类)
* 1.概念
    * IO流用来处理设备之间的数据传输
    * Java对数据的操作是通过流的方式
    * Java用于操作流的类都在IO包中
    * 流按流向分为两种：输入流，输出流。
    * 流按操作类型分为两种：
        * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
        * 字符流 : 字符流只能操作纯字符数据，比较方便

字节流
    字节输入流：InputStream
    字节缓冲输入流： BufferedInputStream
    字节输出流：OutputStream
    字节缓冲输出流： BufferedOutputStream
  字符流
    字符输入流：Reader
    字符输出流：Writer
  什么时候用字节流？ 什么时候用字符流？？
    使用系统自带的记事本打开，里面的内容都可以看懂，那么使用，字符流
  其他情况，都使用字节流
  如果分不清楚， 统统使用字节流 (万能的)

* 2.IO流常用父类
    * 字节流的抽象父类：
        * InputStream 
        * OutputStream
    * 字符流的抽象父类：
        * Reader 
        * Writer        
* 3.IO程序书写

* 使用前，导入IO包中的类
    * 使用时，进行IO异常处理
    * 使用后，释放资源

###13.02_IO流(FileInputStream)

<span style="font-size:14px;color:#000000;">/* * 演示通过IO流，完成文件的 读写操作 */public class IODemo {public static void main(String[] args) throws IOException {//写数据到 小说.txt//write();//读小说.txt中的内容read();}private static void read() throws IOException {//以读数据的方式，打开小说.txtFileInputStream fis = new FileInputStream("小说.txt");//读数据int ch = fis.read();//97System.out.println((char)ch);//关闭文件fis.close();}private static void write() throws IOException {//以写入数据的方式，打开小说.txt FileOutputStream fos = new FileOutputStream("小说.txt");//写数据fos.write('a');//97//关闭文件fos.close();}}</span>

<span style="font-size:14px;"></span>

###13.03_IO流(FileInputStream返回值为什么是int)
* read()方法读取的是一个字节,为什么返回是int,而不是byte
      因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111
        那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上
        24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型
###13.04_IO流(FileOutputStream)
* write()一次写出一个字节

<span style="font-size:14px;color:#000000;">        FileOutputStream fos = new FileOutputStream("bbb.txt");    //如果没有bbb.txt,会创建出一个        //fos.write(97);                        //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte        fos.write(98);        fos.write(99);        fos.close();</span>

*###13.05_IO流(FileOutputStream追加)

OutputStream: 此抽象类是表示字节输出流的超类
 *
 * 由于它是抽象类，所以，我们创建对象需要通过子类来完成，由于我们操作的是文件，所以我们使用的是文件的字节输出流
 * FileOutputStream
 *
 *  构造方法：
 *   public FileOutputStream(File file) 通过File对象 ， 创建 文件字节输出流对象
 *   public FileOutputStream(String name)通过文件的字符串路径 ， 创建 文件字节输出流对象
* A:案例演示
    * FileOutputStream的构造方法写出数据如何实现数据的追加写入

<span style="font-size:14px;">public class FileOutputStreamDemo {public static void main(String[] args) throws FileNotFoundException {//public FileOutputStream(File file)//File file = new File("E:\\test\\abc.txt");//创建字节输出流对象//FileOutputStream fos = new FileOutputStream(file);//public FileOutputStream(String name)FileOutputStream fos = new FileOutputStream("E:\\test\\abc.txt"); }}</span>

###13.06_IO流(拷贝图片)
* FileInputStream读取
* FileOutputStream写出

用代码实现图片的拷贝：

<span style="font-size:14px;">public class IOTest4 {public static void main(String[] args) throws IOException {//1： 创建字节输入流对象，封装数据源  aaa.jpgFileInputStream fis = new FileInputStream("aaa.jpg");//2： 创建字节输出流对象，封装目的地 Copy.jpgFileOutputStream fos = new FileOutputStream("Copy.jpg");//3:读数据byte[] bys = new byte[1024];//存储每次读取到的字节int len = -1; //用来存储每次读取到了多少个新的字节的数量while ((len = fis.read(bys)) != -1) {//4:写数据fos.write(bys, 0, len);}//5:关闭流fos.close();fis.close();}}</span>

###13.07_IO流(练习)
* A:案例演示
    * 字节流一次读写一个字节复制文件

   通过字节流，来完成文本文件的复制 (一次一个字节数组)
 *   将UIUtil.java 文件中的内容    复制到Copy.java文件中
 * 分析：
 *   1：创建字节输入流对象，并封装数据源
 *   2：创建字节输出流对象，并封装目的地
 *   3：读数据
 *   4：写数据
 *   5：关闭
* 弊端:效率太低，代码演示：

<span style="font-size:14px;">public class IOTest3 {public static void main(String[] args) throws IOException {//1：创建字节输入流对象，并封装数据源FileInputStream fis = new FileInputStream("UIUtil.java");//2：创建字节输出流对象，并封装目的地FileOutputStream fos = new FileOutputStream("Copy.java");//3：读数据byte[] bys = new byte[1024];// 1024字节 = 1kb ，在开发中 通常数组会定义成1kb,2kb,4kb,8kb// 用来存储每次读取到的字节int len = -1; // 记录每次读取到了多少个新字节的数量while ((len = fis.read(bys)) != -1) {//4：写数据fos.write(bys, 0, len);}//5：关闭流fis.close();fos.close();}}</span>

###13.08_IO流(字节数组拷贝之available()方法)
* A:案例演示
    * int read(byte[] b):一次读取一个字节数组
    * write(byte[] b):一次写出一个字节数组
    * available()获取读的文件所有的字节个数

* 弊端:有可能会内存溢出 

<span style="font-size:14px;">  FileInputStream fis = new FileInputStream("致青春.mp3");        FileOutputStream fos = new FileOutputStream("copy.mp3");        byte[] arr = new byte[fis.available()];                    //根据文件大小做一个字节数组        fis.read(arr);                                            //将文件上的所有字节读取到数组中        fos.write(arr);                                            //将数组中的所有字节一次写到了文件上        fis.close();        fos.close();</span>

###13.09_IO流(BufferedInputStream和BufferOutputStream拷贝)
* A:缓冲思想
    * 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
    * 这是加入了数组这样的缓冲区效果，java本身在设计的时候，
    * 也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流
* B.BufferedInputStream
    * BufferedInputStream内置了一个缓冲区(数组)
    * 从BufferedInputStream中读取一个字节时
    * BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
    * 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
    * 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
* C.BufferedOutputStream
    * BufferedOutputStream也内置了一个缓冲区(数组)
    * 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
    * 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里
* D.代码实现：

<span style="font-size:14px;">public class BufferedInputStreamDemo {public static void main(String[] args) throws IOException {//创建字节缓冲输入流对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("小说.txt"));//读数据byte[] bys = new byte[1024];int len = -1;while ((len = bis.read(bys)) != -1) {System.out.println( new String(bys,0,len) );}//关闭流bis.close();}}</span>

###13.10_IO流(小数组的读写和带Buffered的读取哪个更快)
* 定义小数组如果是8192个字节大小和Buffered比较的话
* 定义小数组会略胜一筹,因为读和写操作的是同一个数组
* 而Buffered操作的是两个数组

 BufferedOutputStream: 字节缓冲输出流
 *   特点： 在字节输出流的基础上，内部包含了一个用来缓冲数据的数组
 *   作用： 为基本的字节输出流，提高效率，而产生的高效流，那么这个高效流的底层还是通过的流 完成的操作
 ** 构造方法：
 *   public BufferedOutputStream(OutputStream out)采用默认大小的缓冲区8192个字节，创建字节缓冲输出流对象
 *   public BufferedOutputStream(OutputStream out, int size) 指定缓冲区大小，创建自己而缓冲输出流对象

<span style="font-size:14px;">public class BufferedOutputStreamDemo {public static void main(String[] args) throws IOException {//创建对象//public BufferedOutputStream(OutputStream out)//FileOutputStream fos = new FileOutputStream("小说.txt");//BufferedOutputStream bos = new BufferedOutputStream(fos);BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("小说.txt"));//写数据bos.write("我是高效的流".getBytes());//关闭流bos.close();}}</span>

###13.11_IO流(flush和close方法的区别)
* flush()方法
    * 用来刷新缓冲区的,刷新后可以再次写出 
* close()方法
    * 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出 
###13.12_IO流(字节流读写中文) 
* 字节流读取中文的问题
    * 字节流在读中文的时候有可能会读到半个中文,造成乱码 
* 字节流写出中文的问题
    * 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组 
    * 写出回车换行 write("\r\n".getBytes());

<span style="font-size:14px;">public class FileInputStreamDemo5 {public static void main(String[] args) throws IOException {//创建字节输入流对象FileInputStream fis = new FileInputStream("小说.txt");//读数据byte[] bys = new byte[5];//定义一个字节数组，用来存储每次读取到的字节int len = -1; //记录每次读取到了新字节的个数//获取数据，赋值， 比较while (  (len = fis.read(bys)) != -1   ) {//获取有效的数据System.out.print( new String(bys,0,len) );}int len = fis.read(bys);//代表每次读取到了新字节的数量System.out.println("len:"+len);//5System.out.println("bys:"+Arrays.toString(bys));//1,2,3,4,5//关闭流fis.close();}}</span>

###13.13_IO流(递归)

  使用递归的前提：
        1：指定递归规则
  2: 出口条件

    使用递归的注意事项：
  1：递归次数不能过多， 会报出栈溢出异常

    递归思想就是自己调自己，递归在实际应用中主要应用在遍历多层文件夹中，我们用图来表示一下：

###13.14_IO流(图片加密)
* 给图片加密

<span style="font-size:14px;">        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"));                int b;        while((b = bis.read()) != -1) {            bos.write(b ^ 123);        }                bis.close();        bos.close();</span>

这个是自己从网上参考的代码，大家有兴趣的话可以研究一下