老师，这里Class<?>中的？什么意思

package com.bjsxt.task;

/** 
 * <p>Title: Node</p>  
 * <p>Description: 自定义节点</p>  
 * @author xiaoding
 * @date Jun 2, 2020  
 * @version 1.0 
 */
public class Node<K,V> {
    K key;        //键
    V value;    //值
    int hash;    //hashCode值
    
    Node<K,V> next;    //节点
    
    //无参构造方法
    public Node() {}
    //有参构造方法
    public Node(K key,V value,int hash,Node<K,V> next) {
        this.key = key;
        this.value = value;
        this.hash = hash;
        this.next = next;
    }
    
    public K getKey() {
        return key;
    }
    public V getValue() {
        return value;
    }
    @Override
    public String toString() {
        return key + "=" + value + "," + next;
    }
    
    
}

package com.bjsxt.task;

import java.util.Arrays;
import java.util.HashMap;

/** 
 * <p>Title: MyHashMap</p>  
 * <p>Description: 自定义HashMap类</p>  
 * @author xiaoding
 * @date Jun 2, 2020  
 * @version 1.0 
 */
public class MyHashMap<K,V> {
    //功能属性
    private Node<K,V>[] table;    //存储数组
    private int size;    //存放节点的个数
    
    //无参构造方法
    public MyHashMap() {
        //默认数组长度
        this.table = new Node[10];
    }
    //有参构造方法
    public MyHashMap(int length) {
        //手动给数组定义长度
        this.table = new Node[length];
    }
    
    //根据键获取值的方法
//    public V get(Object key) {
//        
//    }
    
    //添加方法
    public void put(K key,V value) {
        //计算Hash值
        int num = key.hashCode();
        //创建一个节点对象并赋值
        Node<K, V> newNode = new Node<K,V>(key,value,putV(num),null);
        if (table[newNode.hash] == null) {
            table[newNode.hash] = newNode;
            size++;
        }else if (table[newNode.hash] != null) {
            //创建一个节点指向当前元素
            Node<K, V> i = newNode;
            for (int j = 0;j<size;j++) {
                if (j == i.hash) {
                    boolean flag = table[j].key.equals(i.key);
                    if (flag) {
                        table[j].key = i.key;
                        break;
                    }else {
                        table[j].next = i;
                        break;
                    }
                }
            }
        }
    }
    
    //计算存储位置的方法
    public int putV(int num) {
        return num % 11;
    }
    
    //重写一下HashCode方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + size;
        result = prime * result + Arrays.hashCode(table);
        return result;
    }
    
    //重写一下比较方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MyHashMap other = (MyHashMap) obj;
        if (size != other.size)
            return false;
        if (!Arrays.equals(table, other.table))
            return false;
        return true;
    }
    
    
    @Override
    public String toString() {
        return "" + Arrays.toString(table);
    }
    public static void main(String[] args) {
        MyHashMap<String,Integer> i = new MyHashMap<String, Integer>();
        i.put("java", 123);
        i.put("good", 256);
        i.put("sxt", 2525);
        System.out.println(i);
    }
}

老师我这个相同位置。元素节点好像没有添加进去，还有那个get方法怎么写，我实在是想不出来

运行结果图：

老师好，不知道为什么我的聊天室客户端和服务端只能收到一半的回复，多线程一般要怎么调试。

package com.casco.server;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class TestServer {
 public static void main(String[] args) throws IOException {
  System.out.println("-----服务器端已启动-----");
  ServerSocket serverSocket = new ServerSocket(9999);
  Socket socket = serverSocket.accept();
  DataInputStream dis = new DataInputStream(socket.getInputStream());
  DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
  while(true){
   System.out.println("客户端发送的数据为：" + dis.readUTF());
   dos.writeUTF("服务器端收到了" + dis.readUTF());
  }
  //CloseUtil.closeAll(dos,dis,socket);
 }
}

package com.casco.client;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
public class TestClient {
 public static void main(String[] args) throws IOException {
  Socket socket = new Socket("localhost",9999);
  SendThread sendThread = new SendThread(socket);
  ReceiveThread receiveThread = new ReceiveThread(socket);
  new Thread(sendThread).start();
  new Thread(receiveThread).start();
 }
}

