老师，电话本项目作业，我在operate类的addOpration中添加了ObjectOutputStream，

public void addOperation() {
    TelNoteRegex telNoteRegex=new TelNoteRegex();
    String name=telNoteRegex.nameValidate();
    String age=telNoteRegex.ageValidate();
    String sex=telNoteRegex.sexValidate();
    String telNum=telNoteRegex.telNumValidate();
    String address=telNoteRegex.addressValidate();
    Person person=new Person(name,age,sex,telNum,address);
    this.list.add(person);
    person.setId(this.list.size());
    ObjectOutputStream oos=null;
    try {
        oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/person.txt",true)));
        oos.writeObject(person);
        oos.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if (oos!= null) {
                oos.close();
            }
        }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

然后在Operate类创建了一个ObjectInputStream方法，

/**
 * 对象输入流
 * 初始化list
 */
public void ObjectInputStream(){
    ObjectInputStream ois=null;
    try{
        ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/person.txt")));
        List list=(List<Person>)ois.readObject();
        this.list=list;
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        try{
            if (ois!=null){
                ois.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

再在app类的start方法里调用operate的ObjectInputStream方法，初始化list内的信息，以便下次打开程序时读取之前存储的信息。

public void start(){
    Menu menu=new Menu();
    TelNoteRegex regex=new TelNoteRegex();
    Operate operate=new Operate();
    operate.ObjectInputStream();//初始化Operate中的list
    while (true) {
        menu.mainMenu();
        int item=regex.menuItemValidate(1,6);
        switch (item){
            case 1:operate.addLogic();break;
            case 2:operate.searchLogic();break;
            case 3:operate.modifyLogic();break;
            case 4:operate.deleteLogic();break;
            case 5:operate.orderLogic();break;
            case 6:System.exit(0);  //结束虚拟机

程序运行后有如下报错。

java.io.EOFException
	at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2638)
	at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:3113)
	at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:853)
	at java.io.ObjectInputStream.<init>(ObjectInputStream.java:349)
	at com.wxc.Operate.ObjectInputStream(Operate.java:159)
	at com.wxc.App.start(App.java:28)
	at com.wxc.App.main(App.java:18)

不知道这个思路问题出在哪里。

像这种方法都必须要添加this.吗，this.表示当前调用它的对象，但是我觉得这种不写也是可以的吧，对结果不影响，好像就get set方法，构造函数，构造函数调用其他构造器，这里面才需要this吧

老师，为什么这里声明ArrayList的时候，要用List<>

List<String> list = new ArrayList<>();

好像其他地方也有这样的，用父类来声明，new 子类。

Iterator<String> iterator = list.iterator();
System.out.println("--------------------while-------------------------");
while(iterator.hasNext()){
    //不要在一次循环中多次调用next方法。
    String value = iterator.next();
    if ("狗蛋".equals(value)){
        iterator.remove();
    }
    System.out.println(value);
    //错误示范
    //System.out.println(iterator.next());
}

老师，为什么我的代码输出结果没有被删除呢；但是写一个else放在里面结果就正确了，为什么？？？执行顺序都是一样的呀？

Iterator<String> iterator = list.iterator();
System.out.println("--------------------while-------------------------");
while(iterator.hasNext()){
    //不要在一次循环中多次调用next方法。
    String value = iterator.next();
    if ("狗蛋".equals(value)){
        iterator.remove();
    }
    System.out.println(value);
    //错误示范
    //System.out.println(iterator.next());
}

老师，为什么我的代码输出结果没有被删除呢；但是写一个else放在里面结果就正确了，为什么？？？执行顺序都是一样的呀？

还是3分30秒的讲解，有两个问题：

for(int i = 0; i < list.size() ; i++){

}

（1）

for内部三个条件的执行顺序是如何的？

因为内部一定要遍历index=0位置的元素，因此是否是：先i=0，判断是否<list.size, 先执行循环内部语句，最后执行i++？

因为如果在进入循环语句前就执行了i++，那么遍历就是从index=1 开始的。

（2）

回到讲解本身的问题：

在执行完i=2，删除c后，i=3(如何按照我上面理解的执行顺序的话）

执行下一次循环，size（）会变成3，此时i=list.size(), 那么应该跳出循环，不该执行循环体，这才是d没有被打印出来的原因吧？

为什么按照老师讲的，是仍然进入了循环体，d因为本移动到index=2的位置，被remove掉了才不执行？

关于3分30秒讲解Arraylist不能使用remove删除元素的部分，

如果是数组，而非集合，也存在这个问题吗？

因为集合是大小可变的，remove一个后，后边的元素会往前移，但是数组是大小不可变的。

所以我在想，是否用数组，不存在remove2号位的元素，后边元素要往前移的问题，因此是可以输出d的？

老师，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？

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