老师，为什么我这个代码好奇怪，为什么我都是先生产完再消费？

一、

/**
 * 对象流将list存储(序列化)到文件中
 */
public void savePersonList() {
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/a.txt")));
        for (int i = 0; i < this.list.size(); i++) {
            oos.writeObject(this.list.get(i));
        }
        oos.flush();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (oos != null) {
                oos.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、

/**
 * 获取文件的对象信息（对象的反序列化）
 */
public void getPersonList() {
    //声明流
    FileInputStream fis = null;
    ObjectInputStream ois = null;
    try{
        //实例化流对象
        fis = new FileInputStream("d:/a.txt");
        ois = new ObjectInputStream(new BufferedInputStream(fis));
        try{
            while (fis.available()==0){
                Person person = (Person) ois.readObject();
                list.add(person);
            }
        }catch (Exception e){
            System.out.println("获取上次记录成功！");
        }
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        try{
            if (fis!=null){
                fis.close();
            }
            if (ois!=null){
                ois.close();
            }
        }catch (Exception E){
            E.printStackTrace();
        }
    }
}

三、问题（程序可以运行成功。实现对象存入文件，并启动程序时读取文件中的对象到list）

遇到的问题：1、代码块二中，while循环里判断条件是（fis.available()==0），我是在网上找的这个判断读取完成的条件。如果条件换成true也可以运行出来，老师可以讲讲区别吗，available方法是什么作用？

2、代码块二中、这里流的关闭顺序不清楚（主要是开启的顺序不知道）

3、老师看看代码有什么需要改进的地方吗？

老师，在启动子线程后再让线程进入阻塞状态，之后终止线程。

那让线程进入阻塞状态只能用System.in.read();吗？

synchronized里面是（Object.class）吗？如果可以，意思是不是就是实例化的是所有对象都有互斥？

if (fis !=null);

 try{ fis.close};

请问为啥是在！=null的情况下关闭流对象啊

老师出现这个编译错误是怎么回事

public class Test1 {
    private int value;
    private static Test1[] cache;

    static{//[-100,100]
        for(int i = -100;i<=100;i++){
            cache[i+100] = Test1.valueOf(i);
        }
    }
public static Test1 valueOf(int i){
        if(i>=-100&&i<=100){
            return cache[i+100];
        }
        return new Test1(i);
}
private Test1(int i){
        this.value = i;
}
public static void main(String[] args) {
        Test1 t1 = Test1.valueOf(1);
    System.out.println(t1);
    }
}

关于看之前的解答

“ 老师，当有1,2两个线程进行操作时，1线程使用yield（）方法进行让位时。下一次不管运行1线程，还是2线程应该都是50%的机会吧。因为当前两个线程都属于就绪状态，cpu调用应该是随机的吧。”

有一个疑问：

当i ==0 时，会把该线程变成准备状态，那么，按照上面的解释，在下一次有50%的概率继续拿到该线程。

假设下一次拿到该线程，那么不还是会出发 i == 0 这个条件，那么不就是又一次触发了yield，然后又回到准备状态了？

那不就是一直没办法进行thread 0 0 的线程？

进一步说：

这里我不是很懂yield（） 在这个for循环是不是一个continue的作用？

如果是的话，那么i =0就没有执行就被略过去了，一直不会出现 thread-0 0

如果不是的话，那么下一次for循环，依然从i = 0 开始，继续yield，继续进入准备状态，那么不就是变成了就在thread-0 0 出死循环了？

package com.yz;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 定义文件拷贝工具类
 */
public class FileCopyTools {
    public static void main(String[] args) {
        //拷贝图片
        FileCopyTools.copyFile("D:/a.jpg","D:/c.jpg");
    }
    public static void copyFile(String src,String des){
        //声明缓冲流
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        //surround  by try catch
        try{
            //实例化缓冲流
            bis = new BufferedInputStream(new FileInputStream(src));
            bos = new BufferedOutputStream(new FileOutputStream(des));
            //读取文件
            int temp ;
            while ((temp=bis.read())!=-1){
                bos.write(temp);
            }
            //清空缓存区，写入到目的文件
            bos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (bis!=null){
                    bis.close();
                }
                if (bos!=null){
                    bos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

问题：老师帮忙看下这个代码有错误或者有什么要改进的地方吗？拷贝图片功能可以实现。

老师，我那个解决了，不用帮我解答了嘻嘻嘻

老师，在第一次运行echoserver 和goodtcp的时候，goodtcp可以正常运行。但是echoserver报错，java.net.BindException: Address already in use: bind

第二次运行goodtcp，goodtcp类报错   java.net.ConnectException: Connection refused: connect

这是什么原因造成的，谢谢。

(-[a-z0-9A-Z]+)

这个正则表达式中的“-，有什么用？

一般的邮箱中不是没有连字符的吗？

关于空间复杂度有一个疑问：

比如一个栈，1进入栈，然后1出栈，然后2和3分别进入栈，然后又出栈。

那么这个的空间复杂度是2还是3呢？

1出栈后，栈空间对1的空间资源会立刻释放吗？在栈的空间复杂度分析中，是否只考虑里面可能存储的最大数，而不是全部数？

老师，我跟着视频敲的代码，一运行就那一行报错，不知道是哪里出来问题，帮忙解答一下