if (address.equalsIgnoreCase(this.list.get(i).getAddress())){
    System.out.println(this.list.get(i));
    flag = false;

老师这个地址不是要区分大小写吗，这个equals方法是不是要用我写的这个？

老师，如果想设置成服务端或客户端输入"退出"时断开连接，应该把判断加在什么地方？

在发送消息线程和接收信息线程添加都尝试过，都会出现报错，提示Socket关闭

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class ProvedChat {
    public static void main(String[] args) {
        ServerSocket serversocket = null;
        Socket socket = null;
        Scanner scanner = null;

        try{
            scanner = new Scanner(System.in);
            System.out.println("请输入：server,<port> 或 ip,<port>");
            String str0 = scanner.nextLine();
            String[] arr = str0.split(",");
            if("server".equals(arr[0])){
                //启动服务端
                serversocket = new ServerSocket(8888);
                System.out.println("服务端启动，等待连接......");
                socket = serversocket.accept();
                System.out.println("连接成功！");
            }else{
                //启动客户端
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功！");
            }
            new ProvedSend(socket,scanner).start();
            new ProvedReceive(socket).start();
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(serversocket!=null){
                    serversocket.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }
}

class ProvedSend extends Thread{
    private Socket socket = null;
    private Scanner scanner;

    public ProvedSend(Socket socket,Scanner scanner) {
        this.socket = socket;
        this.scanner = scanner;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    public void sendMsg(){
        PrintWriter pw = null;
        try{
            //向客户端发送信息的对象
            pw = new PrintWriter(socket.getOutputStream());
            scanner = new Scanner(System.in);
            //开始通信
            while(true){
                //发送信息
                String str0 = scanner.nextLine();
                pw.println(str0);
                pw.flush();
                if("退出".equals(str0)){
                    break;
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(socket!=null){
                    socket.close();
                }
                if(pw!=null){
                    pw.close();
                }
                if(scanner!=null){
                    scanner.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

class ProvedReceive extends Thread{
    private Socket socket = null;

    public ProvedReceive(Socket socket) {
        this.socket = socket;
    }

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

    public void receiveMsg(){
        BufferedReader br = null;

        try{
            //向客户端发送信息的对象
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //开始通信
            while(true){
                //接收信息
                String str0 = br.readLine();
                System.out.println("客户端："+str0);
                if("退出".equals(str0)){
                    break;
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(br!=null){
                    br.close();
                }
                if(socket!=null){
                    socket.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

com.bjsxtsun.awt.windows.ThemeReaderDaemonThreadDemo {

    (String[] args) InterruptedException {

        Thread t = Thread(Daemon())t.setDaemon()t.start()Thread.()System..println()Thread t2 = Thread(UsersThread())t2.start()}
}

Daemon Runnable{

    () {
        (i = i <i++) {
            System..println(Thread.().getName()++i){
                Thread.()} (InterruptedException e) {
                e.printStackTrace()}
        }
        System..println()}
}

UsersThread Runnable{

    () {
        Daemon daemon = Daemon()Thread t1 = Thread(daemon)t1.setDaemon()t1.start()(i = i <i++) {
            System..println(Thread.().getName()++i){
                Thread.()} (InterruptedException e) {
                e.printStackTrace()}
        }

    }
}

测试结果：

Daemon 0
Daemon 1
Daemon 2
Daemon 3
主线程结束
UserThread 0
DaemonUsers 0
UserThread 1
Daemon 4
DaemonUsers 1
UserThread 2
UserThread 3
Daemon 5
UserThread 4
DaemonUsers 2
UserThread 5
Daemon 6
UserThread 6
DaemonUsers 3
UserThread 7
Daemon 7
UserThread 8
DaemonUsers 4
UserThread 9
Daemon 8
DaemonUsers 5

老师 为什么我这里测出来的守护线程的消亡是在用户线程结束后结束的  而不是跟随主线程的结束而结束

为什么下面那个if循环在for循环的外面？

老师，我没用那个 开关boolean 我这样写行不行啊

老师这个return有社么作用？可以不写吗

老师 问一下
fis.read(buff) 这个如果装满了返回数组长度  那1024！=-1是满足的啊，
为什么会停止，还有没装满，读完了是相当于buff这个包没有了，就返回
-1给temp了吗，所有-1！=-1就不满足了

老师，取馒头和放馒头的方法分别放在消费者和生产者类中可以吗？还是必须要放在缓冲区啊

考研考的就是数据结构，倍感亲切啊

老师 为什么在实现runnable接口的类可以直接调用thread中的方法来获取当前类的名称

public E remove(int index) {
    // 对index 进行校验
    this.checkIndex(index);
    // 根据指定位置获取节点对象
    Node<E> node = this.getNode(index);
    // 获取节点对象中的元素
    E item = node.item;
    // 将该对象中单向链表中移除
    // 判断当前节点是否为头节点
    if(this.head == node){
        this.head = node.next;
    }else{
        Node<E> temp = this.head;
        for(int i =0;i<index-1;i++){
            temp = temp.next;
        }
        temp.next = node.next;
    }
    node.next = null;
    
    // 记录元素个数
   this.size--;
    //返回元素
    return item;
}

老师为什么我删除元素 不返回那个元素本身

老师   ArrayList不是要重写接口中的方法嘛      重写接口中的方法之后ArrraList为什么还会拥有接口中的方法啊    

老师，这个案例

的意思是不是方法套方法

为什么这里不能有set

private Account account;老师，这里我不太懂为什么可以直接用Account类型的啊？还有，那个讲super（name）的时候说把name存到super里面是什么意思啊？