老师，前面这里是Mylist，后面是MyDoublyLinkedList,这是什么形式来着不记得了

老师这个视频的那些注释的代码怎么快捷键生成的

public static void main(String[] args) {
	//实例化list容器
	List<String>list = new ArrayList<>();
	//添加元素
	boolean flag1 = list.add("oldlu");
	boolean flag2 = list.add("itbz");
	boolean flag3 = list.add("sxt");
	boolean flag4 = list.add("sxt");
	System.out.println(flag1+"\t"+flag2+"\t"+flag3+"\t"+flag4);
	System.out.println("---------------------------");
	System.out.println(list);

老师，最后那一行直接对容器做输出，是不是也能得到容器中的所有元素？

在

我想问一下为什么temp = fis.read（）这个temp不是指的是读取时的编码吗，为什么可以当做buffer数组的长度

老师我这个reader为啥是红的

老师这里为什么说reader是int类型 为啥又要转为char字符类型

已解决，不够细心。。。。

package com.Thread;

/**
 *测试缓冲区的作用
 */
public class TestBufferThread {
    public static void main(String[] args) {
      SyncStack ss=new SyncStack();
      new XiaoFei(ss).start();
        new Product(ss).start();
    }
}
/***
 * 设置一个馒头类
 */
class Mantou{
    private int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = 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++;
        }
    }
    /**
     * 取馒头
     */
    public synchronized Mantou pop(){
        while(this.index == 0){
            try {
                /**
                 * 语法：wait(),该方法必须要在synchronized块中调用。
                 * wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
                 * 其他需要该对象锁的线程就可以继续运行了。
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.mt[this.index];
    }

}
   /**
 * 定义生产者线程
 */
class  Product extends Thread{
       //传入缓冲区
       private SyncStack ss;
       public Product(SyncStack ss){
           this.ss=ss;
       }
       @Override
       public void run() {
           for (int i = 0; i <10 ; i++) {
               Mantou mt=new Mantou();
               mt.setId(i);
               System.out.println("生产馒头"+mt.getId());
               this.ss.push(mt);
           }
       }
   }
/**
 * 定义消费者线程
 */
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++){
            Mantou mt = this.ss.pop();
            System.out.println("消费馒头："+mt.getId());
        }
    }
}

老师，帮我看看，只启动生产者线程，消费者线程没反应?

对于同一个对象的多种操作，存在逻辑上的先后顺序，就应该采用线程同步锁吗？

可以这么理解吗？

对于同一个对象，存在逻辑上的先后顺序，就应该采用线程同步锁吗？

可以这么理解吗？

老师为什么stream要放在collectors中

老师这个ele是什么意思，为什么可以直接用ele.调用startWith这些方法

老师从这些代码怎么看出反射机制，反射表现在哪些方面

老师完全看不懂，该怎么学习理解呢？