JAVA Day13 总结

1、File类的概述和构造方法

• A:File类的概述
  • File更应该叫做一个路径
    • 文件路径或者文件夹路径
    • 路径分为绝对路径和相对路径
    • 绝对路径是一个固定的路径,从盘符开始
    • 相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下
  • 查看API指的是当前路径
  • 文件和目录路径名的抽象表示形式
• B:构造方法
  • File(String pathname)：根据一个路径得到File对象
  • File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
  • File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
• C:案例演示
  • File类的构造方法

2、File类的创建功能

• A:创建功能
  • public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
  • public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
  • public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
• B:案例演示

  • File类的创建功能

  • 注意事项：

    • 如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。

3、File类的重命名和删除功能

• A:重命名和删除功能
  • public boolean renameTo(File dest):把文件重命名为指定的文件路径
  • public boolean delete():删除文件或者文件夹
• B:重命名注意事项
  • 如果路径名相同，就是改名。
  • 如果路径名不同，就是改名并剪切。
• C:删除注意事项：
  • Java中的删除不走回收站。
  • 要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

4、File类的判断功能

• A:判断功能
  • public boolean isDirectory():判断是否是目录
  • public boolean isFile():判断是否是文件
  • public boolean exists():判断是否存在
  • public boolean canRead():判断是否可读
  • public boolean canWrite():判断是否可写
  • public boolean isHidden():判断是否隐藏
• B:案例演示
  • File类的判断功能

5、File类的获取功能

• A:获取功能
  • public String getAbsolutePath()：获取绝对路径
  • public String getPath():获取路径
  • public String getName():获取名称
  • public long length():获取长度。字节数
  • public long lastModified():获取最后一次的修改时间，毫秒值
  • public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
  • public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
• B:案例演示
  • File类的获取功能

6、输出指定目录下指定后缀的文件名

• A:案例演示
  • 需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称

7、文件名称过滤器的概述及使用

• A:文件名称过滤器的概述
  • public String[] list(FilenameFilter filter)
  • public File[] listFiles(FileFilter filter)
• B:文件名称过滤器的使用
  • 需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
• C:源码分析
  • 带文件名称过滤器的list()方法的源码

8、递归

• 5的阶乘

9、IO流概述及其分类

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

10、FileInputStream

• read()一次读取一个字节

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

FileInputStream fileInputStream =
                new FileInputStream("src//test2.text");
        int i;
        while((i =fileInputStream.read())!= -1){
            System.out.println(i);
        }
        fileInputStream.close();

小结：

1、构造方法大体两类：第一：传递File类 第二：直接传递地址
2、遍历时read()是从该输入流读取一个字节的数据。 并且是 提升为int类型（主要是因为 区分 -1 是否为文件结尾）
3、read() 的作用方式类似指针，调用一次，向下移动一次，因此，在一次循环中调用一次
4、*******要区别read()和read(数组) 两种方法，第一种返回的是存储的字节内容，第二种是返回的存储的总个数

11、read()方法返回值为什么是int

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

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

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

  FileOutputStream fileOutputStream =
                new FileOutputStream("src//abc.text");
        fileOutputStream.write(88);
        fileOutputStream.close();

        FileInputStream fileInputStream =
                new FileInputStream("src//abc.text");
        int i ;
        while((i=fileInputStream.read())!= -1){
            System.out.println((char)i);
        }
        fileInputStream.close();

小结：

1、默认会清空后重写入，若要追加直接在创建时加入true（具体参考下面13）

13、FileOutputStream追加

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

14、拷贝图片

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

 FileInputStream fileInputStream =
                new FileInputStream("src//Day13//a95738b43f1405b9bb939177c79d1d81.jpg");
        FileOutputStream fileOutputStream =
                new FileOutputStream("src//Day13//out.jpg");
        int i;
        while(( i = fileInputStream.read()) !=  -1){
            fileOutputStream.write(i);
        }

        fileInputStream.close();
        fileOutputStream.close();

15、拷贝音频文件画原理图

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

16、字节数组拷贝之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();
  

 FileInputStream fileInputStream =
                new FileInputStream("src//Day13//a95738b43f1405b9bb939177c79d1d81.jpg");
        FileOutputStream fileOutputStream =
                new FileOutputStream("src//Day13//out2.jpg");
        byte [] bytes = new byte[fileInputStream.available()];
        int il;
        while (( il= fileInputStream.read(bytes)) != -1){
            fileOutputStream.write(bytes,0,il);
        }
        System.out.println(il);
        fileInputStream.close();
        fileOutputStream.close();