package com.casco.client;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Scanner;
public class SendThread implements Runnable {
 private BufferedReader br;
 private DataOutputStream dos;
 private boolean flag = true;
 public SendThread(Socket socket) {
  br = new BufferedReader(new InputStreamReader(System.in));
  try {
   dos = new DataOutputStream(socket.getOutputStream());
  } catch (IOException e) {
   flag = false;
   CloseUtil.closeAll(dos);
  }
 }
 public String getMessage() {
  String str = "";
  try {
   str = br.readLine();
  } catch (IOException e) {
   flag = false;
   CloseUtil.closeAll(br);
  }
  return str;
 }
 public void send(String str) {
  try {
   dos.writeUTF(str);
   dos.flush();
  } catch (IOException e) {
   flag = false;
   CloseUtil.closeAll(dos);
  }
 }
 @Override
 public void run() {
  while(true){
   send(getMessage());
  }
 }
}

package com.casco.client;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
public class ReceiveThread implements Runnable {
 private DataInputStream dis;
 private boolean flag = true;

 public ReceiveThread(Socket socket) {
  try {
   dis = new DataInputStream(socket.getInputStream());
  } catch (IOException e) {
   flag = false;
   CloseUtil.closeAll(dis);
  }
 }
 public String getMessage() {
  String str = "";
  try {
   str = dis.readUTF();
  } catch (IOException e) {
   flag = false;
   CloseUtil.closeAll(dis);
  }
  return str;
 }
 @Override
 public void run() {
  while(true){
   System.out.println(this.getMessage());
  }
 }
}

老师好，下面代码中第27行，第行，不太理解这个地方for循环的用法，麻烦老师解释一下

package com.ljk.fs;


import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        String path="com.ljk.fs.User";
        //（1）获取类的名称
        Class c=Class.forName(path);
        System.out.println("类的全名称:"+c.getName());
        System.out.println("类的名称:"+c.getSimpleName());

        //获取父类的Class对象
        Class cSuper=c.getSuperclass();
        System.out.println(cSuper.getName());
        System.out.println(cSuper.getSimpleName());

        //(2)获取类的属性信息
        //Field f=c.getField("userId"); //只能获取公共的属性
        //System.out.println(f);
        Field[] fields=c.getFields(); //只能获取公共的属性
        System.out.println(fields.length);

        Field [] fields2=c.getDeclaredFields();
        //System.out.println(fields2.length);
        for (Field field : fields2) {
            //System.out.println(field);//调用了toString()方法
            System.out.println(field.getModifiers()+"\t"+field.getType()+"\t"+field.getName());
        }

        //(3)获取类的方法信息
        Method[] methods=c.getDeclaredMethods(); //本类中的公共的方法对象
        System.out.println(methods.length);

        for (Method method : methods) {
            //System.out.println(method);
            System.out.println("访问权限" + method.getModifiers());
            System.out.println("返回值类型:" + method.getReturnType());
            System.out.println("方法的名称:" + method.getName());
        }


    }
}

老师，这里的输入流和服务器不要关闭吗，怎么只把输出流和客户端关闭了

老师，反射invoke（）方法是做什么的。。。。执行方法？

老师好，为什么我的static变量序列化成功了。

老师您好：

视频里老师的代码自己理解了，然后自己背着写的代码，也能正常执行，因为背着写多少和视频老师的有点不一样，我传一个serversocket对象，然后在线程中socket s=serversocket.accept();是不是也可以。。。因为刚写代码很多东西不太自信，麻烦老师了。

老师您好，为什么要加这句话？是在网络通信必须加这句话么？

老师这里的flash()可以写循环外面么？我感觉写外面，一次flash()是不是也可以呀。

老师好，对于缓冲流提高读写效率这块我有个疑问，如果提高读写效率只是因为缓冲流有8192大小的数组，那么理论上只要我的中转站数组大小byte[] buf足够大的话效率应该和缓冲流是一样的，那么缓冲流就没有存在的必要了吧。

老师好，请问字节输出流为什么不存在刷新问题，字节输出流不也有缓冲区吗

老师好，我不太懂为什么需要转换流，键盘是标准的输入流InputSream，我们接收处理的时候为什么要转成字符流，为什么不直接处理这个字节流。

老师

（1）这里的value有什么作用吗？和

这里的value有啥区别，为啥一个在双引号上写英文，后面写汉字，一个却在里面写汉字？

（2）为啥又不要id了？

（3）name和id的值是不是前面汉字的英文

老师好，为什么我这里的结果和老师的视频结果不太一样，我这里是一维数组，视频里死二维数组。