我有一个问题容器中本身已经添加了一个元素 那么addfirst方法添加的元素是怎么与已经有的元素实现相互地址的挂钩的呢 原来元素前面的地址不是指向伟空吗？

老师，我这个Ip地址怎么改过来？？？？？？？

上面我知道是为了判断是否存在这个文件，那为什么这里也要捕获异常呢？

老师 为什么输入流在关闭流的时候可以不加判断，难道输入流不会存在为null的现象吗？

public List getAncestor(E item){ //获取当前结点的父结点 E parent = this.getParent(item); //给出递归的边界条件 if (parent == null){ return new ArrayList<>(); } //递归操作 List list = this.getAncestor(parent); list.add(parent); return list;}老师这个方法最后满足递归结束条件后是不是可以这样理解假设每次递归传入的item为p1,p2,p3...pn直到第n次满足递归结束条件List list = new ArrayList<>();list.add(pn-1);list.add(pn-2);... ...list.add(p1);return list;

我的代码一直在跑，完全没有阻塞效果，跑了几千都还在跑

老师不好意思，我提问的乱码了，不会撤回，这种现象正常吗

老师，为啥运行了几次之后会出现先消费馒头啊/** * 消费者与生产者 */package com.company;/** * 定义一个馒头类 */class ManTou{ private int Id; public ManTou(int Id){ this.Id=Id; } public int getId() { return Id; }}/** * 定义缓冲区 */class SyncStack{ //定义存放盒子的馒头 private ManTou[] mt =new ManTou[10]; //定义操作盒子的索引 private int index; /** * 放馒头 */ public synchronized void push(ManTou manTou){ //判断盒子是否已满 while (this.index==this.mt.length) try { /** * 语法：wait();该方法必须要在synchronized块中调用。 * wait();执行后，会将持有的对象锁释放，并进入阻塞状态。 * 其他需要该对象锁的线程就可以继续运行了。 */ this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } //唤醒取馒头的线程 /** * 语法：必须要在synchronized块中调用。 * 该方法会唤醒等待状态队列中的一个线程。 */ this.notify(); this.mt[this.index]=manTou; this.index++; } /** * 取馒头 * @return */ public synchronized ManTou pop(){ while (this.index==0){ try { /** * 语法：wait();该方法必须要在synchronized块中调用。 * wait();执行后，会将持有的对象锁释放，并进入阻塞状态。 * 其他需要该对象锁的线程就可以继续运行了。 */ this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } /** * 语法：必须要在synchronized块中调用。 * 该方法会唤醒等待状态队列中的一个线程。 */ this.notify(); this.index--; return this.mt[this.index]; }}/** * 生产者线程 */class Shengchan extends Thread{ private SyncStack ss; public Shengchan(SyncStack ss){ this.ss=ss; } @Override public void run() { for (int i=0;i<10;i++){ System.out.println("生产馒头:"+i); ManTou manTou=new ManTou(i); this.ss.push(manTou); } }}/** * 消费者线程 */class xiaofei extends Thread{ private SyncStack ss; public xiaofei(SyncStack ss){ this.ss=ss; } @Override public void run() { for (int i=0;i<10;i++){ System.out.println("消费馒头:"+i); } }}public class ProduceThread { public static void main(String[] args) { SyncStack ss=new SyncStack(); new Shengchan(ss).start(); new xiaofei(ss).start(); }}

老师 可以直接将”obj“这个对象理解为在反射机制下就是通过它作为桥梁为“userage”赋一个18的值吗？其实最后这个“Object”对象去实例化新的对象有点类似于泛型的意思

String[] stringArray = list.toArray(new String[list.size()]);for (String sb : stringArray) { System.out.println(sb);}老师，为何 new String 后面是跟中括号？

老师，类 showFlag 方法中的形参，第一个Generic 指类名，那第二个形参 generic 是什么含义？要求调用该方法需要传进来一个 Generic 类型的对象嘛？

public class Generic<T> {

    private T flag;

    public T getFlag() {
        return this.flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {

        showMsg showMsg = new showMsg();
        Generic<Integer> generic01 = new Generic<Integer>();
        generic01.setFlag(20);
        showMsg.showFlag(generic01);

        Generic<Number> generic02 = new Generic<>();
        generic02.setFlag(90);
        showMsg.showFlag(generic02);

        Generic<String> generic03 = new Generic<String>();
        generic03.setFlag("admin");
        showMsg.showFlag(generic03);
    }
}

class showMsg {

    public void showFlag (Generic<?> generic) {
        System.out.println(generic.getFlag());
    }
}

老师，下面两个 new 语句中，第一行右边的 GenericClass<String>()，第二行右边仅是 GenericClass<>()。这两种写法有啥区别嘛？

public class GenericClass<T> {

    private T flag;

    public T getFlag() {
        return flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {

        GenericClass<String> generic01 = new GenericClass<String>();
        GenericClass<String> generic02 = new GenericClass<>();   // 这两种写法有啥区别？

        generic01.setFlag("admin");
        String flag = generic01.getFlag();
        System.out.println(flag);


        GenericClass<Integer> generic03 = new GenericClass<>();
        generic03.setFlag(100);
        Integer num = generic03.getFlag();
        System.out.println(num);
    }
}

这块我还是不太明白，比如说左子树不为空时，执行这行代码进行递归

this.left.inorderTraverasl();

当左子树为空时，是不是应该执行这行代码进行输出

System.out.println(this.item);

后续判断右子树不为空时，继续执行这行代码继续进行递归

this.right.inorderTraverasl();

但是为什么右子树后面就不用添加这行代码进行输出了呢，而是直接在左子树的输出代码进行打印

System.out.println(this.item);

代码正常运行，就是服务端没有实现long类型数据的传递

定义了一个Message泛型类，默认泛型类型为Object，但不等同于Message<Object>。

是如果定义为Message<String>,两者就不是相同类型的对象，可以这样理解吗？