我在自己写LinkedList的时候，不知道怎么直接打印输出LinkedList的内容，就像系统那样输出，本想重写toString()方法，但是不知道怎么具体实现，请老师给予指点；

老师，当主线程处于未阻塞状态时，子线程会等待主线程结束后在执行，当线程处于阻塞状态时，主线程开始执行后，子线程就不用等待主线程结束，直接开始执行，在当线程恢复未阻塞状态时，先结束主线程，在结束子线程。

这里的tytes[]数组获取的是带泛型参数的类型

为啥遍历之后还有输出没有带泛型的第三个参数String类型

这个听起来有点不太懂啊老师,这里是必须掌握吗

老师，一个汉字占两个字节，为什么我文本里面写汉字，read出来的int个数是汉字数的三倍？

老师，您好：

我想写一个工具类（突发奇想，想练练。。。），用fileinputstream读文件，然后用ByteArrayOutputStream的toByteArray()方法得到字节数组，并将字节数组返回。但这个方法的返回值应该写哪？写在最后，流应该close了，老师以后这种问题有没有什么固定套路去处理的。谢谢老师。

1.老师好，String类是不可变字符序列，代码第二行对对象str1进行了重新赋值（str1值改变了），代码第三行对字符串进行了截取（str1值又改变了）。String类是不可变字符序列，指的是String类无法修改数组引用地址的常量值，但是可以改变数组的引用（代码第二行，生成新的常量“hello”，不覆盖原来的常量“he”）达到对值的改变，我的理解对吗，麻烦老师再讲解一下，这里不太懂？

2.代码第五六行，在内存空间里，执行完第六行，1是会被2覆盖掉吗？

String str1 = new String("he");
str1 = "hello";
str1 = str1.substring(0,1);
int a = 1;
a = 2;

老师您好能麻烦您具体介绍一下一下代码的逻辑吗？

看到这位同学跟老师的解答，产生了疑惑：

视频里的add方法当中有写：

所以key对应的value应该不是null ，而是一个一个的object类型的对象 new Object();

老师为什么要加上一个休眠啊

老师，我的Users  类如下：

import java.util.Objects;

public class Users implements Comparable<Users>{
  private String usersname;
  private int  usersage;

    public Users(String yanggege, String s) {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Users users = (Users) o;
        return usersage == users.usersage &&
                Objects.equals(usersname, users.usersname);
    }

    @Override
    public int hashCode() {
        return Objects.hash(usersname, usersage);
    }

    public Users(String usersname, int usersage) {
        this.usersname = usersname;
        this.usersage = usersage;
    }

    public String getUsersname() {
        return usersname;
    }

    public void setUsersname(String usersname) {
        this.usersname = usersname;
    }

    public int getUsersage() {
        return usersage;
    }

    public void setUsersage(int usersage) {
        this.usersage = usersage;
    }

    @Override
    public String toString() {
        return "Users{" +
                "usersname='" + usersname + '\'' +
                ", usersage=" + usersage +
                '}';
    }

    @Override
    public int compareTo(Users o) {
        if (this.usersage>o.getUsersage()){
            return 1;
        }
        if (this.usersname==o.getUsersname()){
            return this.usersname.compareTo(o.usersname);
        }
        return -1;
    }
}

TreeMap 代码：

 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;

public class TreeMapTset {
    public static void main(String[] args) {

        //实例化RreeMap
        Map<Users,String> map=new TreeMap<>();
         Users u1=new Users("杨明","24");
         Users u2=new Users("李飞","19");
         Users u3=new Users("张哥","10");
         Users u4=new Users("陈飞信","55");
         map.put(u1,"杨明");
         map.put(u2,"zangxiao");
         map.put(u3,"sixiaozi");
         map.put(u4,"lixiaozo");
         Set<Users> set=map.keySet();
         for (Users str:set){
            System.out.println(str+"====="+map.get(str));
         }

    }


}

输出：请问下是哪里错了。

/**
 * 创建缓冲区
 * 要点：
 * 1、创建缓冲区空间大小（目前是数组空间）  →  生产者生产数据  →  判断空间是否满了？满了就进入阻滞状态调用Object下面wait方法
 *    满了消费者没来拿数据，就需要唤醒消费者 （调用Object下面notify方法唤醒单个线程）
 * 2、消费者来拿  →判断有没有数据  →  如果没了就进入阻滞状态  →  同时唤醒生产者线程
 */


//定义馒头类
class ManTou{
    private int id;
    public ManTou(int id){
        this.id=id;
    }

    public int getId() {        //私有属性需要
        return this.id;
    }
}

//定义缓冲区
class SycStack{          //缓冲区不需要继承谁，它只是一个放数据地方
    //定义放馒头的空间
    private ManTou[] mt =new ManTou[10];

    //定义操作空间的索引；
    private int index;

    //放馒头
    public synchronized void push(ManTou manTou) throws InterruptedException {
        while(this.index==this.mt.length){          //放数据之前要先判断空间满没满，用循环多判断几次，一次不保险

            this.wait();    //Object  类下的   让线程休眠的方法；  必须在synchronized域内使用。 会先释放对象锁，再休眠。

        }
        this.notify();   //Object  类下  唤醒单个线程的方法，必须在synchronized域内使用。会唤醒在等待队列状态中的  单个线程。/notifyAll是全部线程
        this.mt[this.index]=manTou;    //放馒头时需要知道位置，默认是0；
        this.index++;    //每放一个，索引＋1，直到空间满了
    }

    //取馒头
    public synchronized  ManTou pop() throws InterruptedException {
        while (this.index==0){
            this.wait();
        }
        this.notify();     //对方线程若是处于运行状态  唤醒也无妨
        this.index--;
        return this.mt[this.index];   //先判断，不为空则 拿一个，拿完之后把剩下的返回；
    }
}

//定义生产者线程
class ShengChan extends Thread{
    private SycStack ss;     //生产的数据要放在缓冲区，
    public ShengChan(SycStack ss){
        this.ss=ss;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("生产的馒头"+i);
            ManTou mt=new ManTou(i);    //不知道这里为什么这么做，要创建馒头对象
            try {
                this.ss.push(mt);     //调用放馒头的方法
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//定义消费者线程
class XiaoFei extends Thread{
    private SycStack ss;     //消费的数据也放在缓冲区，
    public XiaoFei(SycStack ss) {
        this.ss = ss;

    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            try {
                ManTou manTou = this.ss.pop();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("消费的馒头"+i);
            }
    }

}


public class TestProduceTread {
    public static void main(String[] args) {

        //s实例化缓冲区
        SycStack ss=new SycStack();

        //实例放、取馒头化线程
        new ShengChan(ss).start();
        new XiaoFei(ss).start();
    }
}

老师为什么我的代码结果是顺序排的？试了几次都这样

老师，您好。我这个代码怎么不能执行，找不到run

package com.itbaizhan;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.FileInputStream;
import java.io.IOException;

public class Test2 {
    public static void main(String[] args) {
        FileInputStream fis = null;
       try{
            fis = new FileInputStream("c:/a.txt");
            StringBuilder sb = new StringBuilder();
            int temp = 0;
            while ((temp = fis.read()) !=-1){
                sb.append((char) temp);
            }
           System.out.println(sb);
       }catch (Exception e){
            e.printStackTrace();
       }finally {
                try {
                    if(fis !=null) {
                        fis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();

            }
       }
    }
}

list容器和数组容器的区别是什么，感觉功能除了动态性其他都一样，那为何不用List容器去代替数组存储呢？

老师，为什么这些对象都需要手动关闭呢，为什么不会自动关闭呢