JAVA11_23学习总结(IO)

今日内容

1. File

File
    高级功能
        public File[] listFiles
            ---获取指定路径下的所有file数组
        public String[] list()
            ---指定路径下的所有文件和目录
        public File[] listFiles(FileFilter filter)
            ---测试指定的抽象路径名是否应包含在路径名列表中
            --FileFilter接口
                --重写方法boolean accept(File pathname)--测试条件
                    -pathname-被测试的文件
        public File[] listFiles(FilenameFilter filter)
            ---测试指定文件是否应包含在文件列表中
            --FilenameFilter接口--过滤器作用
                --重写方法boolean accept(File dir , String name)
                    -File dir-找到该文件的目录
                    -String name-文件的名称

import java.io.File;
//利用public File[] listFiles()方法
public class FileTest {
    public static void main(String[] args) {
        //File构造方法,访问磁盘目录
        File file = new File("D:\\");
        //直接输出file是地址值---利用listFiles方法转换成数组
        File[] files = file.listFiles();
        //遍历数组输出
        for (File f: files){
            //不带.getName()是系统默认格式
            System.out.println(f.getName());
        }
    }
}

import java.io.File;
​
//利用public String[] list()方法
public class FileTest {
    public static void main(String[] args) {
        //File无参构造访问磁盘
        File file = new File("D:\\");
        //调用方法--输出成字符串数组
        String[] str = file.list();
        //遍历数组
        for (String s: str){
            System.out.println(s);
        }
    }
}

import java.io.File;
import java.io.FileFilter;
​
//测试方法public File[] listFiles(FileFilter filter)
//FileFilter接口--重写accept方法
public class FileTest {
    public static void main(String[] args) {
        //创建File无参构造访问磁盘
        File file = new File("D:\\");
        //调用方法
        File[] files = file.listFiles(new FileFilter() { //匿名内部类
            @Override
            public boolean accept(File pathname) { //重写方法--写入判断条件
                //返回值直接判断file-D:盘下,是否有--是文件而且后缀名是.txt的文件
                return (pathname.isFile() && pathname.getName().endsWith(".txt"));
            }
        }) ;
        //遍历输出
        for (File file1: files){
            System.out.println(file1.getName());
        }
    }
}

import java.io.File;
import java.io.FilenameFilter;
​
//测试public File[] listFiles(FilenameFilter filter)
public class FileTest {
    public static void main(String[] args) {
        //创建File无参构造访问磁盘
        File file = new File("D:\\");
        //调用方法--匿名内部类实现
        File[] file1 = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File f = new File(dir,name);
                //判断f是否是文件
                boolean flag = f.isFile();
                //判断f后缀是否是.txt
                boolean flag1 = f.getName().endsWith(".txt");
                //两者都满足返回true,否则false
                return flag && flag1;
            }
        }) ;
        //循环遍历
        for (File file2: file1){
            System.out.println(file2.getName());
        }
    }
}

2.递归

递归
    递归是一种思想
        --在程序中--方法自己调用自己!--循环
    递归的前提
        是一个方法
        有循环规律
        有结束循环的条件!
    注意
        递归不是方法嵌套方法--是自己调用自己
        如果没有结束循环的条件,会一直递归下去,没有结果--死递归
        构造方法没有递归!

/*
    有一个很有名的数学逻辑题叫做不死神兔问题。
       有一对兔子，
      从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，
      问第二十个月的兔子对数为多少？
​
   分析规律        兔子对数
       第一个月:       1
       第二个月:       1
       第三个月:       2
       第四个月:       3
       第五个月:       5
       规律:从第三个月开始,每个月兔子的对数是前两月兔子对数之和
           ---n月份兔子对数 = (n-1)月份兔子对数 + (n-2)月份兔子对数
 */
public class DiGuiTest {
    public static void main(String[] args) {
        int sum = Sum(20);
        //输出总数
        System.out.println(sum);
    }
    //定义方法
    public static int Sum(int num){ //传入问题的最终月数
        //因为前两个月数量不变,所以加入判断
        if (num==1 || num==2){ //当月份减到2月和1月时--也是结束条件!
            return 1 ;//返回1对
        }else {
            return Sum(num-1)+Sum(num-2);//返回(月份-1)+(月份-2)
        }
    }
}

