File类、递归、字节流

File类

对文件及文件夹进程的操作

File类的构造

• public File(String path);
• public File(String parent,String child);
• public File(File parent,String child);

public class FileDemo01 {
	public static void main(String[] args) {
	//1.构造方法1
        File f1 = new File("C:\\Users\\Administrator\\Desktop\\temp\\aaa");
        System.out.println(f1);
        
        //2.构造方法2
        File f2 = new File("C:\\Users\\Administrator","Desktop\\temp\\aaa");
        System.out.println(f2);
        
        //3.构造方法3
        File parent = new File("C:\\Users\\Administrator");
        File f3 = new File(parent,"Desktop\\temp\\aaa");
        System.out.println(f3);
    }
}

File类的方法

File类的获取方法

• public String getAbsolutePath(); 获取该File对象的绝对路径
• public String getPath(); 获取该File对象构造时,传入的路径
• public String getName(); 获取该File对象的代表的文件或者文件夹的名字
• public long length(); 获取该File对象的大小(单位为字节)

File类的判断方法

• public boolean exists(); 判断该File对象代表文件和文件夹是否存在
• public boolean isDirectory(); 判断该File对象说代表是否是文件夹
• public boolean isFile(); 判断该File对象说代表是否是文件

File类的创建删除方法

• public boolean mkdir();创建单级文件夹,返回值表示是否创建成功
• public boolean mkdirs();创建多级文件夹,返回值表示是否创建成功
• public boolean createNewFile();创建文件,返回值表示是否创建成功
• public boolean delete();删除该File对象代表的文件或者空文件夹,返回值表示是否删除成功

File类遍历方法·

• public String[] list(); 列出当前文件夹下所有直接的文件和文件夹的名字

• public File[] listFiles();列出当前文件夹下所有直接的文件和文件夹的File对象

//File类的获取方法
File ff = new File("C:\\Users\\Administrator\\Desktop\\temp\\aaa\\1.txt");
//1.getAbsolutePath
String absolutePath = ff.getAbsolutePath();
System.out.println(absolutePath);

//2.getPath
String path = ff.getPath();
System.out.println(path);

//3.getName
String name = ff.getName();
System.out.println(name);

//4.length
long len = ff.length();
System.out.println(len+"字节");

注意:length方法只能获取文件的大小,不能获取文件夹的大小

//1.创建一个File对象
File ff = new File("1.txt");//相对路径

//2.判断是否存在
boolean b = ff.exists();
System.out.println("是否存在:" + b);

//3.判断是文件呢??还是文件夹呢???
boolean directory = ff.isDirectory();
System.out.println("是文件夹吗?"+directory);
boolean file = ff.isFile();
System.out.println("是文件吗?"+file);

//1.创建一个File对象
File ff = new File("2.txt");

//2.创建文件
boolean b1 = ff.createNewFile();
System.out.println("是否创建成功呢??"+b1);

//3.创建文件夹
boolean b2 = ff.mkdir();
System.out.println("是否创建成功呢??"+b2);

//4.再创建一个File对象
File ff2 = new File("aaa\\bbb\\ccc\\ddd");
boolean b3 = ff2.mkdir();
System.out.println("是否创建成功呢??"+b3);

boolean b4 = ff2.mkdirs();
System.out.println("是否创建成功呢??"+b4);

//5.再创建File对象
File ff3 = new File("2.txt");
boolean b5 = ff3.delete();
System.out.println("是否删除成功呢??"+b5);

注意:
a.mkdir和mkdirs的区别
b.delete方法要么删除文件,要么删除空文件夹,不能删除非空文件夹

• List item

## 相对路径和绝对路径的对比

• 绝对路径: 是指以盘符开头的路径 比如: “D:\core\education\a.txt”
• 相对路径: 以自己的项目的存储路径 比如：“a.txt”或"aa\1.txt"

递归

就是自己调用自己的方法

• 递归求和

需求: 使用递归求1-n的和(开发中不要用递归求和)
使用递归三大步骤:
 a.先定义一个方法(求和)
    b.找规律,调用自己
    c.让递归有出口(结束的条件)
