这两个类有没有快捷的记忆方式啊

这里哪错了

那这第二题照理说，C也是对的吧，因为Closeable接口继承自AutoCloseable接口，不会是么

所以这里的二分查找，只查找一次的么？

有一个疑问，为什么第一次添加的时候，f指向的是first，first在执行第128行之后，指向了newNode，那f不也同样指向newNode了么，那怎么会被判断为空呢

public class TestYield implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {

            if ("Thread-0".equals(Thread.currentThread().getName())){
                if (i==0){
                    Thread.yield();
                }
            }  System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }

    public static void main(String[] args) {
        Thread t=new Thread(new TestYield());
        Thread t2=new Thread(new TestThread());
        t.start();
        t2.start();
    }
}

//我的没有让步是因为什么

Test3 {
    main(String[] args) {
        List list = ArrayList<>();
        list.add();
        list.add();
        list.add();
        list.add();

        list.sort((o1,o2) -> o1.compareTo(o2));
    }
    }
}

为什么compareTo报红

BasicSocketClient {
    (String[] args) {
        (Socket socket =Socket(,);
            BufferedWriter bw = BufferedWriter(OutputStreamWriter(socket.getOutputStream()));
            bw.write();
            bw.newLine();
            bw.flush();
        }(Exception e){
            .printStackTrace();
        }
    }
}

老师这样子为什么不可以

为啥我的结果是负的呢？多次执行也都是负的

package com.itbaizhan;

class SetName1 extends Thread{
//    public SetName1(String name) {
//        super(name);
//    }

    @Override
    public void run() {
        System.out.println(this.getName());
    }
}


public class TestSetNameThread {
    public static void main(String[] args) {
        SetName1 setName1 = new SetName1();
        setName1.setName("one1");
        setName1.start();
    }
}

SetName01类直接继承了Thread类

为什么不直接使用Thread类的setName方法啊？

反而要去用构造器构造名字

怎么在一行语句里，捕获多种异常呢

老师，你这个中文版的API有链接吗？

while(true){ String msg=br.readLine(); synchronized("abc"){ //把读取到的数据写入公共数据区 ChatRoomServer.buf="["+this.socket.getInetAddress()+"]:"+msg; //唤醒发送消息的线程对象。 "abc".notifyAll(); } } while(true){ synchronized("abc"){ //把读取到的数据写入公共数据区 ChatRoomServer.buf="["+this.socket.getInetAddress()+"]:"+br.readLine(); //唤醒发送消息的线程对象。 "abc".notifyAll(); } }分析一下在实现一对多交流的过程中为什么前面的代码可以实现功能，而后面那段代码会进入阻塞class ChatSend extends Thread{
    private Socket socket;
    /**创建发送数据线程*/
    /**
     * 向客户端发送消息的线程类
     */
    public ChatSend(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }

    /**
     * 将公共数据区的消息发送给客户端
     */
    public void sendMsg(){
        try(PrintWriter pw=new PrintWriter(socket.getOutputStream());){
                while(true){
                    synchronized ("abc"){
                        "abc".wait();
                        pw.println(ChatRoomServer.buf);
                        pw.flush();
                    }
                }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
/**
 * 接收客户端消息的线程类
 */
class ChatReceive extends Thread{
    private Socket socket;
    public ChatReceive(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
            this.receiveMsg();
    }

    /**
     * 实现接收客户端发送的消息
     */
    public void receiveMsg(){
        try(BufferedReader br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){
            while(true){
                String msg=br.readLine();
                synchronized("abc"){
                    //把读取到的数据写入公共数据区
                ChatRoomServer.buf="["+this.socket.getInetAddress()+"]:"+msg;
                    //唤醒发送消息的线程对象。
                "abc".notifyAll();
            }
            }

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
//定义公共数据区
public class ChatRoomServer {
    public static String buf;
    public static void main(String[] args) {
        System.out.println("Chat Server Version 1.0");
        System.out.println("Listen at 8888 端口。。。");

        try( ServerSocket serverSocket=new ServerSocket(8888)){
            while(true){

                Socket socket=serverSocket.accept();
                System.out.println("连接到： "+socket.getInetAddress());
                new ChatReceive(socket).start();
                new ChatSend(socket).start();

            }

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

老师，为什么我一开始用的后面那段代码运行后是陷入阻塞的，用了课上老师的前面那段代码就好了，我个人感觉br.readLine()放在哪里好像没什么影响，就不是很理解为什么会陷入阻塞

不是，这是干嘛啊

老师，这个temp不是fis.read()当前读到的那个字节的字节的数值吗，为什么能表示长度，不是很理解