老师，为什么静态代码块初始化对象？ 可以改成无参构造函数  去 初始化对象吗？ 

自定义类要想放入hashset()内就必须重写hashcode()方法及equals()方法和底层原理是哈希表有什么关系啊，不懂！！

老师，请问Class对象里有静态属性方法和常量吗？

老师，我的输出结果  为什么没有服务器收到了！

以下是服务器端的代码：

package ClientServer;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    public static void main(String[] args) throws IOException {
        System.out.println("--------服务器已启动--------");
        /**
         * 创建ServerSocket对象
         */
        ServerSocket server = new ServerSocket(8877);
        /**
         * 监听是否有客户端连接
         */
        Socket socket = server.accept();
        /**
         * 获取输入流数据
         */
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        while(true) {
            String str = dis.readUTF();
            System.out.println("客户端发送的数据为："+str);
            /**
             * 获取输出流响应客户端的请求
             */
            dos.writeUTF("服务器端收到了："+str);
        }
        /**
         * 关闭流
         */
        //CloseUtil.closeAll(dos,dis,socket);
    }

}

以下为客户端代码：

package ClientServer;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class ChatClient {
    public static void main(String[] args) throws UnknownHostException, IOException {
        /**
         * 创建Socket对象
         */
        Socket client = new Socket("localhost",8877);
        /**
         * 创建发送的线程类对象
         */
        Send send = new Send(client);
        /**
         * 创建接收的线程类对象
         */
        Receive receive = new Receive(client);
        /**
         * 创建Thread类并启动线程
         */
        new Thread(send).start();
        new Thread(receive).start();
        
    }
}

一：老师，我的作业不会做，有没有像阶段一那样，每个作业都有专门的视频讲解，我可以跟着讲解写代码，百度上面的代码发现抄下来也看不懂，完全小白一枚，请老师多多指教！

这个to.Array();前面的Object[] arr  是用什么快捷键出来的？

package com.sxt;

import java.io.ByteArrayOutputStream;

public class ByteArrayOutputDemo {
    public static void main(String[] args) {
        ByteArrayOutputStream bos = null;
        StringBuilder sb = new StringBuilder();
        try {
            bos = new ByteArrayOutputStream();
            bos.write('a');
            bos.write('b');
            bos.write('c');
            byte arr[] = bos.toByteArray();
            for (int i:arr) {
                sb.append((char) i);
            }
            System.out.println(sb.toString());
        }finally {
            try {
                if (bos != null){
                    bos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

提问下，这里用遍历的形式无所谓吧，我用for-each遍历后所运行的结果和老师运行的一样，这样写是没什么问题的对吧

老师，为什么我利用hashSet容器遍历后没有重复，反而在treeSet容器遍历后会有重复呢？

老师，我用的是idea，用idea如何应该刷新项目呢？

有个想法：

int menuItemValidate(int min, int max){
    Scanner scanner = new Scanner(System.in);
}
String nameValidate(){
    Scanner scanner = new Scanner(System.in);
}

两个方法中都有定义Scanner对象，

那直接定义在方法外边做一个成员变量（static随意吧），会不会好一些

public void showFlag(Generic<Integer>generic)

<Integer>后面的genericyou 什么作用

public class Method {
    public <T> void a(T name){
        System.out.println(name);

}

}

public class Method {
    public <T> void a(){
        T name = null;
        System.out.println(name);

}

}

请问老师着两种写法有什么区别吗？？？

为社么上面的name 不用赋值，下面的要给name 赋值为null；

java.io.FileNotFoundException: F:\IdeaProjects\untitled\li (拒绝访问。)

at java.base/java.io.FileInputStream.open0(Native Method)

at java.base/java.io.FileInputStream.open(FileInputStream.java:196)

at java.base/java.io.FileInputStream.<init>(FileInputStream.java:139)

at java.base/java.io.FileInputStream.<init>(FileInputStream.java:94)

at java.base/java.io.FileReader.<init>(FileReader.java:58)

at sen.Text01.main(Text01.java:10)

为什么是目录没办法访问

package com.itbaizhan;

class manTou{
    private int id;

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

//定义缓冲区 不是线程类
class SyncStack{
    //定义放馒头的容器
    private manTou m[] = new manTou[10];

    //索引
    int i;

    //放馒头
    public synchronized void push(manTou mantou){
        //判断是否满了
        while(i == m.length) {  //用while多判断几次防止当前线程没有执行而忽略
            try {
                this.wait(); //object类的方法，必须在syn调用，线程的对象锁解放，并且进入堵塞状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.notify();  //唤醒等待序列中的一个线程
        this.m[i] = mantou;
        i++;

    }

    //取馒头
    public synchronized manTou pop() {
        //判断是否满了
        while (i == 0) {  //用while多判断几次防止当前线程没有执行而忽略
            try {
                this.wait(); //object类的方法，必须在syn调用，线程的对象锁解放，并且进入堵塞状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.notify();  //唤醒等待序列中的一个线程
        i--;
        return m[i];

    }

}

//定义生产者线程
class shengchan extends Thread{
    private SyncStack s;

    public shengchan(SyncStack s) {
        this.s = s;
    }

    @Override
    public void run() {
        for(int i = 0; i<10; i++){
            System.out.println("生产馒头" + i);
            manTou m = new manTou(); // 每次循环都创建一个新的馒头并放入stack里

            s.push(m);

        }
    }
}

class xiaofei extends Thread{
    private SyncStack s;

    public xiaofei(SyncStack s) {
        this.s = s;
    }

    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println("取馒头" + i);
            manTou m = s.pop();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ProducerThread {
    public static void main(String[] args) {
        //创建缓冲区
        SyncStack s = new SyncStack();

        //创建生产线程
        shengchan produce = new shengchan(s);
        produce.start();

        //创建消费线程
        xiaofei consumer = new xiaofei(s);
        consumer.start();

    }
}

老师，我的有点问题