这个arraylist是不是每次add一个元素，都会吧之前的数据复制到一个新数组里？

服务端：

package com.sxt;

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

public class TwoWaySocketServer {
    public static void main(String[] args) {
        ServerSocket serverSocket =null;
        Socket socket =null;
        BufferedReader br=null;
        Scanner scanner =null;
        PrintWriter pw =null;
        try {
            //服务器需要监听的端口
            serverSocket = new ServerSocket(8888);
            System.out.println("服务端启动，开始监听....");
            //socket包装erverSocket.accept()，大白话说当监听到客户端来消息时返回给socket。并且启动监听accept();
            socket = serverSocket.accept();
            //读取客户端发来的消息
            ////getInputStream()字节流， InputStreamReader转字符流，BufferedReader转字符串
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //创建键盘输入对象
            scanner = new Scanner(System.in);
            //向客户端发送消息
            pw = new PrintWriter(socket.getOutputStream());
            while (true){
                //读取客户端发送的消息
                String str = br.readLine();
                System.out.println("客户端说："+str);
                /*
                if ("esc".equals(str)){
                    break;
                }
                */
                //键盘输入对象，要向客户端发送信息
                String outPrint = scanner.nextLine();
                pw.println(scanner);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (serverSocket!= null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br!= null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (scanner!= null){
                scanner.close();
            }
            if (pw!=null);
            pw.close();
        }
    }
}

客户端：

package com.sxt;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

public class TwoWaySocketClient {
    public static void main(String[] args) {
        Socket socket = null;
        Scanner scanner = null;
        PrintWriter pw = null;
        BufferedReader br = null;
        try {
            socket = new Socket("192.168.31.250",8888);
            //创建键盘输入对象
            scanner = new Scanner(System.in);
            //创建向服务器发送消息的输出流对象
            pw = new PrintWriter(socket.getOutputStream());
            //创建向服务器读取消息的输入流对象
            //socket.getInputStream()拿到的是一个字节流，先转字符在转字符串
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //使用循环处理数据
            while (true){
                //拿到要对服务器发送的消息
                String strOut = scanner.nextLine();
                //向服务器发送消息
                pw.println(strOut);
                pw.flush();
                //读取服务器发来的消息
                String strInput = br.readLine();
                System.out.println("服务端说"+strInput);
            }

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

            if (pw != null){
                pw.close();
            }
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (scanner != null){
                scanner.close();
            }

        }
    }
}

运行结果：

1：老师好。我这个服务端说的话怎么是乱码啊，找不到什么原因。

2：还有个问题就是不知道怎么回事，服务端和客户端启动之后发送消息有时候两边的接收不到信息

请问老师String和StringBuilder分别再哪种场景使用好呢？ 

请问为什么缓存范围是-128-127呢 是否可以更大呢 这个范围是怎么考虑设定的呢

老师 我写完之后进行测试 发现每次发信息只能发一条 这是为什么啊

老师，我安装的Tomcat启动的时候闪退，我看很多同学在问。我用的JDK是jdk-15.0.1，是不是要换成1.8的版本？

老师，我的代码IDEAL控制台输出正常，但是浏览器没有显示 登陆成功 的字样

代码如下：

package com.bjsxt.server;

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

public class httpServer_3 {
    public static void main(String[] args) {
        String CRLF="/r/n";//换行
        String BLANK=" ";//空格
        ServerSocket server=null;
        Socket socket=null;
        BufferedReader br=null;
        InputStream is=null;

        try{
            server=new ServerSocket(8888);
            socket = server.accept();
            //获取来自浏览器的信息
            is=socket.getInputStream();
            byte[] buf=new byte[20480];
            int len=is.read(buf);
            System.out.println(new String(buf,0,len));
            /**对web浏览器的请求作出响应*/
            StringBuilder sb=new StringBuilder();
            StringBuilder sbContent=new StringBuilder();//响应的文本
            sbContent.append("<html><head><title>响应结果</title></head>");
            sbContent.append("<body>登录成功</body></html>");
            sb.append("HTTP/1.1").append(BLANK).append(200).append(BLANK).append("OK");
            sb.append(CRLF);
            sb.append("Content-Type: text/html;charset=utf-8");
            sb.append(CRLF);
            sb.append("Content-Length:").append(sbContent.toString().getBytes().length).append(CRLF);
            sb.append(CRLF);
            sb.append(sbContent);
            //通过流输出
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(),"utf-8"));
            bw.write(sb.toString());
            bw.flush();
            bw.close();

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

    }

}

得到他的前一个节点不能直接使用getNode(index-1)么，一楼应该是这个意思吧？

按照练习敲得出现类型错误如何修改，Usersage是String类型如何用小于号来比较

1. Users代码

public class Users {
    private String username;
    private int userage;

