ObjectOutputStream  ObjectInputStream是不能同时打开吗

try(
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\素材\\javaTest/c.txt")));
) {
    oos.writeInt(10);
    oos.writeFloat(1.2f);
    oos.flush();
} catch (IOException e) {
    e.printStackTrace();
}
try(
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\素材\\javaTest/c.txt")));
) {
    System.out.println(ois.readInt());
    System.out.println(ois.readFloat());
} catch (IOException e) {
    e.printStackTrace();
}

上面的正常运行

try(
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\素材\\javaTest/c.txt")));
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\素材\\javaTest/c.txt")));
) {
} catch (IOException e) {
    e.printStackTrace();
}

上面的创建了就报错

import java.util.ArrayList;
import java.util.List;

public class TestRemoveAll {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List<String> a = new ArrayList<>();
        a.add("a");
        a.add("b");
        a.add("c");

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

        //容器的差集操作
        boolean flag = b.removeAll(a);
        System.out.println(flag);
        for (String str : a){
            System.out.println(str);
        }
    }
}

反过来为什么不是d呢？

public class MyInteger {
    private int value;
    private static MyInteger[] cache = new MyInteger[256];

    public static final int LOW = -128;
    public static final int HIGH = 127;


    static {
        //[-128,127]
        for(int i=MyInteger.LOW;i<=HIGH;i++){
            //-128,0;-127,1;-126,2;
            cache[i+128] = new MyInteger(i);
        }
    }

    public static MyInteger valueOf(int i) {
        if(i>=LOW&&i<=HIGH) {
            return cache[i+128];
        }
        return new MyInteger(i);
    }

    @Override
    public String toString() {
        return this.value+"";
    }

    private MyInteger(int i) {
        this.value = i;
    }

    public static void main(String[] args) {
        MyInteger m = MyInteger.valueOf(30);
        System.out.println(m);

    }
}

主方法直接调用的valueof方法，之后返回一个cache[i+128]对应的值，但是这个cache数组也没有赋值，他的值是哪来的？static方法是怎么执行到的？主方法里也没有调用，整个程序执行流程是什么顺序？麻烦老师了

老师，这红色方框是运行主线程，而蓝色方框试运行两个子线程，是这样吗？

还有为什么我蓝色方框里的结果没有交错输出？

老师，请问用String的变量作为锁对象就不能实现线程同步了吗？

package com.itbaizhan;

public class TestSynchronized {
    public static void main(String[] args) {
        Programmer p = new Programmer("张三");
        Programmer p1 = new Programmer("李四");
        new Wcc(p).start();
        new Wcc(p1).start();


    }

}
class Programmer extends Thread{
    private String name;

    public Programmer(String name) {
        this.name = name;
    }


    public void wc() {
        synchronized (this.name) {
            try {
                System.out.println(this.name + "打开卫生间大门");
                Thread.sleep(500);
                System.out.println(this.name + "开始排泄");
                Thread.sleep(500);
                System.out.println(this.name + "冲水");
                Thread.sleep(500);
                System.out.println(this.name + "离开卫生间");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Wcc extends Thread{
    private Programmer p;
    public Wcc(Programmer p){
        this.p = p;
    }

    @Override
    public void run() {
        this.p.wc();
    }
}

public class BasicSocketClient {
    public static void main(String[] args) throws UnknownHostException {
        Socket socket=null;
        PrintWriter pw=null;
        //创建 Socket两个参数  1.服务端的IP地址 2.服务端所监听的端口
        try {
            socket=new Socket("127.0.0.1",8888);
            pw=new PrintWriter(socket.getOutputStream());
            pw.println("服务端 你好");
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (pw!=null){
                    pw.close();
                }
                if (socket!=null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

public class BasicSocketServer {
    public static void main(String[] args) {
        Socket socket=null;
        BufferedReader br=null;
        try {
            ServerSocket serverSocket=new ServerSocket(8888);
            System.out.println("服务器启动监听等待链接。。。。");
            //开启端口的监听
            socket=serverSocket.accept();
            //读取客户端发送的消息
            br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (br!=null){
                    br.close();
                }
                if (socket!=null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

老师为什么我两个代码运行完 客户端没有反应呢 没有输出那行话

老师parallel run应该在哪里？

老师，形参里面可变参数给T...，但是数组里给的a,b,c不都是一个类型吗，我能在数组里给a,1,b这样吗

老师，get请求方式可能含有参数，也就是说请求中第一行可能有参数，如果没有参数，那paraString是空，还是和post方式一样在正文中？

老师，我这里有几个问题，问题一：包装类对象转换为数据类型(红线部分)是可以转换为任意的数值型的数据类型吗

问题2：黑线部分那不是基本数据类型转换为包装类对象吗？

问题3；包装类是基本数据类型，包装类对象，字符串之间的湖湘转换，那么包装类一般是用在哪里

老师，这里为啥要返回一个  return null

老师，可以对重新equals和hashCode这一块儿做个详解吗？或者帮忙找个链接也好，谢谢。重写的时候会勾选好多东西，也不知道都是什么意思。还有什么质数31什么的，不明白是干嘛的

请问老师，key.hashCode()这里的意思就是取哈希值的低16位，那为什么视频里老师在对key.hashCode和h>>>16时做异或运算时，key.hashCode()不是把十六位之前的数字看做0？

老师，这俩段代码可以调换位置嘛，麻烦详细点

 开头声明 l=last 后来 last = newNode 

老师那这里的这个l是判断的哪里为空