老师，min，max是什么意思？为什么校验类的方法都要有返回值？

老师，在构造方法里实例化容器，是跟 List<Person> list=new ArryList<>();实例化是一样的吗？

为什么要在构造方法里实例化容器？

List<Person> list; 泛型的类型为什么是Person?

这里可以直接 node = null; 吗？

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 接收客户端发送消息的线程类
 */

class ChatReceive extends Thread{
    private Socket socket;
    public ChatReceive(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }

    /**
     * 实现接收客户端发送的消息
     */
    private void receiveMsg(){
        BufferedReader br=null;
        try {
            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();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (this.socket!=null){
                    try {
                        this.socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
/**
 *向客户端发送消息的线程类
 */

class ChatSend extends Thread {
    private  Socket socket;

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

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

    /**
     * 将公共数据区的消息发送给客户端
     */
    private void sendMsg() {
        PrintWriter pw = null;
        try {
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true) {
                synchronized ("abc") {
                    //让发送消息的线程处于等待状态
                    "abc".wait();
                    //将公共数据区中的消息发送给客户端
                    pw.println(ChatRoomServer.buf);
                    pw.flush();


                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (pw != null) {
                pw.close();
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException 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.....");
        ServerSocket serverSocket=null;
        try {
            serverSocket=new ServerSocket(8888);
            while (true){
                Socket socket=serverSocket.accept();
                System.out.println("连接到"+socket.getInetAddress());
                new ClientReceive(socket).start();
                new ClientSend(socket).start();


            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

我按老师的代码一模一样敲的，为什么运行的时候和老师的不一样；我感觉向客户端发送消息的线程没有执行。这是怎么回事呢

老师，能够看懂计算过程，明白每一步执行调用。但是不知道为什么要这样做，为什么要^,&这些，怎么办？？？

老师，实际工作中也是这样先写出框架再写出具体业务逻辑吗？

老师，这个class对象是对一个new出来的实例负责的是吗，就是我想又new一个同样类的对象，那是不是又有一个class对象

老师好，关于单链表做算法题时候遇到如下代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy= new ListNode(-1);
        ListNode curr= dummy;
        
        while(l1 !=null || l2 !=null){
            int x = (l1 == null)? Integer.MAX_VALUE: l1.val;
            int y = (l2 == null)? Integer.MAX_VALUE: l2.val;     
            if(x<y){
                curr.next=new ListNode(x);
                l1=l1.next;
            }else{
                curr.next=new ListNode(y);
                l2=l2.next;
            }
            curr=curr.next;    
        }
        return dummy.next;
    }
}

我的问题在20行和23行的

curr.next

因为这两部是将dummy链表往后推进，因为curr指向dummy，所以curr.next实际就是指向dummy链表的下一个节点。

但是这里我不懂，为什么不能用

dummy.next=...

这不是同样也表示dummy的下一个节点指向一个新的listnode？

因为我试了下，这样做会报错。谢谢

package com.bjsxt;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ObjectStreamObjectTypeDemo {


    public void ObjectOutputStreamObjectTypeDem(List<Person> list) {
        ObjectOutputStream oos = null;
        List<Person> list1 = new ArrayList<>();
        try {
            oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("J:\\课堂练习\\课程目录\\01.02JAVA入门与深化提高\\智能电话本项目实战\\电话簿.txt")));
            for (int i = 0; i < list.size(); i++) {
                list1.add(list.get(i));
            }
            oos.writeObject(list1);
            oos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public List<Person> ObjectInputStreamObjectTypeDemo(List<Person> list) {
        ObjectInputStream ois = null;
        List<Person> ls = null;
        try {
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("J:\\课堂练习\\课程目录\\01.02JAVA入门与深化提高\\智能电话本项目实战\\电话簿.txt")));
            ls = (List<Person>) ois.readObject();
            for(int i = 0;i<ls.size();i++){
                list.add(ls.get(i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return list;
    }
}

老师的课堂作业，我写了一个类，然后在Operate 类中加了两个方法，一个是在退出时调用类下的方法 将list 遍历到自定义的数组然后将数组序列化到本地文件，

public void exit(){
    ObjectStreamObjectTypeDemo os = new ObjectStreamObjectTypeDemo();
    os.ObjectOutputStreamObjectTypeDem(this.list);
    System.exit(0);;
}

一个是初始化，运行项目时就调用类下的方法将文件的内容读到自定义数组 然后遍历给list，

/**
 * 传入电话薄
 */
public void Initialize(){
    ObjectStreamObjectTypeDemo os = new ObjectStreamObjectTypeDemo();
    os.ObjectInputStreamObjectTypeDemo(this.list);
}

不知道对不对，功能可以实现。就是我给的都是绝度路径，不知道怎么设定为相对路径，不知道制作成Jar包，能不能用

第二个问题

也有可能是我自己的问题，但视频里确实是这么说的，每次循环都减一

这里为什么oldValue == null  

oldValue明显不为null吧，那么value应该没有办法将值传递给e.value吧

这里会不会有问题呢？

 public int compareTo(Users o) {
        if(this.userage < o.getUserage()){
            return 1;
        }
        if(this.userage == o.getUserage()){
           return this.username.compareTo(o.getUsername());
        }
        return -1;
    }

Set<Student> set2 = new TreeSet<>(new StudentComparator());
        Student s = new Student("oldlu",7);
        Student s1 = new Student("admin",8);
        Student s2 = new Student("sxt",6);
        set2.add(s);
        set2.add(s1);
        set2.add(s2);
        for(Student student:set2){
            System.out.println(student)

是不是在s1进入的时候开始比较？this表示的就是s对象？

当s2进入的时候，它又是怎么比较的呢？s2对象怎么和两个对象进行比较的?

麻烦老师说一下他的比较执行的过程。

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

IP地址如何转换成真正我们需要的实际地址，当通过函数方法getHostAddress()方法时，是否有方法让其返回的是虚假的IP地址