    public Users(String username, int userage) {
        this.username = username;
        this.userage = userage;
    }

    public Users() {
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("equals...");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Users users = (Users) o;
        return userage == users.userage &&
                Objects.equals(username, users.username);
    }

    @Override
    public int hashCode() {
        return Objects.hash(username, userage);
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getUserage() {
        return userage;
    }

    public void setUserage(int userage) {
        this.userage = userage;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", userage=" + userage +
                '}';
    }
}

2.TreeMap代码

public class TreeMapTest {
    public static void main(String[] args) {
        //实例化TreeMap
        Map<Users,String> map = new TreeMap<>();
        Users u1 = new Users("oldlu",18);
        Users u2 = new Users("admin",22);
        map.put(u1,"oldlu");
        map.put(u2,"admin");

        Set<Users> keys = map.keySet();
        for (Users key:keys){
            System.out.println(key+" -------------- "+map.get(key));
        }
    }
}

结果报错

请问，老师上课做的笔记在哪里可以获取（凑够20个字）

这个hashset是链表加数组，对于算法结果相同的会在数组处加入链表，那么是不是这个hashset数组长度永远都是16啊

//对对象进行反序列化
public static void test2(){
    ObjectInputStream ois = null;
    try{
        ois = new ObjectInputStream(new
                FileInputStream("E:/object.txt"));
        Person p =(Person)ois.readObject();
        System.out.println(p);
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(ois != null){
                ois.close();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
java.io.InvalidClassException: cn.bzsxt.bytestream.User; local class incompatible: stream classdesc serialVersionUID = 1732458846381710476, local class serialVersionUID = -6028733942570062611
    at java.base/java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:689)
    at java.base/java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1898)
    at java.base/java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1764)
    at java.base/java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2055)
    at java.base/java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1586)
    at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:423)
    at cn.bzsxt.Test.Test.test2(Test.java:40)
    at cn.bzsxt.Test.Test.main(Test.java:11)

老师查了好久说不是代码问题 测了好几遍都报错

public class Person implements Serializable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

import java.util.Calendar;
import java.util.GregorianCalendar;

public class Testcalendar {
    public static void main(String[] args) {
        GregorianCalendar calendar = new GregorianCalendar(2999, 10, 9, 22, 10, 50);

    }
    public static void printCalendar(Calendar calendar){

        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int date = calendar.get(Calendar.DAY_OF_WEEK);
        String week = "" + ((date == 0) ? "日" : date);
        int hour = calendar.get(Calendar.HOUR);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.printf("%d年%d月%日，星期%s%d：%d：%d\n",year,month,day,week,hour,minute,second);
    }
}

老师，运行结果怎么啥也没有？

老师，关于t.schedule()方法中的第二个参数，它代表延迟多久之后开始运行程序，为什么用new Date(System.currentTimeMills()+1000)这种形式来写呢？貌似我直接用1000也可以顺利运行

package com.bjsxt.timer;

import java.util.Date;
import java.util.Timer;

public class TestTimer {
    public static void main(String[] args) {
        //创建Timer的对象
        Timer t=new Timer();
        //调用schedule()方法去执行任务
        //创建任务类的对象
        Clock task=new Clock();
        t.schedule(task,new Date(System.currentTimeMillis()+1000),1000);
    }
}