老师我可以遍历元素，删除所有元素吗

为什么我只有两个元素了

老师，为什么我这里打印了两次itbz

这个值可以我随便定义吗

老师，为什么这个代码里面没有结束循环的语句，这样线程永远死不掉，那么他岂不是会一直运行下去

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中的方法来获取当前类的名称