老师，能不能提供一下在IDEA中咋样新建MXL文件，建了几个，感觉都不对，

用idea编写怎么调出2个输出控制台???

com.bjsxtjava.io.BufferedReaderjava.io.IOExceptionjava.io.InputStreamReaderjava.io.PrintWriterjava.net.ServerSocketjava.net.SocketEchoServer15 {

    (String[] args) {
        ServerSocket serverSocket = {
            serverSocket = ServerSocket()(){
                Socket socket = serverSocket.accept()Msg(socket).start()}

        }(Exception e){
            e.printStackTrace()}{
            (serverSocket != ){
                {
                    serverSocket.close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }
}
Msg Thread{
    Socket (Socket socket){
        .= socket}
    () {
        .readMsg()}
    (){
        BufferedReader br = PrintWriter pw = {
            br = BufferedReader(InputStreamReader(..getInputStream()))pw = PrintWriter(..getOutputStream())pw.println(br.readLine()+)pw.flush()} (IOException e) {
            System..println(..getInetAddress()+)e.printStackTrace()}{
            (br != ){
                {
                    br.close()} (IOException e) {
                    e.printStackTrace()}
            }
            (pw != ){
                pw.close()}

        }
    }
}

com.bjsxtjava.io.BufferedReaderjava.io.IOExceptionjava.io.InputStreamReaderjava.io.PrintWriterjava.net.ServerSocketjava.net.Socketjava.util.ScannerGoodTCP14 {
    (String[] args) {
        Scanner scanner = ServerSocket serverSocket = Socket socket = {
            scanner = Scanner(System.)System..println()String str = scanner.nextLine()String[] arr = str.split()(.equals(arr[])){
                System..println(+arr[]+)serverSocket = ServerSocket(Integer.(arr[]))socket = serverSocket.accept()System..println()}{
            socket = Socket(arr[]Integer.(arr[]))System..println()}
            Send1(socketscanner).start()Receive1(socket).start()} (IOException e) {
            e.printStackTrace()}{
            (serverSocket != ){
                {
                    serverSocket.close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }
}
Send1 Thread{

    Socket Scanner (Socket socketScanner scanner){
        .= socket.= scanner}
    () {
        .sendSMag()}
    (){

        PrintWriter pw = {
            pw = PrintWriter(..getOutputStream())(){
                String msg = .nextLine()pw.println(msg)pw.flush()}


        } (IOException e) {
            e.printStackTrace()}{
            (!= ){
                .close()}
            (pw != ){
                pw.close()}
            (.!= ){
                {
                    ..close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }
}

Receive1 Thread{
    Socket (Socket socket){
        .= socket}
    () {
        .receiveMsg()}
    (){
        BufferedReader br = {
            br = BufferedReader(InputStreamReader(..getInputStream()))(){
                String msg = br.readLine()System..println(+msg)}
        } (IOException e) {
            e.printStackTrace()}{
            (br != ){
                {
                    br.close()} (IOException e) {
                    e.printStackTrace()}
            }
            (.!= ){
                {
                    ..close()} (IOException e) {
                    e.printStackTrace()}
            }
        }
    }

}

他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null
他说null

老师 我把自己的代码和老师代码检查了，但是没发现什么问题，但是我这个代码发送了一条消息之后 会一直打印null  麻烦老师帮忙看看

为什么我在使用缓冲区后耗时会出现0啊

老师，为什么在写sleep方法的时候会出现异常并抛出

想问一下addLast()方法和add()方法有啥区别吗？都是从最后添加，为啥要设计两个方法呢？？？

老师，视频里老师讲的时候，if语句是不用加！号的，但是我这个结果不加！就不对了，但是视频里老师的是没问题的，我这里调整了一下必须加！号，才是输出正确的结果，求老师指点为何原因。

Generic<String> generic = new Generic<String>();

老师我发现如果去掉第一个<String>数据类型就会变成object类，那第二个<String>的作用是什么呢

老师您好：请问；

serverSocket.accept();
如何 转换成Socket accept = severSocket.accept();

再导入javax.xml.bind是发生错误 

The import javax.xml.bind cannot be resolved

该怎么解决呢

请问老师，看了视频好久，对于这一阶段的内容，整体的逻辑关系还是没有理顺，老师可以以逻辑构架的方式解说一下吗

老师，请问这个问题如何解决？

这是我的代码

老师我这个解析不了是什么原因

package com.bjsxt.server;

import jdk.swing.interop.SwingInterOpUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import javax.imageio.stream.ImageInputStream;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class WebDom4j {//用于解析XML
    private List<Entity> entityList;//用于存储N多Entity,而每一个Entity都是servlet-name与servlet-class
    private List<Mapping> mappingList;//用于存储N多Mapping，而每一个Mapping都是一个servlet-name与N多个url-pattern

    public List<Entity> getEntityList() {
        return entityList;
    }

    public void setEntityList(List<Entity> entityList) {
        this.entityList = entityList;
    }

    public List<Mapping> getMappingList() {
        return mappingList;
    }

    public void setMappingList(List<Mapping> mappingList) {
        this.mappingList = mappingList;
    }

    public WebDom4j() {
        entityList = new ArrayList<Entity>();
        mappingList= new ArrayList<Mapping>();
    }
    //获取Document对象的方法
    private Document getDocument(){
        try {
            //(创建SAXReader对象)
            SAXReader reader = new SAXReader();
            //调用read方法
            return reader.read(new File("src\\main\\resources\\web.xml"));
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return null;
    }
    public void parse(Document doc){
        //(1)获取根元素
         Element root = doc.getRootElement();//web-app
        //(2)获取servlet子元素
        for(Iterator<Element> ite = root.elementIterator("servlet");ite.hasNext();){
            Element subElement = ite.next();
            //创建一个实体类
            Entity ent = new Entity();//用于存储servelt-name与servlet-class
            for(Iterator<Element> subIte = subElement.elementIterator();subIte.hasNext();){
                Element ele=subIte.next();//可能是servlet-name也可能是servlet-class
                if("servlet-name".equals(ele.getName())){
                    ent.setName(ele.getText()); //给实体类中的name赋值
                }else if("servlet-class".equals(ele.getName())){
                        ent.setClazz(ele.getText());
                }
            }
            //将Entity添加到集合中
            entityList.add(ent);
        }
        //测试
       /** for(Entity entity :entityList){
            System.out.println(entity.getName()+"\t"+entity.getClazz());
        }*/
       //解析servlet-Mapping
        for(Iterator<Element> ite = root.elementIterator("setvlet-mapping");ite.hasNext();){
            Element subEle = ite.next();//得到每一个servlet-mapping
            //创建一个Mapping对象
            Mapping map = new Mapping();
            //解析servlet-mapping下的子元素
            for(Iterator<Element> subIte = subEle.elementIterator();subIte.hasNext();){
                Element ele = subIte.next();
                if("servlet-name".equals(ele.getName())){
                        map.setName(ele.getText());
                }else if("url-pattern".equals(ele.getName())){
                    //获取集合对象，调用结合对象的添加方法，添加元素
                        map.getUrlPattern().add(ele.getText());
                }
            }
            //Mapping添加到集合中
            mappingList.add(map);

        }
        //测试
        for(Mapping m :mappingList){
            System.out.println(m.getName());
            for(String s:m.getUrlPattern()){
                System.out.println(s);
            }
        }
    }

    public static void main(String[] args) {
        WebDom4j web = new WebDom4j();
        web.parse(web.getDocument());
    }
}

public class FileStreamDemo {
    public static void main(String[] args) {
        //创建文件字节输入流对象
        FileInputStream fis=null;
        //创建文件字节输出流对象
        FileOutputStream fos=null;
        File file=new File("d:/aa.jpg");
        try {
            fis=new FileInputStream("d:/a.jpg");
            fos=new FileOutputStream("d:/aa.jpg");
            file.createNewFile();
            int temp=0;
            while((temp=fis.read()) != -1){
                fos.write(temp);
            }
            //将数据从内存中写入到磁盘中
            fos.flush();




        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {

                if(fis !=null){
                    fis.close();
                }
                if(fos!=null){
                    fos.close();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }









    }
}

问题：

 while((temp=fis.read()) != -1)

这个判断条件的理解是：

先执行括号里的temp=fis.read(),

每次fis.read()方法的调用都会返回一个int值给temp，然后就是相当于比如：（temp=97)  != -1，这样的表述

然后完成temp =97这样的赋值操作

最后这个表述是不是就是判断temp != -1呢

不知道我的理解是否正确