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

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呢

不知道我的理解是否正确

老师，我这里的异常报错实在不知道是怎么回事了，先开服务，再开客户，按步骤一步步来的

老师晚上好！我用老师的方法了，代码如下，但是读出来还是乱码，！老师能否帮我分析一下！

package com.bjsxt;

import java.io.*;

public class DataInputStream01 {
    public static void main(String[] args) throws IOException {
     //  write();
       read();
    }
    public static void read() throws IOException {
        //读数据的方法
        //(1)找数据源
        FileInputStream fis = new FileInputStream("D://baizhan//data.txt");
        //(2)提高读取速率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //(3）处理java的基本数据类型和字符串
        DataInputStream dis = new DataInputStream(bis);
     //   DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(new FileInputStream("D:\\baizhan\\data.txt")));
        //(4)读数据--（读数据的顺醋要与写的顺序一致。）
        dis.readInt();
        dis.readDouble();
        dis.readChar();
        dis.readUTF();
        //(5)关闭
        dis.close();
    }
    public static void write() throws IOException{
        //(1)目的地
        FileOutputStream fos = new FileOutputStream("D:\\baizhan\\data.txt");
        //缓冲流提高写入速度
        BufferedOutputStream bos  =new BufferedOutputStream(fos);
        //(3)数据流，增加对java基本数据类型和String的处理
        DataOutputStream  dos  = new DataOutputStream(bos);
        //(4)写入数据
        dos.writeInt(98);
        dos.writeDouble(13.5);
        dos.writeChar('d');
        dos.writeUTF("hello world!");
        //(5)关闭流
        if (dos!=null){
            dos.close();
        }
    }
}

package com.bjsxt;

import java.util.Arrays;
import java.util.EmptyStackException;

/**
 * 自定义：栈类型容器
 */
public class MyStack<E> {

    private Object[] arr;//存放元素的物理结构

    private int stackLength = 4;//数组的默认长度

    private int size;//记录栈容器的元素个数

    private int index = -1;//操作数组下标位置的指针

    /**
     * 判断栈容器是否为空
     * @return
     */
    public boolean empty(){
        return this.size == 0;
    }

    /**
     * 获取栈顶元素
     * @return
     */
    public E pop(){
        //如果栈容器中没有元素则抛出异常
        if(this.index == -1){
            throw new EmptyStackException();
        }

        //记录元素个数
        this.size--;

        //返回栈顶元素
        return (E)this.arr[index--];//返回的是Object类型，报错，强转为(E)泛型类型
    }

    /**
     * 向栈容器中添加元素
     * @param item
     * @return
     */
    public E push(E item){
        //初始化数组
        this.capacity();

        //向数组中添加元素
        this.arr[++index] = item; //前置增减运算符++、--，先加减后运算

        //记录元素个数
        this.size++;

        return item;
    }

    /**
     * 数组初始化、以1.5倍对数组进行扩容
     */
    private void capacity(){
        //数组初始化
        if(this.arr == null){
            this.arr = new Object[this.stackLength];
        }
        //以1.5倍对数组扩容
        if(this.size-(this.stackLength-1)>=0){
            this.stackLength = this.stackLength+(this.stackLength>>1);// >>1:表示除以2
            this.arr = Arrays.copyOf(this.arr,this.stackLength);
        }
    }

    public static void main(String[] args) {
        MyStack<String> myStack = new MyStack<>();
        myStack.push("a");
        myStack.push("b");
        myStack.push("c");
        myStack.push("d");
        myStack.push("e");
        myStack.push("f");
        System.out.println(myStack.size);

        /*System.out.println(myStack.pop());
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());*/

        for(int i=0;i<=myStack.size;i++){
            System.out.println(myStack.pop()+" "+i);
        }

    }
}

所有的代码都跟老师一样的时候也是正常输出的。

然后我就想后面取用pop()方法取元素的时候用for循环去取，for循环的长度我用myStack.size这个数组长度，输出的时候如图所示，找不出问题，求老师解答

//获取迭代器对象
		Iterator<String> iterable = list.iterator();
		while(iterable.hasNext()){
			//String value = iterable.next();
			//System.out.println(value);
			System.out.println(iterable.next());
			
		}

老师这里直接在输出语句里面使用 next()方法不就可以了吗？视频中重新赋值了下，这样做有什么优势吗

怎么回事？

老师，是不是因为private限定了该属性只能被本类访问，所以在反射的时候不能通过安全检查

老师，我通过输出流写一张图片到文件夹里，但是这个文件打不开，是因为我写的文件太大了吗？

老师您好：

为什么 oldlu在上课的编码页顶端有

import java.net.Socket;

而我的有

java.net.ServerSocketjava.net.Socket

this和字符串作为锁对象的区别：字符串是不同的对象使用同一个线程，使用字符串产生互斥效果，使用this作为线程对象锁时，不同的线程操作同一个对象，使用this产生互斥的效果

老师我可以这样去理解它们之间的区别吗

pred属于这个方法里面的变量，那新添加元素的前一个链也没有被随之改变啊，他改变的只是pred  这块我不是很懂

public int menuItemValidate(int min, int max){
    Scanner scanner = new Scanner(System.in);
    while(true){
        System.out.println("请输入正确的数字，最小是："+min+"\t最大是："+max);
        int inputNum = scanner.nextInt();
        if(inputNum >= min && inputNum <= max){
            return inputNum;
        }else{
            System.out.println("输入错误，请检查！");
        }
    }

老师这个可以不用正则表达式吧，这样是不是也可以限定1-7