Java基础Day20笔记

原创 2017年01月04日 08:45:49

20.01_IO流(IO流概述及其分类)

  • 1.概念
    • IO流用来处理设备之间的数据传输
    • Java对数据的操作是通过流的方式
    • Java用于操作流的类都在IO包中
    • 流按流向分为两种:输入流,输出流。
    • 流按操作类型分为两种:
      • 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
      • 字符流 : 字符流只能操作纯字符数据,比较方便。
  • 2.IO流常用父类
    • 字节流的抽象父类:
      • InputStream
      • OutputStream
    • 字符流的抽象父类:
      • Reader
      • Writer
  • 3.IO程序书写
    • 使用前,导入IO包中的类
    • 使用时,进行IO异常处理
    • 使用后,释放资源

20.02_IO流(FileInputStream)

io流只能对文件进行操作,不可以对文件夹进行操作,如果报错拒绝访问,请查看文件类型是文件夹还是文件

* read()一次读取一个字节
*
FileInputStream fis = new FileInputStream(“aaa.txt”); //创建一个文件输入流对象,并关联aaa.txt
int b; //定义变量,记录每次读到的字节
while((b = fis.read()) != -1) { //将每次读到的字节赋值给b并判断是否是-1
System.out.println(b); //打印每一个字节
}

    fis.close();                                            //关闭流释放资源

20.03_IO流(read()方法返回值为什么是int)

  • read()方法读取的是一个字节,为什么返回是int,而不是byte

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

20.04_IO流(FileOutputStream)

  • write()一次写出一个字节

    FileOutputStream fos = new FileOutputStream("bbb.txt"); //如果没有bbb.txt,会创建出一个
    //fos.write(97);                        //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
    fos.write(98);
    fos.write(99);
    fos.close();
    

20.05_IO流(FileOutputStream追加)

    **在创建对象的时候是如果没有这个文件会帮我创建出来**
    **如果有这个文件就会先将文件清空***
    **如果想续写就在第二个参数传true**
    **虽然写出的是一个int数,但是到文件上的是一个字节,会自动去除前三个8位**

* A:案例演示

    FileOutputStream的构造方法写出数据如何实现数据的追加写入
    FileOutputStream fos = new FileOutputStream("bbb.txt",true);    //如果没有bbb.txt,会创建出一个
    //fos.write(97);                        //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
    fos.write(98);
    fos.write(99);
    fos.close();

20.06_IO流(拷贝图片)

  • FileInputStream读取
  • FileOutputStream写出

    FileInputStream fis = new FileInputStream("致青春.mp3");   //创建输入流对象,关联致青春.mp3
    FileOutputStream fos = new FileOutputStream("copy.mp3");//创建输出流对象,关联copy.mp3
    
    int b;
    while((b = fis.read()) != -1) {             //在不断的读取每一个字节
        fos.write(b);                           //将每一个字节写出
    }
    
    fis.close();                //关流释放资源
    fos.close();        
    

20.07_IO流(拷贝音频文件画原理图)

  • A:案例演示
    • 字节流一次读写一个字节复制音频
  • 弊端:效率太低

  • 8_IO流(字节数组拷贝之available()方法)
  • A:案例演示
    • int read(byte[] b):一次读取一个字节数组
    • write(byte[] b):一次写出一个字节数组
    • available()获取读的文件所有的字节个数
  • 弊端:有可能会内存溢出

    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();
    

20.09_IO流(定义小数组)

  • write(byte[] b)
  • write(byte[] b, int off, int len)写出有效的字节个数

    byte[] arr = new byte[2];
    int a = fis.read(arr);                      //将文件上的字节读取到字节数组中
    
    System.out.println(a);                      //读到的有效字节个数
    for (byte b : arr) {                        //第一次获取到文件上的a和b
        System.out.println(b);
    }
    System.out.println("-----------------------");
    int c = fis.read(arr);
    System.out.println(c);
    for (byte b : arr) {
        System.out.println(b);
    }
    fis.close();    
    

20.10_IO流(定义小数组的标准格式)

  • A:案例演示

    • 字节流一次读写一个字节数组复制图片和视频
    • FileInputStream fis = new FileInputStream("致青春.mp3");
      FileOutputStream fos = new FileOutputStream("copy.mp3");
      int len;
      byte[] arr = new byte[1024 * 8];                    //自定义字节数组
      while((len = fis.read(arr)) != -1) {
          //fos.write(arr);
          fos.write(arr, 0, len);                         //写出字节数组写出有效个字节个数
      }
      
      fis.close();
      fos.close();
      

20.11_IO流(BufferedInputStream和BufferOutputStream拷贝)

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

    FileInputStream fis = new FileInputStream("致青春.mp3");           //创建文件输入流对象,关联致青春.mp3
    BufferedInputStream bis = new BufferedInputStream(fis);         //创建缓冲区对fis装饰
    FileOutputStream fos = new FileOutputStream("copy.mp3");        //创建输出流对象,关联copy.mp3
    BufferedOutputStream bos = new BufferedOutputStream(fos);       //创建缓冲区对fos装饰
    
    int b;
    while((b = bis.read()) != -1) {     
        bos.write(b);
    }
    
    bis.close();                        //只关装饰后的对象即可(化妆后的美女)
    bos.close();
    
  • E.小数组的读写和带Buffered的读取哪个更快?

    • 定义小数组如果是8192个字节大小和Buffered比较的话
    • 定义小数组会略胜一筹,因为读和写操作的是同一个数组
    • 而Buffered操作的是两个数组

