长河饮马

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    // 不用手写，直接在IDEA中，按快捷键 alt + insert，然后选择重写equals即可
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

// 集合存储自定义对象
Collection<Student> collection02 = new ArrayList<>();
// 创建自定义对象（准备数据测试）
Student student01 = new Student("张飞",18);
Student student02 = new Student("曹操",20);
Student student03 = new Student("张飞",18);
// 将元素添加到集合中
collection02.add(student01);
collection02.add(student02);
// Student未重写equals方法，返回子：fasle
boolean result01 =  collection02.contains(student03);
// Student重写了equals方法，返回子：true
boolean result01 =  collection02.contains(student03);

Collection<String> collection = new ArrayList<>();
// 当前集合是空集合，则返回：true
// 不是空集合，返回：false
boolean issuccess = collection.isEmpty();

Collection<String> collection = new ArrayList<>();
// 获取集合元素个数
int len = collection.size();

List<String> list = new ArrayList<>();
list.add("赵四");
list.add("刘能");
list.add("谢广坤");
// 删除索引0处的元素
list.remove(0);

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);
// 当List集合中存储的数据是Integer类型的数据时，此时我们我们传入一个整数
// 为什么调用的是remove(int index)，而不是remove(Object object)呢？
Integer removeElement = list.remove(1);

// remove的执行机制：据传入的 参数的类型 进行判断选择哪种remove方法
// 如：我们传入的参数是int类型，则是选择remove(int index)
// 当我们传入的参数是 Integer（引用数据类型），则选择remove(Object object)

// 手动装箱
Integer i = Integer.valueOf(1);
// 选择的是remove(Object object)
boolean success = list.remove(i);

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
// 获取ListIterator对象
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String str = listIterator.next();
    if (str.equals("c")) listIterator.add("e"); // 添加元素
    System.out.println(str);
}
System.out.println(list);

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
// 普通for遍历：
for (int i = 0; i < list.size(); i++) {
    // List集合是有索引的，所以可以通过索引获取对应值
    String str = list.get(i);
    System.out.println(str);
}

add()：当集合中存在指定的元素，则添加失败，返回false
       当集合中不存在指定的元素，则添加成功，返回true

Set<String> set = new HashSet<>();
boolean bool01 = set.add("张三");     // true
boolean bool02 = set.add("张三");     // false

class Person implements Comparable<Person>{
    public String name;
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 重写比较规则的方法
    @Override
    public int compareTo(Person o) {
        // 一定要知道：TreeSet底层是 红黑数的数据结构，所以要知道红黑树是如何存数据和取数据的
        // 才能理解

        // 使用add 添加元素时，会调用 compareTo方法
        // 根据compareTo比较规则，将元素添加到对应的位置
        // 比较对象：
        //      当前添加的元素 与 集合中存在的元素 比较
        // compareTo的返回值：
        //  正数：表示当前添加的元素大，存在元素（集合中存在的）节点的右边
        //  负数：表示当前元素小，存在元素（集合中存在的）节点的左边
        //  0：表示在集合中已经存在该元素，添加失败


        /*
        * this：当前添加的元素
        * o：已经在集合中存在的元素
        * 返回值：
        *       负数：表示当前元素小，存在元素（集合中存在的）节点的左边
        *       正数：表示当前添加的元素大，存在元素（集合中存在的）节点的右边
        *        0：表示在集合中已经存在该元素，添加失败
        * 注意：
        *   在比较大小时，会多次调用该方法，直到找到 元素存储的位置（节点）
        * */
        // 按年龄比较
        int result = this.getAge() - o.getAge();
        return result;
    }
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

TreeSet<String> treeSet2 = new TreeSet<>(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            // o1：当前添加的元素
            // o2：集合中存在的元素
            // 根据字符串长度比较大小
            int result = o1.length() - o2.length();
            // 如果长度为0，则调用默认的比较方法比较
            if (result == 0) return o1.compareTo(o2);
            return result;
        }
    });

// 路径字符串
File file01 = new File("E:\\Users\\C\\Desktop\\a.txt");

// 父路径 + 子路径 拼接
File file02 = new File("E:\\Users\\C\\Desktop","a.txt");

// 父路径文件对象 +  子路径字符串 拼接
File file03 = new File("E:\\Users\\C\\Desktop");    // 父路径 文件对象
File file04 = new File(file03,"a.txt");             // 父路径文件对象 + 子路径字符串

