老师，这个的具体作用是什么呢，这个每个单词到底是代表什么意思呢

老师说的链表转红黑树的条件不太全面。有2个条件：1，数组任意索引下的节点个数达到8个 。2，数组长度达到64

老师如果不清楚文件里是什么数据应该怎么读？

int[] arr = new int[]{10,20,30,40,50,60,70,80,90,100};
for(int i = 0;i<arr.length;i++){
    raf.writeInt(arr[i]);
}
raf.seek(4); 
System.out.println(raf.read());

我这样直接调用read()返回的是0

为啥不是呢？原来有一位了，既然3+1都可以等于4，为啥不可以8+1等于9？

老师请问下, jaxen这个包是干什么用呢? 在示例代码中完全没有用到jaxen这个包, 为什么还要添加到Build path中呢?

老师您好，它报类型转换异常，146行，怎么解决呢。

package com.gakki.thread;

public class TestSynchronized implements Runnable{
  //声明票的数量
  private int ticket = 100;

  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      this.saleTicket();
    }
  }
  private synchronized void saleTicket() {
    if (ticket > 0) {
      try {
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + "正在卖第" + (ticket--) + "张票");
    }
  }
}

package com.gakki.thread;

public class TestTicket {
  public static void main(String[] args) {
//    Ticket ticket = new Ticket();
    TestSynchronized ticket = new TestSynchronized();
    Thread thread1 = new Thread(ticket, "窗口A");
    Thread thread2 = new Thread(ticket, "窗口B");
    Thread thread3 = new Thread(ticket, "窗口C");

    thread1.start();
    thread2.start();
    thread3.start();
  }
}

问题：我票的数量改了，等待时间也挺长的 依旧是只有A窗口在卖票。 我设置过300的票，它会走完A 的100个人 才到下一个  这是为什么呀？

用idea打开eclipse看不了注释怎么解决??

char c=(char)reader.read();

老师这句上节课讲的也有异常  为啥这节课不放在try的括号里面也不报红

最后一步始终报空指针，配置了XML也报空指针，火狐，谷歌浏览器都试了，也是一样，附上代码

为什么我这个运行之后结果和老师有点不一样

知道哪里错了， 谢谢老师，

Animal a=new Dog()和Dog s=new Dog()有什么区别吗？a instanceof Cat那a不就是算是cat类型的，为啥还要强转成Cat类型？转完之后有啥区别？

我这里为什么会报错。。。。。。。。。。。。。。

在测试自定义容器中，获取祖先结点的时候，发现获取的元素数量少了，已反复核实代码，未能找到问题，请老师给看看，谢谢！

package com.bjsxt;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 基于树形结构实现元素存储的容器
 */
public class MyTree<E> {
    private Map<E,E> map = new HashMap<>(); //String ----> String
    private Map<E,List<E>> map2 = new HashMap<>(); //String ---> list
    /**
     * 向容器中添加元素
     */
    public void add(E parent,E item){
        //完成单结点之间映射
        this.map.put(item,parent);
        //完成多结点之间映射
        List<E> list = this.map2.get(parent);
        //判断当前结点下是否含有子结点，如果没有则创建一个list
        if(list == null) {
            list = new ArrayList<E>();
            map2.put(parent, list);
        }
        list.add(item);
    }
    /**
     *获取当前结点的父结点
     */
    public E getParent(E item){
        return  this.map.get(item);
    }
    /**
     * 获取当前结点的子结点
     */
    public List<E> getChild(E item){
        return  this.map2.get(item);
    }
    /**
     * 获取当前结点的兄弟结点
     */
    public List<E> getBrother(E item){
        //获取当前节点的父结点
        E parent = this.getParent(item);
        //获取当前父结点的所有子结点
        List<E> list = this.getChild(parent);
        List<E> brother = new ArrayList<>();
        if(list != null){
            brother.addAll(list);
            brother.remove(item);
        }
        return brother;
    }
    /**
     * 获取当前结点的祖先结点（祖先结点包括父结点）
     */
    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;
    }
    /**
     * 获取当前结点的子孙结点
     */
    public List<E> getGrandChildren(E item){
        //存放所有子孙结点中的元素
        List<E> list = new ArrayList<>();
        //获取当前结点的子节点
        List<E> child = this.getChild(item);
        //结束递归的边界条件
        if(child == null){
            return list;
        }
        //重点 for循环中的  递归调用！！ 递归方法的返回值和压栈
        for(int i=0;i<child.size();i++){
            //获取结点中的元素
            E ele = child.get(i);
            List<E> temp = this.getGrandChildren(ele);
            list.add(ele);
            list.addAll(temp);
        }
        //当前结点的子结点 完全添加  当前结点的子节点的子节点
        return list;
    }

    public static void main(String[] args) {
        //实例化容器
        MyTree<String> myTree = new MyTree<>();
        //添加元素
        myTree.add("root", "生物");
        myTree.add("生物", "植物");
        myTree.add("生物", "动物");
        myTree.add("生物", "菌类");
        myTree.add("动物", "脊索动物");
        myTree.add("动物", "脊椎动物");
        myTree.add("动物", "腔场动物");
        myTree.add("脊柱动物", "哺乳动物");
        myTree.add("脊柱动物", "鱼类");
        myTree.add("哺乳动物", "猫");
        myTree.add("哺乳动物", "牛");
        myTree.add("哺乳动物", "人");
        System.out.println("---------获取父结点----------");
        String parent = myTree.getParent("鱼类");
        System.out.println(parent);
        System.out.println("---------获取子结点----------");
        List<String> child = myTree.getChild("动物");
        for(int i=0;i<child.size();i++){
            System.out.println(child.get(i));
        }
        System.out.println("---------获取兄弟结点----------");
        List<String> brother = myTree.getBrother("脊椎动物");
        for(int i=0;i<brother.size();i++){
            System.out.println(brother.get(i));
        }
        System.out.println("---------获取祖先结点----------");
        List<String> foreFather = myTree.getForeFathers("人");
        for(int i=0;i<foreFather.size();i++){
            System.out.println(foreFather.get(i));
        }


    }
}

运行效果图：

视频中运行效果图：