1.File

一、Object

package object;

public class Demo {
    public static void main(String[] args) {
        /*
        第一个被子类重写的Object中的方法toString
        原因：
        1.输出对象信息更准确
        2.连接字符串的时候内容有意义
         */
        Point p = new Point(1,2);
        /*
        输出一个对象时，实际上输出的是对象toString()方法返回的字符串
        Object定义了toString方法。目的是将当前对象转换为字符串，而返回的字符串格式
        为：类名@地址
        在输出上来讲，这个字符串对开发帮助不大。因此要重写toString方法
         */
        System.out.println(p);
        //其他类型在与字符串连接时，会调用其toString转换字符串后在进行连接
        String line = "这个对象是：" + p;
        System.out.println(line);
        String str = p.toString();
        System.out.println(str);

        /*
           注：equal相等的意思
            另一个被子类重写的方法equals。
            作用是判定两个对象的内容是否相同。
         */
        Point p2 = new Point(1,2);
        System.out.println(p == p2);//对于引用类型而言，就是比较是否为"同一个对象"
        /*
            子类不重写equals时，Object中的equals内部还是"=="比较，因此不重写无意义
            如果是自己写的类，一般要考虑重写
         */
        System.out.println(p.equals(p2));//false
        /*
            java提供的类大多都重写过了toString和equals方法。
            只有我们自己定义的类在使用时出现上述情况需要自行重写两个方法。
            例如：String，他的toString和equals方法已经重写过了。

         */
    }
}

二、包装类

package object;

/**
 * 包装类常见的功能
 */
public class IntegerDemo02 {
    public static void main(String[] args) {
        //查看int最大值与最小值
        /**
         * 可以强转的为基本类型，引用类型一边造型
         * Byte,Short,Integer,Long,Double,Float
         */
        int max = Integer.MAX_VALUE;
        int min = Integer.MIN_VALUE;
        System.out.println(max);//2147483647
        System.out.println(min);//-2147483648
        max = Byte.MAX_VALUE;
        min = Byte.MIN_VALUE;
        System.out.println(max);//127
        System.out.println(min);//-128
        max = Short.MAX_VALUE;
        min = Short.MIN_VALUE;
        System.out.println(max);//32767
        System.out.println(min);//-32768
        double max1 = Double.MAX_VALUE;
        double min1 = Double.MIN_VALUE;
        System.out.println(max1);
        System.out.println(min1);
        /**
         * 包装类提供了一个静态方法，可以将字符串转换为对应的基本类型，前提是
         * 这个字符串正确描述了基本类型可以保存的值，否则会抛出异常：
         * 数字     格式      异常
         * NumberFormatException
         */
        String line = "123";
        int d = Integer.parseInt(line);
        System.out.println(d);//123
        line = "123.123";
        double dou = Double.parseDouble(line);
        System.out.println(line);//123.123


    }
}

自动拆装箱

特性 JDK5之后推出了一个新的特性:自动拆装箱 该特性是编译器认可的.当编译器编译源代码时发现有基 本类型和引用类型相互赋值使用时会自动补充代码来完 成他们的转换工作,这个过程称为自动拆装箱.

package object;

public class IntegerDemo03 {
    public static void main(String[] args) {
        int a = 123;
        Integer i = a;
        /**
         * 编译器自动将上面的代码补成本句，自动装箱
         * 编译器改好的样子
         * Integer i = Integer.valueOf(a);
         */
       // Integer i = (Integer) a；
        a = i;
        /**
         * 触发了自动拆箱特性，编译器会补充代码将包装类转换为基本类型
         */
       // a = i.intValue();编译器改好的样子

    }
}

三、文件操作——File

1.1File类概述和构造方法

File:它是文件和目录路径名的抽象表示

• 文件和目录都是通过File封装成对象的
• 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。他可以是存在的，也可以是不存在的。将来要是通过具体的操作把这个路径的内容转换为具体存在的。

File类的每一个实例可以表示硬盘(文件系统)中的一个文件或目录(实际上表示的是一个抽象路径)

使用File可以做到:

• 1:访问其表示的文件或目录的属性信息,例如:名字,大小,修改时间等等
• 2:创建和删除文件或目录
• 3:访问一个目录中的子项

但是File不能访问文件数据.

File构造方法

方法名	说明
File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File(String parent, String child)	从父路径名字符串和子路径字符串创建新的File实例
File(File parent, String child)	从父抽象路径名子路径字符串创建新的File实例

package file;

import java.io.File;