File file = new File("D:\\Lenovo\\桌面\\a.txt");
// 1. 判断是否是文件夹
boolean bool01 = file.isDirectory();
System.out.println(bool01);

// 2. 判断是否是文件
boolean bool02 = file.isFile();
System.out.println(bool02);

// 3. 判断File表示的路径是否存在
boolean bool03 = file.exists();
System.out.println(bool03);

// 4. 获取文件的大小（字节数）
// 注意：
// length()只能获取 文件的 大小，不能获取文件的大小
// 如果想获取文件夹的大小，则需要将文件夹内的所有文件的大小相加即可
long size = file.length();
System.out.println(size);

// 5. 返回文件的绝对路径
String path = file.getAbsolutePath();
System.out.println(path);

// 6. 返回定义文件时使用的路径
String path02 = file.getPath();
System.out.println(path02);

// 7. 返回文件名
// 注意：如果是文件，则会带上文件的后缀名，如果是文件夹，则会直接返回文件夹的名字
String fileName = file.getName();
System.out.println(fileName);

// 8. 返回文件最后修改的时间
long date = file.lastModified();
System.out.println(date);

 File file01 = new File("D:\\Lenovo\\桌面\\b.txt");

// 1. 创建空文件
// 返回值：创建文件是否成功
//      当路径表示的文件存在，则创建失败，返回false
//      当路径表示的路径不存在，则创建成功，返回true
// 当路径是错误的（如：父级路径不存在），则程序直接抛出异常

// 注意：createNewFile创建的一定是文件，当给的路径是没有后缀名的，则会创建一个没有后缀名的文件
boolean bool01 = file01.createNewFile();
System.out.println(bool01);

// 2. 创建目录
// 注意：
//  1. 当创建的文件夹，存在则创建失败，返回false
//  2. mkdir只能创建单级文件夹，不能创建多级文件夹（父级目录也不存在）
//  3. 父级目录不存在时，创建文件夹失败，返回false，程序不会抛出异常
File file02 = new File("D:\\Lenovo\\桌面\\ee\\ff");
boolean bool02 = file02.mkdir();
System.out.println(bool02);

// 3. 创建多级文件夹（既能创建单级目录，也可以创建多级目录）
File file03 = new File("D:\\Lenovo\\桌面\\ee\\ff");
boolean bool03 = file03.mkdirs();
System.out.println(bool03);

// 4. 删除文件 或 空文件夹（）
File file04 = new File("D:\\Lenovo\\桌面\\b.txt");
boolean bool04 = file04.delete();
System.out.println(bool04);
// 如果删除的目录，不是空的，则删除失败，返回false
File file05 = new File("D:\\Lenovo\\桌面\\ee\\ff");
boolean bool05 = file05.delete();
System.out.println(bool05);

// 注意：delete只能删除 文件 和 空文件夹  不走回收站

File file = new File("D:\\Lenovo\\桌面\\ee");
File[] files = file.listFiles();
// 遍历并删除
for (File file1 : files) {
    // 在删除之前应该要判断是否是文件还是文件夹
    // 原因：delete只能删除空文件夹，所以要做特殊处理
    // 这里没有做判断，是因为测试时，目录全是空的
    boolean bool = file1.delete();
    System.out.println(bool);
}

File[] arr = File.listRoots();

// 如果是文件夹，则是文件夹名，如果是文件，则是文件名（有后缀）
// 与listFiles()的区别：
//  list只能获取文件名，而listFiles获取到的是完整的路径
File file01 = new File("D:\\Lenovo\\桌面\\ee");
String[] strings = file01.list();

// FilenameFilter：函数式接口
String[] strings1 = file01.list(new FilenameFilter() {
    /*
    *   dir：父级路径
    *   name：文件名（没有路径，仅仅是名字）
    *   返回值：true，则表示满足条件，保留，如果false，则当前文件舍弃
    * */
    @Override
    public boolean accept(File dir, String name) {
        // 所有的内容都舍弃
        return false;
    }
});

public class MyThread extends Thread{
    @Override
    public void run() {
        // 编写线程执行的代码
        for (int i = 0; i < 10; i++) {
            System.out.println(getName());
        }
    }
}

class Test {
     MyThread myThread = new MyThread();
}