源代码：

package com.bjsxt.client;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Server {
	public static void main(String[] args) throws IOException {
		System.out.println("-----------服务器端已启动------------------");
		ServerSocket server = new ServerSocket(9999);
		
		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(stringDate());
			dos.writeUTF(str);	
		}
		
		
		
	}
	
	public static String stringDate() {
		DateFormat date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
		
		Date d = new Date();
		
		String str = date.format(d);
		
		return str;
		
	}
}

问题一：

    在上面的代码中，while（）循环后面 为什么不能在写代码，

问题二：

为什么当我运行完之后，先关闭客户端，服务器端会报错

问题三

下面代码Mythread1里的方法for循环会执行10次，不太明白为什么，请老师指导

代码：

  //自定义Thread类
    class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread..."+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//测试类
public class RunnableTest1 {
    public static void main(String[] args) {
        test2();
    }

    /**
     * 通过Runnable接口实现多线程案例
     */
    public static void test2(){
        Runnable un1 = new MyThread1();
        Thread tr1 = new Thread(un1);
        tr1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("Main..."+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果

如果run()方法没有循环，这个stop方法是不是就没有意义

老师，这个地方为什么只有第一句加载文件的代码放到了try后面的圆括号内，read方法不是也有异常么，为什么不需要放进去

DemoException03 {
    (String[] args) {
        (FileReader fileReader=FileReader()){
            ch1= ()fileReader.read()ch2= ()fileReader.read()System..println(+ch1+ch2)}(Exception e){
            e.printStackTrace()}
    }
}

老师 为什么这里要求服务器和主机所在的包的名字要保持一致啊  我试了试 包的名字不一致则会出现

Exception in thread "main" java.net.SocketException: Connection reset

package com.bjsxt;

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

public class TreeMapTest {
    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("Oldyou",23);
        map.put(u1,"first");
        map.put(u2,"ser");
        map.put(u3,"three");
        Set<Users> keys = map.keySet();
        for (Users u:keys){
            System.out.println(u.getUsername()+"\t"+u.getUserage());
        }   
    }
}

返回结果为什么oldyou 不显示呢

老师，我这个没法像视频；里那样使用try catch，这样可以吗？

package com.io;

import java.io.*;

public class TestFileCopy {
    public static void main(String[] args) {
        //数据源是文件，输入流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("/Users/pain_/Desktop/text.txt");
            //目的地
            fos = new FileOutputStream("/Users/pain_/Desktop/target.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        int b =0;//中转站，存储读到的字节
        while(true){
            try {
                if (!((b=fis.read())!=-1)) break;
            } catch (IOException e) {
                e.printStackTrace();
            }
            //写入文件
            try {
                fos.write(b);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //关闭，先进后出
        try {
            if(fos!=null){
            fos.close();
            fis.close();}
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

老师，这一步我能不能理解为输入流和输出流创建对象？

如上图：while循环里面是一直在创建线程吧，那为什么老师说每有一个客户端就创建一个线程

图2:

package chatGroup;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.List;

/**
 * 服务器路径线程
 */
public class MyChannel implements Runnable{
    private DataInputStream dis;
    private DataOutputStream dos;
    private boolean flag=true;

    public MyChannel(Socket socket) {
        try {
            dis=new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dis);
        }
        try {
            dos=new DataOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dos);
        }
    }

    @Override
    public void run() {
        while (flag){
            //this.send(gain());
            sendOther();
        }
    }
    public String gain(){
        String str="";
        try {
            str=dis.readUTF();
        } catch (IOException e) {
            flag=false;
            CloseUtil.close(dis);
            MyServer.list.remove(this);
        }
        return str;
    }
    public void send(String str){
        if (str!=null&&str.length()!=0){
            try {
                dos.writeUTF(str);
                dos.flush();
            } catch (IOException e) {
                flag=false;
                CloseUtil.close(dos);
                MyServer.list.remove(this);
            }
        }
    }
    public void sendOther(){
        String str=this.gain();
        List<MyChannel> list=MyServer.list;
        for (MyChannel other:list){
            if (other==this){
                continue;
            }
            other.send(str);
        }
    }
}

图2中：Myserver.list.remove(this),将元素从容器中移除，这里的元素就是客户端，如果客户端发送的流出了异常，接收流没有出异常，就删除该客户端吗，就是说接收和发送只要一个有异常就移除这个客户端吗？

服务器与客户端基于TCP协议通信，服务器需要先建立ServerSocket对象，客户端则需要建立Socket对象，然后在服务器端根据端口监听客户端，当监听到时，返回socket对象（这里有疑问，此时的socket对象是服务端中的socket对象，通过输入流获取客户端输出的对象，是不是可以理解为服务端与客户端通过一条流相连，那这里

Socket client=server.accept();

服务器端创建的的client对象是和客户端中的对象只有连接关系，没有其他关系呢）

为什么this.index--一定要放在上面，放在下面或写成return 

this.mt[this.index--];就会空指针报错？

this.mt[this.index]

老师什么我最后那个s4输出的是13

package com.bjsxt;

import java.io.FileInputStream;

public class FirstDemo {
    public static void main(String[] args) {
        //创建字节输入流对象
        FileInputStream fis=null;
        try{
            fis=new FileInputStream("d:/a.txt");
            int s1=fis.read();//打印输入字符a对应的ascii码值97
            int s2=fis.read();//打印输入字符b对应的ascii码值98
            int s3=fis.read();//打印输入字符c对应的ascii码值99
            int s4=fis.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(fis!=null)
            {
                try{
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

对性别验证的正则表达式可以这样写吗？

//定义性别验证的正则表达式

String regex="[男|女]{1}";

在输入1到6后，执行完成后，为什么又可以回到主菜单？

在switch case完成后，用的是break，因此每次执行完一次，应该会跳出while（true）循环，

为什么在视频演示代码中，执行完成后，会继续回到主菜单？

出现无法解析book.xsd的问题,检查过代码了