非静态泛型方法这里第一句 new 静态泛型方法第一句不可以 new

没听懂   问题是非静态泛型方法需要new 静态泛型方法不能new吗

为啥输出不了这个数组呢？

我想问一下，视频里老师是按了什么键才开始截图的啊？

请问我用trycatch的语法糖可以吗，这样还需要写finally吗？还有我的txt文件内容是：kjl牛逼，结果它输出了kjl，牛逼输出却乱码是咋回事，setting-encoding上我全部改为utf-8也不行

老师，这里面的自定义对象，是相当于一个manager类名，意思就是同一个经理对两个不同的员工敬酒，所以是在线程类里设置的synchronized（this.manager)吗？

还有一个疑问就是，259，260，261这三节课设计的都是可以在方法里，定义线程锁。那么设计成什么样子，是不可以在方法里定义线程锁必须在线程里设置锁？

老师，为什么这里声明ArrayList的时候，要用List<>

List<String> list = new ArrayList<>();

好像其他地方也有这样的，用父类来声明，new 子类。

代码：

/**
 * 获取当前结点的祖先结点
 */
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);

还是不太理解这个为啥是这样打印的，第一行递归的时候不是应该到4那里停止了吗？

此时的当前结点不是在4吗？再执行第三行的递归，其中结点值为4的右节点不是为空吗？

怎么返回的？

想问下下面代码，最后两行颠倒是否会有影响。

先写入磁盘，在换行，那么唯一的区别是，在exit后，这样的写入的最后一行少一行回车吗？

是否还有别的区别呢？

package com.bjxst;

public class MyDoublyLinkedList<E> implements MyList<E> {
    private Node head;
    private Node tail;
    private int size;

    @Override
    public void add(E element) {
        this.linkedLast(element);

    }
    private void linkedLast(E element){
        //首先获取尾部节点
        Node t = this.tail;
        //创建节点对象
        Node node1 =new Node(t,null,element);

        node1=this.tail;
        if(t==null){
            node1 =this.head;
        }else{
            node1 = t.next;
        }
        this.size++;
    }

    @Override
    public E get(int index) {
        //对Index做合法性校验
        this.checkIndex(index);

        //根据节点对象查找位置
        Node<E> node = this.getNode(index);
        return node.item;

    }
    private void checkIndex(int index){
        if(!(index>=0&&index<this.size)){
            throw new IndexOutOfBoundsException("index"+index+"size"+size);
        }
    }
    private Node getNode(int index){
        if (index<(this.size>>1)){
            Node node = this.head;
            for (int i=0;i<index;i++){
                node = node.next;
            }
            return node;
        }else{
            Node node = this.tail;
            for (int i=this.size-1;i>index;i--){
                node = node = node.prev;
            }
            return node;
        }




    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public E remove(int index) {
        //对index进行合法性校验
        this.checkIndex(index);
        //根据指定位置获取节点对象
        Node<E> node = this.getNode(index);
        //获取节点对象中的元素
        E item = node.item;
        //判断当前节点是否为头节点
        if(node.prev ==null){
            node.next=this.head;

        }else{
            node.prev.next = node.next;

        }
        //判断当前节点是否为尾结点
        if(node.next==null){
            node.prev = this.tail;
        }else{
            node.next.prev = node.prev;
        }
        node.next =null;
        node.prev= null;
        node.item =null;

        this.size--;
        return item;


    }
    //创建节点内部类
    class Node<E>{
        E item;
        Node<E> prev;
        Node<E> next;
        Node(Node<E> prev,Node<E> next,E item){
            this.prev = prev;
            this.next=next;
            this.item = item;
        }
    }
    public void addFirst(E element){
        this.linkFirst(element);
    }
    private void linkFirst(E element){
        //获取头结点对象
        Node head = this.head;
        Node node1 = new Node(null,head,element);
        //将新节点定为头节点
        node1 =this.head;

        if(head==null){
            node1 = this.tail;
        }else{
            node1=head.prev;
        }
        this.size++;
    }
    public void addLast(E element){
        this.linkedLast(element);
    }

    public static void main(String[] args) {
        MyList<String> myList = new MyDoublyLinkedList<>();
        myList.add("a");
        myList.add("b");
        myList.add("at");
        myList.add("e");
        myList.add("e");



        System.out.println(myList.remove(3));
    }
}

老师，为什么t调用join方法，就是主线程和A线程联合了？

麻烦详细点

老师，java不是双字节的吗？一个中文字符占两个字节，那么一个英文字符不是也应该占两个字节吗

1.老师，我在百度的时候，发现一个问题
对于一个对象的成员方法，这些方法中包含本地变量，仍需要存储在栈区，即使它们所属的对象在堆区。
但是视频中，老师讲解的是成员方法是放在堆中，怎么现在需要存储在栈中？

为什么我这个根据IP地址打印的主机名和IP地址一样呢

老师，请问PrintWriter是有将字符流转化为字节流的作用吗？