老师我不太懂为什么这里的抛出异常不需要那么繁琐的步骤或者为何不添加括号写里面呢?

老师，我想问一下，这个主机和客户端难道不是指的同一台电脑吗，为什么它们的IP不一样：

老师，这个在构造器里重写方法那为什么还有在Student类里面重写equals和hashcode方法，能不重写吗

老师好，有个点想问下：

就是如图，为啥下面不可以直接用上面定义好的mapping去使用呢？

静态的什么时候用，还是分不清

老师，我一个客户端发送消息，其他客户端接收不到

老师，在foreach循环set的时候也会调用hashCode方法吗，我试了一下每次查到一个值的时候都调用了一次hashCode， 这是为什么，foreach是怎么循环set的

我这个format为什么不能使用

package com.itbaizhan.IO;

import java.io.*;

public class TestHeBing {
    public static void main(String[] args) {
        try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\29913\\Desktop\\讲义\\初三\\内能与比热容  知识迁移-题集（学生版）.pdf"));
            BufferedInputStream bis2 = new BufferedInputStream(new FileInputStream("C:\\Users\\29913\\Desktop\\讲义\\初三\\第5讲 内能与比热容-讲义（学生版）.pdf"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\29913\\Desktop\\讲义\\初三\\整合讲义（学生版）.pdf",true))){
            int temp = 0;
            byte[]bytes=new byte[1024];
            while ((temp=bis.read(bytes))!=-1){
                bos.write(bytes);
                bos.flush();
            }
            while ((temp=bis2.read(bytes))!=-1){
                bos.write(bytes);
                bos.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

老师，为什么我这个代码写完了还是会覆盖而不是在后面进行拼接呢？

试了好多次都是重写文件

老师，之前这版块不是到十三章“手写服务器”的吗？为什么没有了的？

老师，请问一下这个画一线是表示什么意思呢

老师这个buf是个什么方法，，，，，，。。。。作用是啥，看他返回的是string类型的，那我可不可以定义个变量去把后面的那些存储呢，不用but这个方法

老师，守护线程的意思是，如果给哪个线程加上了守护线程，该线程终止 守护线程也同样会终止对吧

package thread;

/**
 * 守护线程（辅助线程）
 * 1、给用户线程添加守护线程
 * 2、守护线程的生命周期会随着用户线程的结束而结束
 */
class Daemon implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class DaemonThread {
    public static void main(String[] args) throws Exception {
        Thread thread=new Thread(new Daemon(),"守护线程");
        //将该线程设置为守护线程
        thread.setDaemon(true);
        thread.start();
        Thread.sleep(1000);
        System.out.println("主线程结束");
    }
}

这个我给主线程加入了守护线程，主线程结束，守护线程就不能在运行了，但是我的还是会运行一下才会停止，如果改变一下守护线程的休眠时间就正确了 这是为啥？

class A implements Runnable{
    @Override
    public void run() {
        Thread t = new Thread(new B());
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class B implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class JoinThread {
    public static void main(String[] args) {
        Thread t = new Thread(new A());
        //Thread t1 = new Thread(new B());
        t.start();
        //t1.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 2){
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread-0 0

Thread-1 0

main 0

main 1

Thread-0 1

Thread-1 1

Thread-1 2

Thread-0 2

main 2

Thread-1 3

Thread-0 3

Thread-1 4

Thread-0 4

Thread-0 5

Thread-1 5

Thread-0 6

Thread-1 6

Thread-1 7

Thread-0 7

Thread-0 8

Thread-1 8

Thread-1 9

Thread-0 9

Thread-1 10

Thread-1 11

main 3

Thread-1 12

main 4

main 5

Thread-1 13

main 6

Thread-1 14

Thread-1 15

main 7

Thread-1 16

main 8

Thread-1 17

main 9

Thread-1 18

Thread-1 19

老师，我在线程A里面运行线程B，然后再主线程里面联合线程A，我觉得结果应该是，主线程和A线程交替运行到联合的地方，然后线程A和线程B交替运行，再运行完主线程。可是为什么结果是上面这样子

public int menuItemAvalizble(int min,int max){
    //定义正则表达式
    String regex="[1-9]";
    Scanner sc=new Scanner(System.in);
    while (true){
        System.out.println("请输入您要操作的内容"+min+"-"+max);
    String input=sc.nextLine();
    int value=Integer.parseInt(input);
    if (input.matches(regex)){
        if (value>=min&&value<=max)
            return value;
        else
            System.out.println("您输入的内容错误，请重新输入");
       }else
           System.out.println("您输入的内容不合法，请输入1~6之间的数字");
     }
   }

老师，这个方法规定了第一次输入的字符串类型只能是数字字符串，如果输入字母就会报异常；有啥好的解决方法嘛