老师真的太棒了,加油! 努力上进,每天进步一点点

老师为什么我这里还是有两个感叹号，book.xsd也照着敲的

this.getName()和Thread.currentThread().getName()获取的线程名称有什么区别吗？

import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TreeMap;


/*  元素自身实现比较规则  */
public class TestTreeMap {

    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);
        Users u3 = new Users("sxt",22);

        // 添加
        map.put(u1,"oldlu");
        map.put(u2,"admin");
        map.put(u3,"sxt");
        System.out.println(map.get(u3));

        // 遍历
        Set<Users> set = map.keySet();
        for(Users users:set){
            Users key = users;
            String val = map.get(key);
            System.out.println(key+" --- "+val);
        }

    }

}

class Users implements Comparable<Users>{
    private String usersName;
    private int usersAge;

    public Users() {
    }

    public Users(String usersName, int usersAge) {
        this.usersName = usersName;
        this.usersAge = usersAge;
    }

    public String getUsersName() {
        return usersName;
    }

    public void setUsersName(String usersName) {
        this.usersName = usersName;
    }

    public int getUsersAge() {
        return usersAge;
    }

    public void setUsersAge(int usersAge) {
        this.usersAge = usersAge;
    }

    @Override
    public String toString() {
        return "姓名：" + usersName + "    年龄：" + usersAge;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Users users = (Users) o;
        return usersAge == users.usersAge &&
                Objects.equals(usersName, users.usersName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(usersName, usersAge);
    }

    @Override
    public int compareTo(Users o) {
        // 比较年龄 由小到大
        if(this.usersAge < o.getUsersAge()){
            return 1;
        }
        // 如果年龄相等 按名字排序
        if(this.usersAge == o.getUsersAge()){
            this.usersName.compareTo(o.getUsersName());
        }
        return -1;
    }
}

value值为什么是null？

package G_Multithreading.E_Synchronized;

//面包类
class Bread{
    private int id;
    public Bread(int id){
        this.id = id;
    }
}

//缓冲区
class SynBuffer{
    //存放面包的盒子
    private Bread[] breads = new Bread[10];
    //存放面包盒子的索引
    private int index;
    //放面包
    public synchronized void push(Bread bread){
        //判断盒子是否存满
        while (breads.length == this.index + 1){
            try {
                /*
                语法：wait(),该方法必须要在synchronized块中调用。
                     wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
                     其他需要该对象锁的线程就可以继续运行了。
                 */
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /*
            语法：该方法必须要在synchronized块中调用。
                 该方法会唤醒处于相同对象的，并且等待状态队列中的一个线程。
             */
            //提醒取面包
            this.notify();
            breads[this.index] = bread;
            this.index++;
        }
    }
    //取走面包
    public synchronized Bread pop(){
        while (breads.length == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return breads[this.index];
    }
}

//生产面包线程
class Produce extends Thread{
    SynBuffer synBuffer;
    public Produce(SynBuffer synBuffer){
        this.synBuffer = synBuffer;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            Bread bread = new Bread(i);
            this.synBuffer.push(bread);
            System.out.println("生产面包" + i);
        }
    }
}

//消费者线程
class Customer extends Thread{
    SynBuffer synBuffer;
    public Customer(SynBuffer synBuffer){
        this.synBuffer = synBuffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            Bread bread = this.synBuffer.pop();
            System.out.println("取走面包" + i);
        }
    }
}
public class SynchronizedBuffer {
    public static void main(String[] args) {
        SynBuffer synBuffer = new SynBuffer();
        new Produce(synBuffer).start();
        new Customer(synBuffer).start();
    }
}

老师，他到取出的是够就高速index是-1，哪里出错了？

GregorianCalendar calendar4 = new GregorianCalendar();
calendar4.setTime(new Date());
怎么理解这两行

代码能正常运行，就是没有实现数据的发送，老师请帮忙查看下代码哪里有问题？

老师好 在万年历的编程中有一点我弄不明白

DateFormat df = new SimpleDateFormat("yyyy-MM-dd");

Calendar cal = new GregorianCalendar();

创建这两个对象时为什么都用了父类引用指向子类对象的方式?

老师您好，我的客户端发送请求到服务器后，还是出现乱码，请问该如何解决?

package com.zyt.Server;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**	服务器，用于启动和停止服务	*/
public class Server {
	
	private ServerSocket server;
	private Socket client;
	
	public static void main(String[] args) {
		new Server().start(8888);
	}
	
	public void start(int port) {
		InputStream is = null;
		
		try {
			server = new ServerSocket(port);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		try {
			client = server.accept();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		try {
			is = client.getInputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		byte[] buf = new byte[20480];
		try {
			int index = is.read(buf);
			System.out.println(new String(buf, 0, index));
		} catch (IOException e) {
			e.printStackTrace();
		}
	
	}
	
	public void stop() {
		
	}
}

运行图：

老师，为什么这里需要加getAddress而不是直接.getHostAddress。

既然继承Runable可以使用Thread自带的setName()方法，那继承Thread它本身就是Thread为什么不直接调用Thread自带的setName()方法还需要自己构造一个SetName1()方法来改名字呢

老师代码如下：

package com.bjsxt.server;


import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.BufferedReader;
public class Server2 {
    public static void main(String[] args) {
            //(1)创建ServerSocket对象
        ServerSocket server=null;
            //(2)监听是否有客户端发送请求
        Socket client=null;
        BufferedReader br=null;
        try {
            server = new ServerSocket(8888);
            client = server.accept();
            //获取来自浏览器的请求信息
             br=new BufferedReader(new InputStreamReader(client.getInputStream(),"utf-8"));
             String str=null;
             while ((str=br.readLine()).length()>0){
                 System.out.println(str);
             }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //(6)关闭流
            IOClose.closeAll(br,client,server);
        }
    }
}

运行空指针异常报错，第一次都可以正常运行，按照老师视频操作复制粘贴创建server2后再运行就报错了，求指导。

老师好，为什么我这样写线程并没有发生死锁。

package com.casco;

import java.util.TreeMap;

public class DeadLock extends Thread {

    private Object money;
    private Object water;
    public boolean flag;

    public DeadLock(Object money, Object water) {
        this.money = money;
        this.water = water;
    }

    @Override
    public void run() {
        if(flag){
            synchronized (money){
                System.out.println("有钱，买水");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (water){
                System.out.println("有水，等钱");
            }
        } else {
            synchronized (water){
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (money){
                    System.out.println("有钱，买水");
                }
            }

        }
    }
}

package com.casco;

public class Test {
    public static void main(String[] args) {
        Object money = new Object();
        Object water = new Object();
        DeadLock d1 = new DeadLock(money,water);
        DeadLock d2 = new DeadLock(money,water);
        d1.flag = true;
        d2.flag = false;
        d1.start();
        d2.start();
    }
}

public class Main {
    public static void main(String[] args) {
        List list1 = new ArrayList();
        list1.add("123");
        list1.add("456");
        list1.add("789");

        List list2 = new ArrayList();
        list2.add("123");
        list2.add("456");

        System.out.println("list1元素:"+list1);
        System.out.println("list2元素:"+list2);
        System.out.println(list1.containsAll(list2));
        list1.addAll(list2);
        System.out.println("list1元素:"+list1);
    }
}

运行结果：

老师，在list1.containsAll(list2)中返回的结果是true，说明list1中包含了list2中的所有对象，但是在下一行list1添加list2中的所有对象时，list1的元素个数由之前的3个变成了5个，既然包含了，为什么不是同一个对象呢？

老师为什么remove(）方法中使用

node.item = null;

还能正常返回item的值