1. 问题：我的代码运行后，客户端向服务端发送消息后就会无限的输出”对方说：null，对着代码看过还是没找到原因，麻烦老师帮忙看看。

2. 客户端运行情况：

3. 代码

1. package com.wonderx.TCPDemo4;
   
   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 ChatSocketServer {
       public static void main(String[] args) {
           ServerSocket serverSocket = null;
           try {
               serverSocket = new ServerSocket(8888);
               System.out.println("服务器启动，等待监听端口8888。。。");
               Socket socket = serverSocket.accept();
               System.out.println("连接成功！！！");
               new Send(socket).start();
               new Receive(socket).start();
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               try {
   
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
       }
   }
   
   /*
   发送消息的线程
    */
   class Send extends Thread {
       private Socket socket;
   
       public Send(Socket socket) {
           this.socket = socket;
       }
   
       @Override
       public void run() {
           this.sendMsg();
       }
   
       /*
       发送消息的方法
        */
       private void sendMsg() {
           Scanner scanner = null;
           PrintWriter pw = null;
           try {
               //创建Scanner对象
               scanner = new Scanner(System.in);
               //创建向客户端发送消息的流对象
               pw = new PrintWriter(this.socket.getOutputStream());
               while (true) {
                   String str = scanner.nextLine();
                   pw.println(str);
                   pw.flush();
               }
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               if (scanner != null) {
                   scanner.close();
               }
               if (pw != null) {
                   pw.close();
               }
               if (socket != null) {
                   try {
                       socket.close();
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   
   /*
   接受消息线程
    */
   class Receive extends Thread {
       private Socket socket;
   
       public Receive(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()));
               String str = br.readLine();
               System.out.println("对方说：" + str);
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               try {
                   if (br != null) {
                       br.close();
                   }
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }

2. package com.wonderx.TCPDemo4;
   
   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.InputStreamReader;
   import java.io.PrintWriter;
   import java.net.Socket;
   import java.util.Scanner;
   
   /**
    * 点对点聊天的客户端
    */
   public class ChatSocketClient {
       public static void main(String[] args) {
           Socket socket = null;
           try {
               System.out.println("连接中。。。");
               socket = new Socket("127.0.0.1", 8888);
               System.out.println("连接成功！！！");
               new ClientSend(socket).start();
               new ClientReceive(socket).start();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   
   /*
   发送消息的线程类
    */
   class ClientSend extends Thread {
       private Socket socket;
   
       public ClientSend(Socket socket) {
           this.socket = socket;
       }
   
       @Override
       public void run() {
           this.sendMsg();
       }
   
       /*
       发送消息的方法
        */
       private void sendMsg() {
           Scanner scanner = null;
           PrintWriter pw = null;
           try {
               //创建Scanner对象
               scanner = new Scanner(System.in);
               //创建向客户端发送消息的流对象
               pw = new PrintWriter(this.socket.getOutputStream());
               while (true) {
                   String str = scanner.nextLine();
                   pw.println(str);
                   pw.flush();
               }
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               if (scanner != null) {
                   scanner.close();
               }
               if (pw != null) {
                   pw.close();
               }
               if (socket != null) {
                   try {
                       socket.close();
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   
   /*
   接受消息的线程类
    */
   class ClientReceive extends Thread {
       private Socket socket;
   
       public ClientReceive(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 str = br.readLine();
                   System.out.println("对方说：" + str);
               }
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               if (br != null) {
                   try {
                       br.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }

为什么是encoding=gbk啊

老师，对这个问题我可不可以这样理解：

Tomcat默认的编码方式是ISO-8859-1，现在服务器要给浏览器响应下载这个文件，但是在响应过程中是以字节的方式去传输的，于是对文件名进行字符到字节的转换（转换成GBK），而在需要将其转换成ISO-8859-1是因为浏览器的默认的编码是ISO-8859-1（是要响应给浏览器的），浏览器接收到这个数据包后进行解析，发现编码是IS0-8859-1后，一般浏览器会自己采用自己本机的操作系统的编码方式去转换（一般windows对中文是GBK）所以，此时，在浏览器上就能看到是中文不是乱码。

对以上的问题中还有问题：那既然发现接收到的数据报里面是ISO-8859-1，它会自己根据操作系统的编码进行转换，那为啥之前，我不设置响应编码时（resp.setContentType("text/html;charset=utf-8")），还是会出现乱码？他咋不会根据操作系统的编码进行转化呢？？？

问一下，如果我要添加一列等级，根据BMI>某个值为优秀，然后小于某个值为良好该怎么写?

有没有什么简便的写法？

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class test1 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("d:/a.txt");
            int s1 = fis.read();
            int s2 = fis.read();
            int s3 = fis.read();
            int s4 = fis.read();
            int s5 = fis.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
            System.out.println(s5);

            //流对象使用完，必须关闭，不然，总占用系统资源，最终系统会崩溃。
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

97

98

99

13

10

为啥没有数据时返回的数值不是-1呢，一个13，一个10

老师请问这个地方的DEFINE_string,是TensorFlow里边的方法吗，tf后边的一些列app、flags、DEFINE_string都是TensorFlow里边的方法吗？然后在最后运用DEFINE_string这个函数配置了VGG16这个网络，就相当于把VGG16这个网络给导入了吗？然后在train里边就可以直接调用VGG16网络了吗？

老师，pip install fake-useragent命令是下面这种情况

limit和limit    offset是没有区别的，除了顺序不一样，这样理解对吗

'Java' is not recognized as an internal or external command,

operable program or batch file.

为什么会是这样的提示呢

老师我的Hbuilder打不开了，卸载重新解压也打不开，一直提示这个，怎么办呀

老师，我想问一下如何可以将语句打印在一行里面？

from threading import Thread
from time import sleep,time
import threading
# 线程的实现
# 方法包装

# 创建普通方法
def func1(name):
    print(threading.currentThread())
    print(f"Threading:{name} start")
    sleep(3)
    print(f"Threading:{name} end")

if __name__ == "__main__":

    print(threading.currentThread())
    # 开始时间
    start = time()
    '''
    # 创建线程
    t1 = Thread(target=func1,args=('t1',))
    t2 = Thread(target=func1,args=('t2',))  

    # 开始线程
    t1.start()
    t2.start()
    # 等待t1线程执行完再往下执行
    t1.join()
    # 等待t2线程执行完再往下执行
    t2.join()
    # func1('t1')
    # func1('t2')
    '''
    thread_list = []
    for i in range(100):
        t = Thread(target=func1,args=(f't{i+1}',))
        t.start()
        thread_list.append(t)
    for t in thread_list:
        t.join()
    # 结束时间
    end = time()-start
    print(end)

老师这里第二个for循环遍历列表里的线程，每遍历一个线程都join()，那不就是等这个线程结束才会遍历下一个线程，然后又join()又要等下一个线程结束才能接着遍历后面的，这就串行运行了啊，但是打印显示还是3秒多，麻烦老师解释一下我错在哪了

老师，这是啥意思。

老师你好  请问<>里面的是什么 函数？迭代器?

C:\Users\无言>mysql -h 192.168.66.1 -u root -p

Enter password: *************

ERROR 1130 (HY000): Host '192.168.66.1' is not allowed to connect to this MySQL server

C:\Users\无言>mysql -h 192.168.1.115 -u root -p

Enter password: *************

ERROR 1130 (HY000): Host 'LAPTOP-A3A65IMF' is not allowed to connect to this MySQL server

这个错误是怎么回事