3. IO

IO
    分类
        流的方向划分
            输入流--读--read--往里读
            输出流--写--write--往外写
        流的类型划分
            字节流-按方向划分
                字节输入流--InputStream
                            --无法实例化
                                -具体的子类-FileInputStream
                字节输出流--OutputStream
                            --无法实例化
                                -具体的子类-FileOutputStream
                字节缓冲流--高效!
                    字节缓冲输入流
                        --BufferedInputStream
                    字节缓冲输出流
                        --BufferedOutputStream
            字符流--与字节流类似
                字符输入流
                字符输出流

字节输出流--OutputStream
    具体子类
        FileOutputStream
        构造方法
            public FileOutputStream(File file)
                ---需要先创建File file = new File("抽象路径");
                    ---将抽象路径传入FileOutputStream
            public FileOutputStream(String pathname)
                ---后面直接跟路径名称
            public FileOutputStream(String name , boolean append)
                ---在指定的文件后继续追加书写而不是覆盖--前提是append为true
        成员方法
            public void write(int b)
                ---写一个字节
            public void write(byte[] bytes)
                ---写一个字节数组

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
​
//测试字节输出流方法
public class IOTest {
    public static void main(String[] args) throws IOException {
        //构造方法1
        File file = new File("D:\\这是第二个测试用文件.txt");
        FileOutputStream output = new FileOutputStream(file);
        //构造方法2
        FileOutputStream output1 = new FileOutputStream("D:\\这是第三个测试用文件.txt");
        //写文件--写一个字节
        output.write(97);
        //写文件--写一个数组字节
        byte[] bytes ={97,98,99,100};
        output.write(bytes);
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
​
//测试追加书写
public class IOTest {
    public static void main(String[] args) throws IOException {
        //有参构造创建要追加书写的文件,为true
        FileOutputStream output = new FileOutputStream("d:\\这是第二个测试用文件.txt",true);
        //追加书写
        output.write(97);
    }
}

字节输入流--InputStream
    具体子类
        FileInputStream
    成员方法
        public int read() throws IOException
            ---一次读取一个字节，返回字节数
        public int read(byte[] b) throws IOException
            ---一次读取一个字节数组
    注意
        文件字节输入流一次读取一个字节,将文件内容输出控制台上,中文出现乱码
          因为
            字节流读取字节的时候---将字节--->强转成char
             当英文的后面有中文拼接无法解析强转了--->乱码---->java才提供了字符流
        传统的IO流
            BIO阻塞式流
                --多个线程同时在操作的时候,一个线程在使用io流进行操作时候,其他线程处于阻塞式
        NIO:非阻塞式流

什么时候使用字符流?
    什么时候使用字符流
        打开记事本能读懂的就使用字符
    什么时候使用字节流
        打开记事本读不懂,就使用字节!---读图片文件-视频-音频

import java.io.FileInputStream;
import java.io.IOException;
​
//测试字节输入流
public class IOTest {
    public static void main(String[] args) throws IOException {
        FileInputStream input = new FileInputStream("d:\\这是第二个测试用文件.txt");
        //一次读一个字节数组
        byte[] bytes = new byte[5] ;//读五个字节
        //判断文件里面是否为空
        int len = 0 ;//定义一个接收变量
        if ((len=input.read(bytes))!=-1){
            //输出数组里的内容,从0位置开始,长度为len
            System.out.println(new String(bytes,0,len));//aabcd
        }
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
​
//测试读写联动--复制文件
public class IOTest {
    public static void main(String[] args) throws IOException {
        //创建读--读取目标文件
        FileInputStream input = new FileInputStream("d:\\这是第二个测试用文件.txt");
        //创建写--写进目标文件夹
        FileOutputStream output = new FileOutputStream("d:\\SZR\\这是一个复制文件.txt");
        //按数组读取--按字节读取太慢
        byte[] bytes = new byte[1024];//一般为1024的倍数!
        int len = 0 ;//接收数据
        if ((len=input.read(bytes))!=-1){ //判断非空
            output.write(len);//写操作
        }
    }
}