问题：

请问老师，如下是程序的运行的结果，Thread-0线程已近运行结束了，而主线程还没结束，为什么Thread-0线程还是存活状态，是因为sleep导致的吗？

代码：

package lt1;

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0;i<10;i++){
             System.out.println(Thread.currentThread().getName()+"------"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Test {

    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();      

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(t.getName()+"线程是否存活："+t.isAlive());
        System.out.println(Thread.currentThread().getName()+"线程是否存活："+Thread.currentThread().isAlive());
    }

}

运行结果：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TwoWaySocketSever {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        Scanner scanner = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            serverSocket = new ServerSocket(7777);
            System.out.println("服务端启动!监听端口8888~~~~~");
            socket = serverSocket.accept();
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            scanner = new Scanner(System.in);
            pw = new PrintWriter(socket.getOutputStream());
            while (true) {
                String str = br.readLine();
                System.out.println("客户端说:" + str);

                String keyput = scanner.nextLine();
                pw.println(keyput);
                pw.flush();

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(br !=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(scanner!=null){
                scanner.close();
            }
            if(socket !=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(pw !=null){
                pw.close();
            }


        }
    }
}

    老师这是为什么报错呢

老师,IDEA里怎么点出这个画面呢?快捷键是什么呢?

老师 我换成Mac本之后，这个我创建一个文本之后，这个路径和win上面的不一样，我应该怎么在Mac写文件对应的路径

老师，这是代码

import java.util.Calendar;
import java.util.*;

public class TestCalendar {
    public static void main(String[] args) {

        //得到日期相关元素
        GregorianCalendar calendar = new GregorianCalendar
                (2020, 12, 13, 15, 19, 12);
        int year = calendar.get(Calendar.YEAR);
        int month=calendar.get(Calendar.MONTH);
        int day=calendar.get(Calendar.DAY_OF_MONTH);
        int day2=calendar.get(Calendar.DATE);
        //日，Calendar.DAT_OF_MONTH和Calendar.DATE同义。
        int date=calendar.get(Calendar.DAY_OF_WEEK);
        //星期几，这里是1-7，周日是1，周一是7
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(day2);
        System.out.println(date);

        //设置日期
        GregorianCalendar calendar2=new GregorianCalendar();
        calendar2.set(Calendar.YEAR,1997);
        calendar2.set(Calendar.MONTH,9);     //月份0-11
        calendar2.set(Calendar.DATE,3);
        calendar2.set(Calendar.HOUR_OF_DAY,12);
        calendar2.set(Calendar.MINUTE,13);
        calendar2.set(Calendar.SECOND,14);
        printCalendar(calendar2);

        //日期计算
        GregorianCalendar calendar3=new GregorianCalendar
                (2020,11,13,11,22,33);
        calendar3.add(Calendar.MONTH,-1);
        calendar3.add(Calendar.DATE,+1);
        printCalendar(calendar3);

        //日历对象和时间对象的转化
        Date d=calendar3.getTime();
        GregorianCalendar calendar4=new GregorianCalendar();
        calendar4.setTime(new Date());

        static void printCalendar(Calendar calendar){
            int year2 =calendar.get(Calendar.YEAR);
            int month2=calendar.get(Calendar.MONTH)+1;
            int day3=calendar.get(Calendar.DATE);
            int date2=calendar.get(Calendar.DAY_OF_WEEK)-1;   //星期几
            String week=""+((date==0)?"日":date);

            int hour=calendar.get(Calendar.HOUR);
            int minute=calendar.get(Calendar.MINUTE);
            int second=calendar.get(Calendar.SECOND);
            System.out.println("yyyy年MM月dd日 hh时ff分mm秒");

        }


    }
}

老师，我的代码运行时，只会出现单线程跑，似乎是出现了死锁的情况，检查不出问题，请老师帮我看看

package 线程冲突3;

public class ProduceTestThread {

    public static void main(String[] args) {

    SyncStack ss=new SyncStack();

    new shengChang(ss).start();

    new xiaoFei(ss).start();

    }

}

/**

 * 馒头类

 */

class manTou{

    private int id;

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

}

/**

 * 缓冲区

 */

class SyncStack{

    //定义放馒头的盒子

    manTou []mtArr=new manTou[10];

    //定义取馒头的盒子

    int index;

    /**

     * 放馒头的方法

     */

    public synchronized void fang(manTou mt){

        while(index==mtArr.length){

            try {

                wait();

             /*   notify();*/

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notify();

        mtArr[index]=mt;

        index++;

    }

    /**

     * 取馒头的方法

     */

    public synchronized manTou qu(int index){

        /*System.out.println("测试：进去取");*/

        while(index==0){

            try {

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notify();

        this.index--;

        return mtArr[this.index];

    }

}

/**

 * 生产者线程

 */

class shengChang extends  Thread{

    private SyncStack ss;

    shengChang(SyncStack ss){

        this.ss=ss;

    }

    @Override

    public void run() {

        for(int i=0;i<10;i++){

             manTou mt=new manTou();

            ss.fang(mt);

            ss.mtArr[i].setId(i+1);

            System.out.println("生产馒头："+ss.mtArr[i].getId());

        }

        /*System.out.println("共计生产了馒头"+sum+"个");*/

    }

}

/**

 * 消费者线程

 */

class xiaoFei extends  Thread{

    private  SyncStack ss;

    xiaoFei(SyncStack ss){

        this.ss=ss;

    }

    @Override

    public void run() {

        for(int i=0;i<10;i++){

            ss.qu(i);

            System.out.println("消费馒头:"+ss.mtArr[i].getId());

            /*manTou mt = ss.qu(i);

            System.out.println("消费馒头"+mt.getId());*/

        }

    }

}

我这显示也是无法找到路径，但是我感觉自己没有问题的

服务器端未关闭流，不会浪费资源？

package cn.sxt.chat.server;
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("----------服务器启动了----------");
//(1)创建ServerSocket对象
ServerSocket server = new ServerSocket(9999);
//(2)监听客户是否有客户端连接
Socket socket = server.accept();

//(3)获取输入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
//(4)获取输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
while(true){
String str = dis.readUTF();//获取输入数据
System.out.println("客户端发送了："+str);
dos.writeUTF("服务器端收到了："+str);//反回客户端数据
}
//(5)关闭流
//CloseUtil.closeAll(dos,dis,socket);
}
}

老师，运行结果的最上面一行结果是什么意思？

pw.println(str);
pw.flush();

关于上面两行代码有一个问题：

假设是在服务端中的这两行代码,

在讲解I/O的时候，flush说明的是讲输出的内容从内存写入到磁盘中。

在网络编程应用I/O这部分我就不是很理解，为什么还要有写入磁盘的这一个过程？

客户端和服务端的通信，不就是在内存中进行吗？如果要写入磁盘，又要写在哪里？是类似I/O中所讲的，会在本地磁盘中有一个类似txt文件，来存储写入磁盘的内容吗？谢谢

老师，视频中说这四个都是二叉查找树，但不是要求左子树上所有结点的值均小于它的根节点的值，像图中圈出的这种等于也可以是吗？

                    这里的代码是不是相当与对Programmer这个类进行了实列化 等同于new Programmer，如果是的化这两种实列化的方法他们的使用方法有何区别不同使用时有没有限制。

老师，请问为什么第二个for-each会报错呢？内部类对象不是Object对象吗？

public class listTest2 {
    public static void main(String[] args) {
        Set<String> a = new HashSet<>();
        a.add("aaa");a.add("bbb");a.add("ccc");
        for(Object temp:a){
            System.out.println(temp);
        }

        Map<String,Integer> m = new HashMap<>();
        m.put("C",1);m.put("A",1);m.put("B",1);
        Set<Map.Entry<String,Integer>> b = m.entrySet();
        for(Object temp:b){
            System.out.print(temp.getKey()+"-----"+temp.getValue());
        }
    }
}

为什么这里vlaue的值不能够通过getname获取呢，getname的返回值也是String类型啊

1、对于IO流的问题，IO流有可以分为输入流，输出流；字节流字符流，同时还包含其他例如缓冲流，数据流等等。我想问一下IO流必须是成对出现的吗？或者说他们需要成对出现吗？我指的是同一种IO流的输入和输出。

2、对于IO流可以组合使用吗？只要满足输入流或者输出流的要求

                Socket client=new Socket("localhost", 8888);
		//(2)获取输出流  (对象流)
		ObjectOutputStream oos=new ObjectOutputStream(client.getOutputStream());
		//(3)创建User对象
		          //调用获取用户对象的方法
		User u=getUser();//new User("bjsxt", "bjsxt");
		//(4)User对象发送到服务器
		oos.writeObject(u);
		
		//(5)获取输入流（数据流）
		DataInputStream dis=new DataInputStream(client.getInputStream());

对于上面这代码，输出流使用对象流，输入流使用数据流