老师你好，我这里有一个假排序的问题

HashMap默认给出的数组长度为16，而上课时测试的数字只有10个，我在想既然是假排序，又已知在分配元素的索引位置时，索引数 = hash值%16 ，那么测试数为100个的时候，输出结果应该以16个数为一个循环的输出，可结果却依然是从小到大排列，请问为什么？

我的推理：

1. 我认为输出结果应该以16为一个循环，那我就是默认了在输出时是按着一个一个链表轮流输出

2. 而结果依然是从小到大排列，那是不是因为输出时是先将每一个链表中的第一个元素按顺序输出，输出完一轮后再将每一个链表中的第二个元素进行输出，依次类推

3. 还有一种可能就是默认的数组长度进行了扩宽，100数字对于一百个索引

希望老师能给我解答

下面的head还是原来的头节点吗，但是上面不是已经定义新节点是头节点了吗，为什么还可以这么写(head.prev像是新节点的前驱一样)

import sun.dc.pr.PRError;

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;

/**
 * 发送消息
 */
class Send1 extends Thread{
    private Scanner scanner;
    private Socket socket;
    public Send1(Socket socket,Scanner scanner){
        this.socket=socket;
        this.scanner=scanner;
    }

    @Override
    public void run() {
        this.Send1Msg();
    }
    public void Send1Msg(){
        try (PrintWriter pw=new PrintWriter(socket.getOutputStream());){
            while (true){
                String msg=scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 接收消息的线程
 */
class Receive1 extends Thread{
    private Socket socket;
    public  Receive1(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        this.ReceiveMsg();
    }
    public void ReceiveMsg(){
        try (BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));){
            String msg=br.readLine();
            System.out.println("他说:"+msg);

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class GoodTCP {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket socket=null;
        try {
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入：server,<port> 或者：<ip>,<port>");
            String str=scanner.nextLine();
            String[] arr=str.split(",");
            //启动服务器
            if ("server".equals(arr[0])){
                System.out.println("TCP Server Listen at "+arr[1]+".......");
                serverSocket=new ServerSocket(Integer.parseInt(arr[1]));
                socket=serverSocket.accept();
            }else {//启动客户端
                socket=new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功");
            }
            //启动发送消息的线程
            new Send1(socket,scanner).start();
            //启动接收消息的线程
            new Receive1(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (serverSocket !=null){
                try {
                    serverSocket.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

为什么我的只能一次，而且另外一个也会运行回答null呢。

这个假排序有点晕 我在这留个记号 等以后再回来看看

Abstraclist是抽象类，Arraylist和Arraylist继承了Abstraclist，为什么Arraylist和Arraylist有不是抽抽象类了呢

守护进程是一对一的吗？同一守护进程可以同时守护多个用户进程吗

请问本节课里老师打开的 jdk1.8 中文 有道翻译版 这个从哪里可以获取？

坤哥，PrintWriter 转换编码还是会乱码，是什么问题？
ANSI转gbk  用utf-8也是会乱码的

老师 这个代码为什么会一直运行

public class UDPUserTest02 {
    public static void main(String[] args) {
        long a = 1000l;
        try(DatagramSocket socket = new DatagramSocket(9000);
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            DataOutputStream output = new DataOutputStream(out)){
            output.writeLong(a);
            byte[] arr = out.toByteArray();
            DatagramPacket pocket = new DatagramPacket(arr,arr.length,new InetSocketAddress("127.0.0.1",9999));
            socket.receive(pocket);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

public class UDPServerTest {
    public static void main(String[] args) {
        try(DatagramSocket socket = new DatagramSocket(8888)){
            //接受信息缓冲区
            byte[] b = new byte[1024];
            //创建数据报包对象
            DatagramPacket packet = new DatagramPacket(b,b.length);
            socket.receive(packet);
            String str = new String(packet.getData(),0,packet.getLength());
            System.out.println(str);
        }catch(Exception e){
            e.printStackTrace();
        }

    }
}


public class UDPUserTest {
    public static void main(String[] args) {
        try(DatagramSocket socket = new DatagramSocket(9999)){
            byte[] b = "我们顶峰相见".getBytes();
            DatagramPacket packet = new DatagramPacket(b,b.length,new InetSocketAddress("127.0.0.1",8888));
            socket.send(packet);
        }catch(Exception e){
            e.printStackTrace();
        }

    }
}

老师 我这服务端上接收不到消息，把视频中的代码复制上去也接受不到

为什么 卢老师没有做刷新处理 

public class BasicSocketClient {
    public static void main(String[] args) {
        //创建Socket对象
        try(Socket socket = new Socket("192.168.0.178",8888);
            //创建向服务端发送消息的输出流对象
            PrintWriter pw = new PrintWriter(socket.getOutputStream())
        ){
            pw.println("服务端你好");
            pw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class BasicSocketServer {
    public static void main(String[] args) {
        System.out.println("服务器启动等待监听...");
        //创建ServerSocket服务端
        try(ServerSocket ss = new ServerSocket(8888)){
            //监听8888端口，此时线程会处于阻塞状态
            Socket socket = ss.accept();
            //连接成功后会得到与客户端对应的Socket对象，并解除线程阻塞
            //通过客户端对应的Socket对象中的输入流对象，获取客户端发送过来的的消息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("服务器创建失败...");
        }
    }
}

老师你好，请问这个连接成功了，但是为什么没有打印客户端的那一句“服务端你好”啊？

try/catch语句中，try括号里面的主要是包括哪些内容啊？老师

在5分35到5分45时间段之间。老师说定义数组类型时可以使用泛型，但是创建数组的时候需要指定类型。那么当我们使用这个类创建对象时，给予了指定的泛型类型。那么在类的加载中，按我们给予的指定的类型创建相应的数组为什么会有问题？

如果我在一个java文件中定义了多个类，那么获取到的对象是哪一个呢？还是说只能获取public那一个类？