小结：

1、public int read(byte[] b)
即：从该输入流读取最多b.length字节的数据 “到” 字节数组（把数据读入到字节数组中，最大读字节数组的大小）
返回：读取到缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达， -1 。 （返回读了多少字节）

2、write(byte[] b, int off, int len)
即：从off开始写入len个字节的数据
无返回值

为什么不用这个方法 write(byte[] b) 而用 write(byte[] b, int off, int len)
备注：read 当数组长度为4时，最后只剩下3个数据，返回值也为3，不过数组中有4个数据（第四个数据是上一次读入的数据），因此，write方法不能用write(byte[] b)，会将第四个无用数据也传入，参考如下

         FileInputStream fileInputStream =
                new FileInputStream("src//Day13//test2.text");  //1234
        FileOutputStream fileOutputStream =
                new FileOutputStream("src//Day13//out3.text");

        byte [] bytes = new byte[3];
        int i;
        while ((i = fileInputStream.read(bytes))!= -1){
        
        fileOutputStream.write(bytes);  //输出 123423
        fileOutputStream.write(bytes,0,i);  //输出 1234

3、对于二者源码如下：

        public void write(byte b[]) throws IOException {
            writeBytes(b, 0, b.length, append);从0到b.length
        }
        
        public void write(byte b[], int off, int len) throws IOException {
            writeBytes(b, off, len, append);从off到len
        }

17、定义小数组

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

18、定义小数组的标准格式

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

19、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操作的是两个数组

  BufferedInputStream bufferedInputStream =
                new BufferedInputStream(new FileInputStream("src\\Day13\\a95738b43f1405b9bb939177c79d1d81.jpg"));
        BufferedOutputStream bufferedOutputStream =
                new BufferedOutputStream(new FileOutputStream("src\\bufferout1.jpg"));
        int b;
        while ((b =bufferedInputStream.read()) != -1){
            bufferedOutputStream.write(b);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();

小结：

1、它的操作和普通的流方法相同，只是在底层实现时有所区别，它是存够后在进行一块写入
2、read()同样返回一个字节的数据 read(数组)返回读取的总个数

//使用数组
 BufferedInputStream bufferedInputStream =
                new BufferedInputStream(new FileInputStream("src\\Day13\\test2.text"));
        BufferedOutputStream bufferedOutputStream =
                new BufferedOutputStream(new FileOutputStream("src\\Day13\\out3.text"));
        byte [] bytes = new byte[5];
        int b;
        while ((b =bufferedInputStream.read(bytes)) != -1){
            bufferedOutputStream.write(bytes,0,b);
            System.out.println(b);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();

20、flush和close方法的区别

• flush()方法
  • 用来刷新缓冲区的,刷新后可以再次写出
• close()方法
  • 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

小结：

1、如果不刷新，可能会出现输出不全的问题
2、flush()方法适用类似 qq聊天的场景， 发送多次装不满

21、字节流读写中文

• 字节流读取中文的问题
  • 字节流在读中文的时候有可能会读到半个中文,造成乱码
• 字节流写出中文的问题
  • 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
  • 写出回车换行 write("\r\n".getBytes());3

 FileInputStream fileInputStream = new FileInputStream("C:\\Users\\PengH\\Desktop\\新建文件夹\\Day1Day2\\src\\Day13\\test2.text");
        FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\PengH\\Desktop\\新建文件夹\\Day1Day2\\src\\Day13\\out3.text");

        //读
        byte [] bytes = new byte[57];
        int i ;
          while ((i = fileInputStream.read(bytes)) != -1){
              System.out.println(new String(bytes,0,i));
          }

          //写
        String str = "我你大爷";
          fileOutputStream.write(str.getBytes());


          fileInputStream.close();
          fileOutputStream.close();

22、流的标准处理异常代码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();
    	}
    }
  

23、流的标准处理异常代码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方法将流关掉

小结：

普通的方法，实现AutoCloseable中的close 在（）中也会自动调用

public class TestClose implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("我关闭了");
    }
}

psvm{
 try(TestClose tt  = new TestClose();){

        } catch (Exception e) {
            e.printStackTrace();
        }
}
//我关闭了

24、图片加密

• 给图片加密

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

25、拷贝文件

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

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

26、录入数据拷贝到文件

• 将键盘录入的数据拷贝到当前项目下的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();