20.12_IO流(flush和close方法的区别)

  • flush()方法
    • 用来刷新缓冲区的,刷新后可以再次写出
  • close()方法
    • 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
      *两者均具备刷新的功能,flush()刷完之后还可以写出,用于实时的刷新,比如聊天记录随时查看等,而close()刷完之后不可以写出

20.13_IO流(字节流读写中文)

  • 字节流读取中文的问题
    • 字节流在读中文的时候有可能会读到半个中文,造成乱码 ,比如长度为3,一个中文占用2个字节,那么会读取第一个完整中文,第二个中文的前一个字节,
  • 字节流写出中文的问题
    • 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
    • 写出回车换行 write(“\r\n”.getBytes());

20.14_IO流(流的标准处理异常代码1.6版本及其以前)

  • try finally嵌套

    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream("aaa.txt");
        fos = new FileOutputStream("bbb.txt");
        int b;
        while((b = fis.read()) != -1) {
            fos.write(b);
        }
    } finally {
        try {
            if(fis != null)
                fis.close();
        }finally {
            if(fos != null)
                fos.close();
        }
    }
    

20.15_IO流(流的标准处理异常代码1.7版本)

  • try close

    try(
        FileInputStream fis = new FileInputStream("aaa.txt");
        FileOutputStream fos = new FileOutputStream("bbb.txt");
        MyClose mc = new MyClose();
    ){
        int b;
        while((b = fis.read()) != -1) {
            fos.write(b);
        }
    }
    
  • 原理
    • 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉

20.16_IO流(图片加密)

  • 给图片加密
    将写出的字节异或上一个数,这个数就是密钥,解密的时候再次异或就可以了

    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();
    

20.17_IO流(拷贝文件)

  • 在控制台录入文件的路径,将文件拷贝到当前项目下

    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个文件路径");
    String line = sc.nextLine();                //将键盘录入的文件路径存储在line中
    File file = new File(line);                 //封装成File对象
    FileInputStream fis = new FileInputStream(file);
    FileOutputStream fos = new FileOutputStream(file.getName());
    
    int len;
    byte[] arr = new byte[8192];                //定义缓冲区
    while((len = fis.read(arr)) != -1) {
        fos.write(arr,0,len);
    }
    
    fis.close();
    fos.close();
    

20.18_IO流(录入数据拷贝到文件)

  • 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出

    Scanner sc = new Scanner(System.in);
    FileOutputStream fos = new FileOutputStream("text.txt");
    System.out.println("请输入:");
    while(true) {
        String line = sc.nextLine();
        if("quit".equals(line))
            break;
        fos.write(line.getBytes());
        fos.write("\r\n".getBytes());
    }
    
    fos.close();
    

    //详细写法如下

    package com.heima.test;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.Scanner;
    
    public class Test3 {
    
    /**
     * 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出
     * 
     * 分析:
     * 1,创建键盘录入对象
     * 2,创建输出流对象,关联text.txt文件
     * 3,定义无限循环
     * 4,遇到quit退出循环
     * 5,如果不quit,就将内容写出
     * 6,关闭流
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //1,创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //2,创建输出流对象,关联text.txt文件
        FileOutputStream fos = new FileOutputStream("text.txt");
        System.out.println("请输入数据:");
        //3,定义无限循环
        while(true) {
            String line = sc.nextLine();                    //将键盘录入的数据存储在line中
            //4,遇到quit退出循环
            if("quit".equals(line)) {
                break;
            }
            //5,如果不quit,就将内容写出
            fos.write(line.getBytes());                     //字符串写出必须转换成字节数组
            fos.write("\r\n".getBytes());
        }
        //6,关闭流
        fos.close();
    }
    

    }

20.19_day20总结

  • 把今天的知识点总结一遍。
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

黑马程序员_Java基础_我的day20学习笔记

IO流(重点知识)01. IO流概述及其分类 1.概念 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种:输入流,输出流。 ...

传智播客 2015 刘意 Java基础-视频-笔记day27(完结)(2016年5月1日12:42:20)

day27 1.类的加载概述和加载时机   2.类加载器的概述和分类 类加载器 负责将.class文件加载到内存中,并为之生成对应的Class对象。 虽然我...

传z播客 刘意_2015年Java基础视频笔记(day18~day20(2016年3月20日14:36:05)

day18 1.Map引入 Map是区分于Collection的另外一个"老大" 作为学生来说,是根据学号来区分不同的学生的,那么假设我现在已经知道了学生的学号,我要根据学号去获取学生姓名,请问怎么做...

21天精通java基础之Day20网络编程(一)

Day20:网络编程(一) 网络通信的一个要素:IP地址,通过IP地址,唯一的定位互联网上一台主机。      InetAddress:位于java.net包下    1.InetAddress用...

黑马程序员_java基础day20

------- android培训、java培训、期待与您交流! ---------- 主要内容:一,File类;二、Properties简述;三、打印流;四、序列流:SequenceInput...

IO流+JAVA学习笔记-DAY20

IO流概述及其分类、IO流常用父类 、FileInputStream、read()方法返回值为什么是int、FileOutputStream、FileOutputStream追加、拷贝图片、音频、字节...

[Java视频笔记]day20

File类 1. 用来将文件或者文件夹封装成对象 2. 方便对文件与文件夹的属性信息进行操作(流只能操作数据) 3. File对象可以作为参数传递给流的构造函数   File类常见方法: 1. 创建 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基础Day20笔记
举报原因:
原因补充:

(最多只允许输入30个字)