/**
        * file文件
        * java.io.File类
        * 该类的每一个实例可以表示硬盘上的一个文件或目录（实际表示的是一个抽象路径）
        * 通过File我们可以：
        * 1.访问其表示的文件或目录的属性信息（名字、大小等）
        * 2.创建，删除文件过目录
        * 3.访问一个目录中的子项
        * 但是不能访问文件数据
        */
public class FileDemo {
    public static void main(String[] args) {
        //访问当前项目目录下的demo.txt文件
        /**
         * File file = new File("F:\\java\\IdeaProjects\\JAVASE");
         * 实际开发中我们几乎不用绝对路径去定位文件或目录，都是使用相对路径。
         * 因为它有更好的跨平台性。
         * 例如："./"表示当前目录，具体是哪里要看当前程序的运行环境而定，比如我们现在
         *  在IDEA里执行程序时，IDEA规定当前目录就是当前程序所在的项目目录。
         */
        File file = new File("./demo.txt");
        String name = file.getName();
        System.out.println(name);//demo.tx
        long length = file.length();
        System.out.println("长度"+length+"字节");//长度10字节
        boolean b = file.canRead();//可读
        boolean b1 = file.canWrite();//可写
        boolean b2 = file.isHidden();//是否隐藏
        System.out.println("可读"+b);//true
        System.out.println("可写"+b1);//true
        System.out.println("隐藏"+b2);//没隐藏false,隐藏true
    }
}

通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。
File f1 = new File("d:/LOL/java.txt");
System.out.println(f1);
从父路径名字符串和子路径字符串创建新的File实例。
File f2 = new File("d://LOL","java.txt");
System.out.println(f2);
从父抽象路径名子路径字符串创建新的File实例。
File f3 = new File("d://LOL");
File f4 = new File(f3,"java.txt");

1.2File类创建功能

方法名	说明
public boolean createNewFile()	当具有该名称的文件不存在是，创建一个由抽象路径名命名的新空文件。如果文件不存在就创建文件，并返回true；如果文件存在就不创建文件，并返回false。
public boolean mkdir()	创建由此抽象路径名命名的目录。如果目录不存在就创建目录，并返回true；如果目录存在就不创建目录，并返回false
public boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必须但不存在的父目录。

//1.在d:/LOL目录下创建一个文件java.txt
File f1 = new File("d:/LOL/java.txt");
System.out.println(f1.createNewFile());
//2.在d:/LOL目录下创建一个目录javase
File f2 = new File("d:/LOL/javase");
System.out.println(f2.mkdir());
//3.在d:/LOL目录下创建一个多级目录javaweb/HTML
File f3 = new File("d:/LOL/javaweb/HTML");
//4.在d:/LOL目录下创建一个文件javase.txt
File f4 = new File("d:/LOL/javase.txt");
System.out.println(f4.createNewFile());
注意：文件和文件夹不能同名，mkdirs()可以创建多级目录。

package file;

import java.io.File;

/**
 * 创建一个目录
 * mkdir():创建目录的时候，该目录的父目录得存在，否则无法创建
 * mkdirs():可以逐级创建目录
 */
public class MkdirDemo {
    public static void main(String[] args) {
        //在当前目录下创建一个目录：./demo
        File file = new File("./demo");
        if(file.exists()){//判断目录是否存在
            System.out.println("目录已经存在");
        }else{
           // boolean mkdir = file.mkdir();
            file.mkdir();//创建一个目录（文件夹）
            System.out.println("目录已经成功创建了");

        }
        File file1 = new File("./a/b/c");
        if(file1.exists()){
            System.out.println("目录已经存在");
        }else{
            file1.mkdirs();//可以逐级创建目录
            System.out.println("目录创建成功");
        }


    }
}

1.3File类判断和获取功能

