老师好，关于二叉树遍历的递归算法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p== null && q == null) return true;
        if(p==null || q==null) return false;
        
        if(p.val!= q.val) return false;
        
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        
    }
}

因为之前关于递归只讲了阶乘的例子，所以这里用true or false时候并不太懂，主要有两个问题：

（1）

当左右节点的深度不同时，最终的判断的终止条件在哪里？

比如一个二叉树，它的左子树（p）的深度为2，右子数（q）的深度为5.（如下图）

那么，该递归的终止条件，是深度为2时，p.left p.right都是为null，跳出递归？还是到深度为5时，q的子节点也都遍历完成后，才跳出递归？

（2）

关于boolean类型递归是如何作用的。

之前关于递归只讲到阶乘，是递归直到调用到n=1 return 1, 才会一点点向上返回每次递归调用的值。

但是，这里就不是很懂是如何作用的，假设只有最后的p.left和q.left不同，（如下图）

那么，是如阶乘的算法一样，第一层是先开始isSameTree()方法，

到第二层后，判断为false && true， 所以return false，

然后关闭第二层栈堆，然后到第一层， 判断为 true && true， return true

最后结束程序？

那么这样的话，不就是return了两个值？分别是false和true？

这里的递归倒是是怎么作用的？谢谢

老师，o1和o2分别代表什么意思？compareTo方法是能够自身比较是吗？

public class TestTreeSet02 {

    public static void main(String[] args) {

        Set<User> set = new TreeSet<>();
        User u = new User("oldlu",18);
        User u1 = new User("lili",22);
        User u2 = new User("admin",22);
        set.add(u);
        set.add(u1);
        set.add(u2);
        for(User user:set){
            System.out.println(user);
        } 
    }
}
class User implements Comparable<User>{  

    private String userName; 
    private int userAge; 

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    // 无参构造器
    public User() {
    }
    // 带参构造器
    public User(String userName, int userAge) {
        this.userName = userName;
        this.userAge = userAge;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "姓名：" + userName + ", 年龄：" + userAge ;
    }

    // 重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return userAge == user.userAge &&
                Objects.equals(userName, user.userName);
    }
    // 重写hashCoded方法
    @Override
    public int hashCode() {
        return Objects.hash(userName, userAge);
    }

    // 重写比较器方法 定义比较规则
    // 正数：大  负数：小   0：相等
    @Override
    public int compareTo(User o) { 
       // 通过年龄进场比较 由小到大
        if(this.userAge > o.getUserAge()){
            return 1;
        }
        // 如果年龄相同，按姓名进行排序
        if(this.userAge == o.getUserAge()){
            return this.userName.compareTo(o.getUserName());
        }
        return -1;  
    }
}

我在compareTo方法直接返回-1 会按照年龄从大到小排序，年龄相等的也会按照姓名顺序排序，这是为什么?

但是如果我return 0 就只返回第一个添加的

public void add(E element) {
    this.linkLast(element);
}

//将节点对象添加到双向链表的尾部
private void linkLast(E element){
    //获取尾节点
    Node<E> lastNode = this.tail;
    //创建节点对象（通过有参构造完成了新节点的直接前驱的挂接）
    Node<E> node = new Node<>(element,lastNode,null);
    //将新节点定义为尾节点
    this.tail = node;
    //尾节点为空则代表双链表没有节点，则这个新节点要被头尾两个节点指向
    if (lastNode == null){
        this.head = node;
    }else {
        //完成了尾节点对新节点的挂接
        lastNode.next = node;
    }
    this.size++;
}

第一个数总是打印不出来，被第二个代替，也没有报错，麻烦老师看一下哪里错了

老师，为什么this.list.size()==0就能表示容器是否为空？不应该是为null吗？还有就是这段代码能换成这样的吗？

老师，这个调用person的setId方法是什么意思？干嘛用的？

老师可以更新一下新版本JDk的底层源码分析吗？看新版本的还是有些不明白

可变参数一定是数组？这个到底用来干嘛的？

老师在实现接口的时候就在接口里给定了泛型，那为啥还要再实列化类的时候再类声明泛型，不是多此一举嘛

老师，就是我画红线的那一句是什么意思？有什么作用？

两个对象a,b   内容相同+hashcode 相同    a==b?  

list<string> list =new arraylist<>();

这个是向上转型，子类对象转换成父类（接口），list可以调用自身的方法，而arraylist中特定的方法是无法调用的。

问题是：system.out.println(list)可以打印list的内容，调用了toString方法。而toString方法是arraylist从AbstractCollection父类中继承过来的。为什么list可以调用arraylist中特定的toString方法呢？

老师，这个有点懵了

=String();
=;

不是同一个初始化方式嘛

老师好，我在应用ArrayList练习算法时遇到如下问题：

题目如下：

代码：

/**
 * 获取当前结点的祖先结点
 */
public List<E> getForefathers(E item){
    //获取当前结点的父结点
    E parent = this.getParent(item);
    //结束递归的边界条件
    if (parent == null){
        return new ArrayList<>();
    }
    //递归调用，再次获取当前父结点的父结点
    List<E> list = this.getForefathers(parent);
    //将递归到的所有结点元素添加到返回的 list 中
    list.add(parent);
    return list;
}

问题一：请问这里的List对象是在第一次运行代码的时候就创建的吗？

    //递归调用，再次获取当前父结点的父结点
    List<E> list = this.getForefathers(parent);

还是在最后一次递归到根结点时返回的new ArrayList呀？

    if (parent == null){
        return new ArrayList<>();
    }

问题二：如果是在第一次运行就创建的List对象，那么这里每次运行都是这段代码，不会每次递归都创建一个新的List对象吗？

    List<E> list = this.getForefathers(parent);