public class RecursionDemo02 {
    public static void main(String[] args) {
        //需求: 使用递归求1-n的和(开发中不要用递归求和)
        int sum = getSum(100);
        System.out.println(sum);
    }
    //使用递归
    //a.先定义一个方法(求和)
    public static int getSum(int n){
        //c.让递归有出口(结束的条件)
        if (n == 1){
            return 1;
        }
        //b.找规律,调用自己
        // 1+2+3..n = (1+2+3..+n-1) + n
        // getSum(n) = getSum(n-1) + n
        return getSum(n-1) + n;
    }
        
        

• 递归阶乘

需求: 使用递归求n的阶乘(就是求1-n的积)(开发中不要用递归求积)
使用递归三大步骤:
 a.先定义一个方法(求积)
    b.找规律,调用自己
    c.让递归有出口(结束的条件) 
public class RecursionDemo03 {
    public static void main(String[] args) {
        //需求: 使用递归求n的阶乘(就是求1-n的积)(开发中不要用递归求和)
        int ji = getJi(4);
        System.out.println(ji);
    }
    //使用递归三大步骤:
    //a.先定义一个方法(求积)
    public static int getJi(int n){
        //c.让递归有出口(结束的条件)
        if (n == 1) {
            return 1;
        }
         //b.找规律,调用自己
        // 1*2*3..*n = (1*2*3..n-1)*n
        // getJi(n) = getJi(n-1)*n
        return getJi(n-1)*n;
    }
}
        

• 文件搜索

需求:
 在某个目录中找出所有的.txt文件
 某个目录:C:\Users\Administrator\Desktop\temp\aaa
public class RecursionDemo04 {
    public static void main(String[] args) {
//        需求:
//        在某个目录中找出所有的.txt文件
//        某个目录:C:\Users\Administrator\Desktop\temp\aaa
    File fileDir = new File("C:\\Users\\Administrator\\Desktop\\temp\\aaa");
        //调用
        findTxtFile(fileDir);
    }
    