方法名	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为日录
public boolean isFile()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否为存在
public String getAbsolutePath(）	返回此抽象路径名的绝对路径名字符串
public String getPath(）	将此抽象路径名转换为路径名字符串
public String getName(）	返回此抽象路径名表示 的文件过目录的名称
public String[] list()	返回此抽象路径名表示的目录中的文件和目录的名称字符数组
public File[] listFile()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

//FiLe类的判断和获职功能。

  File f = new File("d:/LOL/java.txt");
//isDirectory():测试此抽象路经名表示的FiLe是否为目录
  System.out.println(f.isDirectory());
  //izFiLe( ):测试此拍象黯径名表示的Fz是否为文件
  System.out.println(f.isFile());
  //exists():测试此拍象路径名表示的FiLe是否存在
  System.out.println(f.exists());
  //getAbsolutePath():_返回此抽象路径名的绝对路径名字符串
  System.out.println(f.getAbsoluteFile());
  //geEPath():将此拍象路径名转预为路径名宁符串
  System.out.println(f.getPath());
  //getName():拉回由此抽象路径名表示的文件或自录的名称
  System.out.println(f.getName());
  // list()，返回此抽象路径名表示的日录中的文件和日录的名称字符串数组
  System.out.println("-------------------------");
  File f2 = new File("d:/LOL");
  String[] strArray = f2.list();
  for(String str : strArray){
      System.out.println(str);

  }
  // ctrl +alt + v可以生成左边的内容
  //listFiles()。返回此拍家路径名表示的目录中的文件和目录的FiLe对家数组
  System.out.println("-------------------------");
  File[] fileArray = f2.listFiles();
  for(File file : fileArray){
      System.out.println(file);
  }//这种方法带路径，可以根据路径去调用方法

1.4 File类删除功能

方法名	说明
delete()	删除由此抽象路径名表示的文件或目录

绝对路径与相对路径的区别

• 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：D:\LOL\java.txt
• 相对路径：必须使用取自其他路径名的信息进行解释。例如：LOL\java.txt

//1.3File类删除功能
//1.在当前模块目录下创建java.txt文件
File f1 = new File("java.txt");
System.out.println(f1.createNewFile());
//2.删除当前模块目录下创建java.txt文件
System.out.println(f1.delete());
//3.当前模块目录下创建LOL目录
File f2 = new File("LOL");
System.out.println(f2.mkdir());
//4.当前模块目录下删除LOL目录
System.out.println(f2.delete());
//5.当前模块目录下创建itcast目录，然后再次目录下创建一个文件java.txt
File f3 = new File("itcast");
System.out.println(f3.mkdir());
File f4 = new File("itcast/java.txt");
System.out.println(f4.createNewFile());
//6.删除当前模块目录下itcast目录(有内容不能直接删)
//System.out.println(f3.delete());
System.out.println(f4.delete());
System.out.println(f3.delete());

package file;
/**
*  访问一个目录中的所有子项
   listFiles方法可以访问一个目录中的所有子项
*/
import java.io.File;

/**
 * 访问一个目录中的所有子项
 */
public class ListFilesDemo1 {
    public static void main(String[] args) {
        //获取当前目录中的所有子项
        File dir = new File(".");
        /*
            boolean isFile()
            判断当前File表示的是否为一个文件
            boolean isDirectory()
            判断当前File表示的是否为一个目录
         */
        if(dir.isDirectory()){
            /*
                File[] listFiles()
                将当前目录中的所有子项返回。返回的数组中每个File实例表示其中的一个子项
             */
            File[] subs = dir.listFiles();
            System.out.println("当前目录包含"+subs.length+"个子项");
            for(int i=0;i<subs.length;i++){
                File sub = subs[i];
                System.out.println(sub.getName());
            }
        }
    }
}

package file;

import java.io.File;
import java.io.FileFilter;

/**
 * 重载的listFiles方法，允许我们传入一个文件过滤器从而可以有条件的获取一个目录
 * 中的子项。
 */
public class ListFilesDemo2 {
    public static void main(String[] args) {
        /*
            需求:获取当前目录中所有名字以"."开始的子项
         */
        File dir = new File(".");
        if(dir.isDirectory()){
//            FileFilter filter = new FileFilter(){//匿名内部类创建过滤器
//                public boolean accept(File file) {
//                    String name = file.getName();
//                    boolean starts = name.startsWith(".");//名字是否以"."开始
//                    System.out.println("过滤器过滤:"+name+",是否符合要求:"+starts);
//                    return starts;
//                }
//            };
//            File[] subs = dir.listFiles(filter);//方法内部会调用accept方法

            
            File[] subs = dir.listFiles(new FileFilter(){
                public boolean accept(File file) {
                    return file.getName().startsWith(".");
                }
            });
            System.out.println(subs.length);
        }
    }
}

1.5递归

概述：以递归的角度来看，递归指的是以方法定义中调用方法本身的现象。

public class DiGuiDemo {
    public static void main(String[] args) {
        /*
        递归解决问题，首先就要定义一个方法：
            1.定义1个方法f（n），表示第n个月的兔子对数
            2.那么，第n-1个月的兔子对数如何表示呐？f（n-1）
         */
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i-1] + arr[i-2];

        }
        System.out.println(arr[19]);
        System.out.println(f(20));

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

    }
}

递归解决问题的思路：

把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解；

递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算。

1.6递归求阶乘#####

public class JieChengDemo {
    public static void main(String[] args) {
        //求5的阶乘
        System.out.println("5的阶乘是"+f(5));
    }
    public static int f(int n){
        if(n == 1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

1.7遍历目录

package exercise.File;

import java.io.File;

public class DiGuiDemo2 {
    public static void main(String[] args) {
        /**
         * 需求：给定一个路径（D:\\LOL),请通过递归完成遍历该目录下的所有内容,并把所有文件的          * 绝对路径输出在控制台
         * 思路：
         * 1.根据给定的路径创建一个File对象
         * 2.定义一个方法，用于获取给定目录下的所有内容，参数为第一步创建的file对象
         * 3.获取指定的File目录下所有的文件或者目录的File数组
         * 4.遍历该File数组，得到每一个File对象
         * 5.判断该File对象是否是目录
         *      是，递归调用
         *      否，获取绝对路径输出在控制台
         * 6.调用方法
         */
        File srcFile = new File("d:/LOL");
        getAllFilePath(srcFile);
    }
    public static void getAllFilePath(File srcFile){
        File[] fileArray = srcFile.listFiles();
        if(fileArray != null){
            for(File file : fileArray){
                if(file.isDirectory()){
                    getAllFilePath(file);

                }else {
                    System.out.println(file.getAbsoluteFile();
                }
            }

        }
    }
}

1.8递归删除目录

循环是重复执行某个步骤，而递归是重复整个过程

package file;

import java.io.File;

/**
 * 编写一个程序，要求实现1+2+3+4+....100并输出结果。
 * 代码中不能出现for，while关键字
 *
 * 编写程序计算:
 * 一个人买汽水，1块钱1瓶汽水。3个瓶盖可以换一瓶汽水，2个空瓶可以换一瓶汽水。不考虑赊账问题
 * 问20块钱可以最终得到多少瓶汽水。
 *
 * 删除一个目录
 */
public class Test {
    public static void main(String[] args) {
        File dir = new File("./a");
        delete(dir);
    }

    /**
     * 将给定的File对象表示的文件或目录删除
     * @param file
     */
    public static void delete(File file){
        if(file.isDirectory()) {
            //清空目录
            File[] subs = file.listFiles();
            for (int i = 0; i < subs.length; i++) {
                File sub = subs[i];//从目录中获取一个子项
                //将该子项删除
                delete(sub);//递归调用
            }
        }
        file.delete();
    }
}

1.9Lambda表达式

Lambda表达式，也可称为闭包。JDK8之后，java支持了lambda表达式这个特性

• lambda可以用更精简的代码创建匿名内部类，但是该匿名内部类实现的接口只能有一个抽象方法，否则无法使用。
• lambda表达式是编译器认可的，最终会将其改为内部类编译到class文件中

package lambda;

import java.io.File;
import java.io.FileFilter;

/**
 * JDK8之后java支持了lambda表达式这个特性
 * lambda表达式可以用更精简的语法创建匿名内部类，但是实现的接口只能有一个抽象
 * 方法，否则无法使用。
 * lambda表达式是编译器认可的，最终会被改为内部类形式编译到class文件中。
 *
 * 语法:
 * (参数列表)->{
 *     方法体
 * }
 */
public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类形式创建FileFilter
        FileFilter filter = new FileFilter() {
            public boolean accept(File file) {
                return file.getName().startsWith(".");
            }
        };

        FileFilter filter2 = (File file)->{
            return file.getName().startsWith(".");
        };

        //lambda表达式中参数的类型可以忽略不写
        FileFilter filter3 = (file)->{
            return file.getName().startsWith(".");
        };

        /*
            lambda表达式方法体中若只有一句代码，则{}可以省略
            如果这句话有return关键字，那么return也要一并省略!
         */
        FileFilter filter4 = (file)->file.getName().startsWith(".");
    }
}

    FileFilter filter = new FileFilter() {
        public boolean accept(File file) {
            return file.getName().startsWith(".");
        }
    };

    FileFilter filter2 = (File file)->{
        return file.getName().startsWith(".");
    };

    //lambda表达式中参数的类型可以忽略不写
    FileFilter filter3 = (file)->{
        return file.getName().startsWith(".");
    };

    /*
        lambda表达式方法体中若只有一句代码，则{}可以省略
        如果这句话有return关键字，那么return也要一并省略!
     */
    FileFilter filter4 = (file)->file.getName().startsWith(".");
}

}