File类&递归&IO流

1.File类

File表示文件或者文件夹(目录)的路径,路径可以存在也可以不存在

//使用File类的构造方法创建对象
File f1=new File("C:\\itheima\\a.txt");

//使用父路径和子路径创建对象(父路径是一个String)
File f2=new File("C:\\itheima","a.txt");

//使用父路径和子路径创建对象(父路径是一个File对象)
File dir=new File("C:\\itheima");
File f3=new File(dir,"a.txt");

1.1文件路径名称分隔符

在Windows系统中，文件名称分隔符 "\"
在Linux和Mac系统中，文件名称分隔符 "/"
如果你用Java代码写程序想实现跨平台，可以是使用 File.separator 来代替 "\" 或者 "/"

1.2相对路径和绝对路径

绝对路径: 从根目录开始的路径(Windows系统中，从盘符开始的路径)
   String path="C:\\itheima\\java\\a.txt"; 
相对路径: 相对于某一个父路径来说的，省略父路径，直接写的子路径
    在Java项目中，父路径就是Java项目的根目录.

1.3File的创建功能

boolean createNewFile() 根据File对象封装的路径，创建文件且路径要真实存在

boolean mkdir() 根据File对象封装的路径,创建目录(单级文件夹)

boolean mkdirs() 根据File对象封装的路径,创建目录(多级文件夹) 

1.4File获取的方法

String getAbsolutePath() 获取绝对路径,返回值是一个字符串

String getAbsoluteFile() 获取绝对路径,返回值是一个File对象

String getName() 获取文件或者文件夹的名称

public String getParent() 获取父路径,父路径是一个字符串

String getParentFile() 获取父路径,父路径是一个File对象

public String getPath() 获取File对象封装的路径(可能是相对路径，也可能是绝对路径)

public long lastModified() 获取一个文件或者文件夹的最后一次修改的时间毫秒值

public long length() 获取文件的长度(单位:字节)
注意:文件夹大小不能获取(除非用到递归)  

1.5 判断功能

public boolean isFile() 判断是否为文件

public boolean isDirectory() 判断是否为文件夹

public boolean exists() 判断文件或者文件夹是否存在

1.6File的删除功能

boolean delete() 删除文件和空的文件夹 注意:文件夹里面有内容是删除不了(除非用到递归)

1.7File的重命名

boolean renameTo(File f) 重命名File的路径

1.8遍历目录中的所有文件

public class DirDemo {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\陈坦\\Desktop\\文件");
        getDirAllFiles(file);
    }
    //下面的方法表示遍历一个目录中所有的文件(包括子目录中的文件)
    public static void getDirAllFiles(File dir){
        File[] f1 = dir.listFiles();
        if(f1!=null){
            for(File f:f1){
                //如果是文件
                if(f.isFile()){
                    System.out.println(f.getName());

                }
                //如果是文件夹
                if(f.isDirectory()){
                    getDirAllFiles(f);
                }
            }
        }
    }
}

2.递归

递归指的是方法自己调用自己,但是一定要注意:

1. 递归一定要有出口
2. 递归的次数不能过多

2.1求斐波那契数列

//a.第一个数和第二个数都是1
//b.从第3个数开始，这个数等于前面两个数之和
//c.求第12个数是多少

public class Fdemo {
    public static void main(String[] args) {
        int result = fun(12);
        System.out.println(result);

    }

    public static int fun(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return fun(n - 1) + fun(n - 2);
        }
    }   
}

2.2求1~n以内的和

/*
使用递归求 1~n的和
    假设：f(n)表示n以内所有整数的和
    f(1)=1
    f(2)=f(1)+2 //3
    f(3)=f(2)+3 //6
    f(4)=f(3)+4 //10
    ...
    f(n)=f(n-1)+n
 */
public class SumDemo {
    public static void main(String[] args) {
        System.out.println(sum(10));
    }
    //求1~n的和
    public static int sum(int n){
        if(n==1){
            return 1;
        }else{
            return sum(n-1)+n;
        }

    }
}

2.3求n的阶层

/*
使用递归求 1~n的和
    假设：f(n)表示n以内所有整数的和
    f(1)=1
    f(2)=f(1)*2 //2
    f(3)=f(2)*3 //6
    f(4)=f(3)*4 //24
    f(5)=f(4)*5 //120
    ...
    f(n)=f(n-1)+n
 */
public class JcDemo {
    public static void main(String[] args) {
        System.out.println(jc(10));
    }
    //求1~n的和
    public static int jc(int n){
        if(n==1){
            return 1;
        }else{
            return jc(n-1)*n;
        }

    }
}

3.IO流

IO流是专门用来处理设备之间的数据传输的(内存和硬盘)

输入流:读写数据(硬盘--> 内存)
输出流:写入数据(内存--> 硬盘)

3.1IO流按照读写的数据来分类

字节流:可以读写任何格式的文件(文本 图片 视频 音频 软件...)
字节输出流:(OutputStream)
         --FileOutputStream
         --BufferedOutputStream
 
字节输入流:(InputStream)
         --FileInputStream
         --BufferedInputStream

字符流:只能读写文本文件(用记事本打开能看懂的文件)
字符输出流:(Writer)
        --FileWriter
        --BufferedWriter
字符输入流:(Reader)
        --FileReader
        --BufferedReader

3.2流的使用步骤
IO流中的任何子类他们的用法都是差不多的,三步走(搭桥 过桥 拆桥)

1.创建流对象(搭桥)
2.读/写数据(过桥)
   Writer写数据
   Reader读数据,返回-1表示读取到文件末尾
 3.释放资源(拆桥)
   close()

3.3字节流写数据

public class Demo1 {
    public static void main(String[] args) throws IOException {
        //创建流对象
        //关联文件路径:如果不存在会自动创建,如果存在会覆盖
        File file = new File("C:\\Users\\陈坦\\Desktop\\文件\\a.txt");
        FileOutputStream fot= new FileOutputStream(file);
        fot.write(97);
        fot.write(98);
        fot.write(99);
        // "\r\n" 换行
        fot.write("\r\n".getBytes());
        byte[] a={100,101,102};
        fot.write(a);
        fot.write("我爱罗".getBytes());
        fot.write("wink".getBytes());
        //释放资源
        fot.close();
    }
}

3.4字节流读取数据

public class ReadDeam {
    public static void main(String[] args) throws IOException {
        //创建流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\陈坦\\Desktop\\文件\\a.txt");
        //一次读取一个字节
        /*int b;
        while ((b = fis.read()) != -1) {
            System.out.println(b);
        }*/
        //一次读取多个字节
        byte[] bs = new byte[1024];
        int len;
        while((len=fis.read(bs))!=-1){

          //  System.out.println(Arrays.toString(bs)+"..."+len);
            //把字节数组中的有效字节,转换为字符串
            String s = new String(bs, 0, len);
            System.out.println(s);
        }
       //释放资源
       fis.close();
    }
}

3.4字节流复制文件

/*
 把a.txt文件中的内容拷贝到b.txt文件中
 */
public class CopyFile {
    public static void main(String[] args) throws IOException {
        //读取a.txt文件
        FileInputStream fis=new FileInputStream("day08-code/262.jpg");
        //写入b.txt
        FileOutputStream fos=new FileOutputStream("day08-code/263.jpg");

//一边读一边写
        byte[] bs=new byte[1024];
        int len; //记录每次读取的有效字节个数
        while ((len=fis.read(bs))!=-1){
            //把读取到的数据，写入b.txt文件中
            fos.write(bs,0,len);
        }
        //释放资源
        fos.close();
        fis.close(); 
    }
}