源代码：

package com.bjsxt.TcpIp;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetDemo02 {
    public static void main(String[] args) throws UnknownHostException {

        InetAddress inetAddress1 = InetAddress.getByName("www.baidu.com");

        byte[] bytes1 = inetAddress1.getAddress();
        System.out.print("inetAddress1.getAddress(): ");
        for (byte b : bytes1) {
            System.out.print(b + ",");
        }
        System.out.println();
        System.out.println("inetAddress1.getHostAddress(): " + inetAddress1.getHostAddress());
        System.out.println("inetAddress1.getHostName(): " + inetAddress1.getHostName());
        System.out.println("=====================================");
        InetAddress inetAddress2 = InetAddress.getByAddress(bytes1);
        System.out.println("inetAddress2.getHostAddress(): " + inetAddress2.getHostAddress());
        System.out.println("inetAddress2.getHostName(): " + inetAddress2.getHostName());
        System.out.println("=====================================");
    }
}

运行结果：

inetAddress1.getAddress(): -73,-24,-25,-82,
inetAddress1.getHostAddress(): 183.232.231.174
inetAddress1.getHostName(): www.baidu.com
=====================================
inetAddress2.getHostAddress(): 183.232.231.174
inetAddress2.getHostName(): 183.232.231.174
=====================================

疑问：

老师，如果客户端发送exit给服务端时，为了实现无异常退出，我在客户端的发送消息线程和服务端的接收消息线程，分别添加了一下代码：

if("exit".equals(msg)) {
    System.exit(0);
}

好像能实现无异常退出，不报socket closed异常，就是不知道这样有没有上面缺陷？或者有更好的思路？

2个问题：

1. 服务端和客户端都有2个线程类，发送信息和接收消息。为什么发送消息的类里面，发送消息的方法最后要关闭socket；而接收消息的线程类里面，接收消息的方法不用关闭socket?

2. 主线程不用关闭socket吗？

这个是什么意思，已经定义是什么意思，要怎么改呢？

老师，receive的作用是等待客户端发送消息是吗？

String str=new String(dp.getData(),0,dp.getLength());是有什么作用？

dp.getData(),0,dp.getLength()分别代表了什么意思？

研究了下发现也可以采用方法引用方式实现排序：

List<String> list = new ArrayList<>();
list.add("a");
list.add("d");
list.add("c");
list.add("b");

list.sort(String::compareTo);
list.forEach(System.out::println);

但有个问题：compareTo方法并不是静态方法，这里的归属者为什么采用的是类名String？

public int compareTo(String anotherString) {
    byte v1[] = value;
    byte v2[] = anotherString.value;
    byte coder = coder();
    if (coder == anotherString.coder()) {
        return coder == LATIN1 ? StringLatin1.compareTo(v1, v2)
                               : StringUTF16.compareTo(v1, v2);
    }
    return coder == LATIN1 ? StringLatin1.compareToUTF16(v1, v2)
                           : StringUTF16.compareToLatin1(v1, v2);
 }

老师你好

视频中说通配符的上限限定也适用于泛型。这个泛型是指所有用 <>  符修饰的都可以以相同方法限定上限吗？

这是咋回事，我是按照教程来的啊。是符号的问题，还是什么

源代码如下：

package com.bjsxt.Thread;

/**
 * 守护线程类
 */
class  Daemon  implements   Runnable{
    @Override
    public  void  run()  {
        for(int  i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+", i="+i);
            try  {
            //    Thread.sleep(2000);
                Thread.sleep(200);
            }  catch  (InterruptedException  e)  {
                e.printStackTrace();
            }
        }
    }
}
class  UsersThread  implements  Runnable{
    @Override
    public  void  run()  {
        Thread  t  =  new  Thread(new  Daemon(),"Daemon");
        //将该线程设置为守护线程
        t.setDaemon(true);
        t.start();
        for(int  i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+", i="+i+", t.isAlive(): " + t.isAlive()+ ", t.getState: "+t.getState());
            try  {
                Thread.sleep(1000);
            }  catch  (InterruptedException  e)  {
                e.printStackTrace();
            }
        }
    }
}
public  class  DaemonThreadDemo  {
    public  static  void  main(String[]  args)throws  Exception  {
        Thread  t  =  new  Thread(new  UsersThread(),"UsersThread");
        t.start();
        Thread.sleep(1000);
        System.out.println(" 主线程结束 ");
    }
}

运行结果如下：

Daemon, i=0
UsersThread, i=0, t.isAlive(): true, t.getState: RUNNABLE
Daemon, i=1
Daemon, i=2
Daemon, i=3
Daemon, i=4
 主线程结束 
UsersThread, i=1, t.isAlive(): true, t.getState: TIMED_WAITING
Daemon, i=5
Daemon, i=6
Daemon, i=7
Daemon, i=8
Daemon, i=9
UsersThread, i=2, t.isAlive(): true, t.getState: TIMED_WAITING
UsersThread, i=3, t.isAlive(): false, t.getState: TERMINATED
UsersThread, i=4, t.isAlive(): false, t.getState: TERMINATED

Process finished with exit code 0

疑问：

按照代码， Daemon线程 应该是 UsersThread线程 的守护线程。最后两行的打印结果显示，UsersThread线程  还在运行时，  Daemon线程  已经结束了。

不应该是用户线程执行完，守护线程才随之死亡了，上述代码好像是守护线程先死亡，用户线程再死亡呢？

这种方式也可以对list实现排序，这要怎们理解呢

remove之后为什么遍历还是会得到被移除的元素

老师，IDE中，什么快捷键是可以修改一个变量，然后下面所有同名变量都会跟着变得？

还有，调用一个方法是，什么快捷键是直接给方法添加一个返回值？List.get()--------->node = List().get()?

老师，为什么在放馒头的同步方法里，用notify()唤醒的是取馒头的线程呢？

老师，视频里面说，放馒头时，满了会等待；取馒头时，没有馒头会等待。这2个条件好像永远不能同时满足吧？缓冲区只有一个，要不就是满了，要不就没有满。怎么会对生产者来说是满了，对消费者来说是空了呢？很迷糊