    //从指定的目录中搜索txt文件
    public static void findTxtFile(File file) {
        //1.列出该文件夹下所有的File对象
        File[] files = file.listFiles();
        //2.遍历列出的数组
        for (File f : files) {
            //3.判断是否为txt文件
            if (f.getName().endsWith(".txt") && f.isFile()) {
                System.out.println(f);
            }else if (f.isDirectory()){
            //那么列出这个f文件夹下的所有.txt文件即可
                findTxtFile(f); // 递归!!!
            }
        }
    }
} 

    

IO流

定义：
I: Input 输入流, 数据从外部设备到程序中,读数据的流
O: Output 输出流, 数据从程序到外部设备,写数据的流
流: 一种比喻,数据传输的过程比喻成流

IO的四大流

1. 字节输入流：InputStream(顶层父类,抽象类)
2. 字节输出流：OutputStream(顶层父类,抽象类)
3. 字符输入流：Reader(顶层父类,抽象类)
4. 字符输出流：Writer(顶层父类,抽象类)

注意(技巧)：
Java中所有流都会是以上四个流中的某一个子类而且具有的流的命名是非常规范的！！！

比如：FileWriter 向文件中写出字符为单位的数据
比如：FileInputSream从文件读取以字节为单位的数据

字节流

万物皆对象
现实中的任何东西，我们在Java中都可以使用一个对象来表示

IO流一切皆字节
电脑的所有数据，最终都是由字节组成的(01010101二进制组成)

小疑惑？？？

普通文本文件，图片文件，视频文件，都是字节组成的吗？
–yes

为什么打开的文件看不到01010101数据？
–因为这些打开的文件使用的软件已经把这些文件给解析了

能不能打开文件时不解析，怎样才能看到01010101这些数据？
–可以使用二进制查看软件，BinaryViewer

5. 字节输出流

顶层父类：OutputStream(抽象类)
共享方法：
public void close();关闭流，释放资源
public void flush();刷新缓冲区
public void write(int b);//一次写一个字节
public void write(byte[] bs);//一次写一个字节数组
public void write(byte[] bs,int starIndex,int len);//一次些一个字节数组的一部分
6. FileOutputStream类的使用
文件的字节输出流(向文件中写字节数据的)
构造方法
public FileOutputStream(String path);//传入文件的路径
public FileOutputStream(File file);//传入文件的File对象

//1.创建一个FileOutputStream
FileOutputStream fos = new FileOutputStream("1.txt");
//FileOutputStream fos = new FileOutputStream(new File("1.txt"));
/*
构造方法的三个步骤：
a.创建fos对象
b.判断文件是否存在
	b.1如果存在，会清空文件的内容
	b.2如果不存在，会自动创建该文件
c.让对象fos和1.txt绑定
*/

• 写字节数据的三个方法

//1.创建一个FileOutputStream
FileOutputStream fos = new FileOutputStream("1.txt");
//2.向文件中写数据
//a.一次写一个字节
fos.write(97);//a
//b.一次写一个字节数组
byte[] bs = {97,98,99,100};
fos.write(bs);//abcd
//c.一次写一个字节数组的一部分
byte[] bs = {97,98,99,100};
fos.write(bs,1,2);//bc

//**追加续写**
FileOutputStream fos2 = new FileOutputStream("a.txt",true);
//写数据
fos2.write(65);

//换行
//window \r\n
//Linux \n
//MacOS \r  (MacOSX  \n)

```java
//1.创建一个FileOutputStream
FileOutputStream fos = new FileOutputStream("1.txt");

//2.写数据
for (int i = 0; i < 10; i++) {
     fos.write("java\r\n".getBytes());
//   fos.write("\r\n".getBytes());

注意(close和flush):
流一旦使用完毕，及时释放资源，别的程序就可以使用该资源了

7. 字节输入流

顶层父类：InputStream(抽象类)
共性方法：
public void close();//关闭流，释放资源
public int read();//一次读一个字节
public int read(byte[] bs);//一次读一个字节数组，返回值表示实际读取的字节数

8. FileInputStream类的使用
   文件的字节输入流(从文件中读取以字节为单位的数据)
   构造方法：
   public FileInputStream(String path);//传入文件的路径
   public FileInputStream(File file);//传入文件的File对象

注意：

//1.创建FileInputStream对象
FileInputStream fis = new FileInputStream("1.txt");
// FileInputStream fis = new FileInputStream(new File("1.txt"));

//注意：
/*
a.创建对象fis
b.判断文件是否存在
	b.1如果存在,什么不干(不清空!!!)
	b.2如果不存在,会直接抛出异常FileNotFoundException
c.让fis和1.txt绑定

• 读取一个字节

//1.创建FileInputStream对象
FileInputStream fis = new FileInputStream("1.txt");
//2.读数据
        //a.一次读取一个字节
        //int b = fis.read();
        //System.out.println((char) b);
        //==============一次读取一个字节的标准循环代码==================
        int b = 0;//保存读取到字节
        /**
         * (b = fis.read()) != -1
         * 这句代码干了三件事!!!
         * a.先读  fis.read()
         * b.赋值  b = 读取字节
         * c.判断  b != -1
         */
         while ((b = fis.read()) != -1) {
            System.out.println((char) b);
        }
        //4.释放资源
        fis.close();

• 读取一个字节数组

//1.创建FileInputStream对象
FileInputStream fis = new FileInputStream("1.txt");
//2.读数据
        //b.一次读取一个字节数组
        //byte[] bs = new byte[4]; //实际开发中 一般1024 或者 其整数倍
        //int len = fis.read(bs);
        //System.out.println("实际读取到"+len+"个字节");
        //System.out.println(new String(bs,0,len));
        //===============一次读取一个字节数组的标准循环代码===============
        byte[] bs = new byte[4];
        int len = 0;
        /**
         * (len = fis.read(bs)) != -1
         * 以上代码干了三件事
         * a.先读  fis.read(bs)
         * b.赋值  len = 实际读取的个数
         * c.判断  len != -1
         */
         while ((len = fis.read(bs)) != -1) {
            System.out.println(new String(bs,0,len));
        }
        //3.释放资源
        fis.close();
      

• 字节流拷贝图片
  

//复制文件
        //1.源文件G:\uplaod\1.png
        FileInputStream fis = new FileInputStream("G:\\upload\\1.png");
        //2.目标文件
        FileOutputStream fos = new FileOutputStream("copy.png");
        //3.复制文件(一次赋值一个字节数组)
        byte[] bs = new byte[1024]; // 1KB
        int len = 0;
        while ((len = fis.read(bs)) != -1) {
            fos.write(bs,0,len); // 为了防止最后一次读取时 写入多余的数据
        }
        //4.释放资源(先开后关)
        fos.close();
        fis.close();

概述：

• File对象的创建方式
  public File(String path);
  public File(String parent,String child);
  public File(File file,String child);

• File类常用方法
  获取方法 getPath getAbsolutepath getName length
  判断方法 exists isFile isDirectory
  创建方法 createNewFile mkdir mkdirs
  删除方法 delete

• 遍历文件夹
  遍历文件夹方法 list listFiles

• 相对路径和绝对路径
  绝对路径: 以盘符开头的路径 C:\windows\data\1.txt
  相对路径: 相当于当前项目的根目录 1.txt 表示 当前项目根目录下的1.txt

• 递归
  方法内部调用方法本身(自己调自己)
  递归的方式计算5的阶乘
  使用递归会内存溢出隐患的原因
  注意：递归不断调用方法,方法不断入栈,栈内存就会溢出!!!

• IO流的分类和功能
  输入流 : 读数据
  输出流 : 写数据

  字节流 : 数据是以字节为单位
  字符流 : 数据是以字符为单位

• 使用字节输出流写出数据到文件

  • FileOutputStream类
    write(int b);
    write(byte[] bs);
    write(byte[] bs,int startIndex,int len);

• 使用字节输入流读取数据到程序

  • FileInputStream类
    int read();
    int read(byte[] bs);

• 读取数据read(byte[])方法的原理

• 使用字节流完成文件的复制
  注意：一个一个字节复制，一个一个字节数组复制