老师 ，这个调用pop方法后是只移动了游标，然而数组里的元素没有改变对吧？

public void add(E parent,E item){
    map.put(item,parent);
    List<E> list=this.map2.get(parent);
    if (list==null){
        list=new ArrayList<>();
        this.map2.put(parent,list);
    }
     list.add(item);
}

老师，这里为什么对list操作之后，赋值给list的this.map2value的list也会进行改变？

它们这两个list之间是相连的吗？因为list没有新建，只是拿了另一个list的地址，所以如果进行操作，两个list都会被改变。       

不知道这样理解对不对

如果String输入的是汉字，它的排序规则是什么？

Set<String> set = new HashSet<>();
set.add("c");
set.add(null);
set.add("a");
Iterator<String> it = set.iterator();
if( it.hasNext()){
    String next = it.next();
    System.out.println(next);
}
System.out.println("1 "+it.next());
System.out.println("--------while-------");
Iterator<String> it2 = set.iterator();
while(it2.hasNext()){
    String str = it2.next();
    System.out.print(str+"  ");
}

Set集合允许有null

问题1：获取单个元素时，为什么第一个it.next()输出1 null 第二个反而是2 a，而且如果第一输出的是null那么不就代表it.hasNext()是false么，因为他是null啊

问题2：那么it2.hasNext()就为false，为什么还能循环输出第三个元素？

问题4：如果把null改为b输出的是1 a 和 2 b，把b给为33输出结果是1 33和2 a，这是因为set接口的无序性导致的么？根据哈希值计算存储的原因

结果：

结果：

public class Operate {
    private List<Person> list ;
    public Operate(){
        this.list = new ArrayList<>();
    }

在构造方法里进行实例化有什么作用呢？

这样做的目的是为了什么？

直接在定义list的时候就初始化有什么影响？

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 collection.stu.com;

import java.util.Stack;

/**
 * 测试Stack，判断一个字符串是否对称
 * 假设修正法；
 * */
public class StackTest01 {
    public static void main(String[] args) {
        String str1="(({{[[]]}})){";
        String str2="(({{[[[]]}}))";
        String str3="([{}])";
        StackTest01.getString(str1);
        StackTest01.getString(str2);
        StackTest01.getString(str3);
    }
    public static void getString(String str1){
        boolean flag=true;
        Stack<String> stack=new Stack<>();
        for (int i=0;i<str1.length();i++){
            char c1=str1.charAt(i);
            if (c1=='('){
                stack.push(")");
            }
            if (c1=='{'){
                stack.push("}");
            }
            if (c1=='['){
                stack.push("]");
            }
            if (c1==')'||c1=='}'||c1==']'){
                if (stack.empty()){
                    flag=false;
                   break;
                }
                String str2=stack.pop();
                if (str2.charAt(0)!=c1){
                    flag=false;
                    break;
                }
            }
            if (!stack.empty()){
                flag=false;
                break;
            }
        }
     System.out.println(flag);
    }
}

false

false

false

全是false,最后一个应该是true，老师麻烦看看；

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class n4_OneWaySocketServer {
    public static void main(String[] args) {
        Socket socket =null;
        BufferedReader br = null;
        PrintWriter pw =null;

        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务端启动开始监听");
            socket = serverSocket.accept();

            System.out.println("链接成功...");
            //读取客户端的消息
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            //协会消息流对象
            pw = new PrintWriter(socket.getOutputStream());

            while(true){
               
                String str = br.readLine();
                System.out.println("客户端说：" + str);
                if ("exit".equals(str)){
                    break;
                }
                pw.println(str);
                pw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (pw!=null){
                pw.close();
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

2.br.close  socket.close向这些  什么流啊，socket，scanner对象关闭顺序是什么

key = 45678
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

视频里老师说hashCode()是取第16位，那么h=key.hashCode()不就是h=0110 0111 1000 1001了么

那h>>>16这里的h是0110 0111 1000 1001，取h的高16位是怎么得出0000 0000 0100 0101的？

BufferedReader br = new BufferedReader(new FileReader("D:/a.txt");
br.read()  //这个是不是没有缓存区
br.readLine //这个才有缓存区

final Node<E> f = first;
first = newNode;

被final 修饰的变量不是不可以重新赋值嘛？

有点懵圈了

老师，为啥对象的引用要向上呢，实例化自己不是更加确切嘛

public List<E> getAncestor(E item){
    //获取当前结点的父结点
    E parent = this.getParent(item);
    //给出递归的边界条件
    if (parent == null){
        return new ArrayList<>();
    }
    //递归操作
    List<E> list = this.getAncestor(parent);
    list.add(parent);
    return list;
}

递归调用弹栈的时候不太懂，当item是4的时候返回一个Arraylist，并且add了一个null进去，之后item是3的时候，parent是4，List<E> list = 4???每次递归都返回list，是不是应该所有递归都结束才返回list呢？？？？麻烦老师可以详细的讲一下。

 public List<E> getBrother(E item){
        //获取当前结点的父结点
        E parent = this.getParent(item);
        //获取当前父结点的所有的子结点
        List<E> list = this.getChild(parent);
        List<E> brother = new ArrayList<>();
        if(list != null){
            brother.addAll(list);
            brother.remove(item);
        }
        return brother;
    }

if判断不写也是可以的吧，因为它是至少都有一个子结点肯定不能为空。

private Map<E,E> map1 = new HashMap<>();//存储一对一的
private Map<E,List<E>> map2 = new HashMap<>();//存储一对多的

public void add(E parent,E item){
    //完成单结点之间的映射
    this.map1.put(item,parent);
    //完成多节点之间的映射
    List<E> list = this.map2.get(parent);
    //判断当前结点是否有子结点，如果为空则创建一个新的List
    if (list == null){
        list = new ArrayList<>();
        this.map2.put(parent,list);
    }
    list.add(item);
}

为什么要创建一个新的list，直接用之前的list为什么不行呢？如果为空我就把list.add放里面。然后再put是不是也可以