在实现多线程的时候，win10 系统报以下错误（win7是正常测试不报错的）

Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: -1
 at java.lang.String.checkBounds(String.java:381)
 at java.lang.String.<init>(String.java:545)
 at cn.hbyc8888.server.Request.<init>(Request.java:41)
 at cn.hbyc8888.server.Dispatcher.<init>(Dispatcher.java:26)
 at cn.hbyc8888.server.Server.receive(Server.java:49)
 at cn.hbyc8888.server.Server.start(Server.java:32)
 at cn.hbyc8888.server.Server.start(Server.java:19)
 at cn.hbyc8888.server.Server.main(Server.java:62)

问题：通过对IntegerCache源码的阅读，只要调用valueOf(int i)方法时，就在创建一个cache[]数组，里面按次序放置了256个引用对象，对象里面的值分别对应[-128,127]的数；这样理解对不对？

当使用Integer a=Integer.valueOf(120);。这时栈中a引用的cache[]中Integer(120)对象的地址，还是cache[]的地址，有点理解不了，能给分析一下吗？

老师好：

图中循环了20次，i就有了20个值，n被final修饰，不能被再次赋值，那是说明 创建了20个变量n 吗，这个怎么理解比较顺

public class TestSetAccessible {
    public static void main(String[] args) throws Exception{
        Users users=new Users();
        Class clazz=users.getClass();
        Field field= clazz.getDeclaredField("username");
        field.setAccessible(true);
        field.set(users,"平平");
        Object o=field.get(users);
        System.out.println(o);
        System.out.println("--------------");
        Method method=clazz.getDeclaredMethod("suibian");
        method.setAccessible(true);
        method.invoke(users);
        System.out.println("---------------");
        Constructor constructor=clazz.getDeclaredConstructor(int.class);
        //constructor.setAccessible(true);
        System.out.println(constructor);

    }
}

老师私有的构造方法是可以直接访问的吗 不用安全检查

               老师这是哪不对呢

还有就是视频中复制一个文件和复制一个文件夹下的文件，之间有什么逻辑关系?有些搞不清。因为在复制整个文件夹文件的时候是调用了，复制一个文件的copyFile().

老师，这里直接用copyFile  调取方法，不用  copyFile  copy=nwe copyFiled 的方式 是因为这个方法在一个 类里面吗？如果不在一个类里面是不是就需要 用  copyFile  copy=nwe copyFiled  的方式来调取。

老师就是按照您的写了之后服务端一直处于开启状态啊

public class Mysinglylinedlist<E> implements My_List<E>{


    /**
     * 定义单向链表中的节点对象
     */
    class Node<E>{
        private E item;//存储元素
        private Node next;//存储下一个节点对象的地址
        Node(E item,Node next){
            this.item=item;
            this.next=next;
        }
    }
    private Node hand;//存放链表中的头节点
    private int size;//记录元素个数


    /**
     * 向链表中添加元素
     * @param element ：添加的元素
     */
    @Override
    public void add(E element) {
        //创建节点
        Node<E>node=new Node<>(element,null);
        //找到尾节点
         Node tail = gettail();
        //挂接
        if(tail==null)
            this.hand=node;
        else
            tail.next=node;

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


    }

    private Node gettail(){
    //头节点是否存在
        if(this.hand==null){
            return null;
        }
        //查找尾节点
        Node node = this.hand;
        while (true){
            if (node==null) break;
            node = node.next;     //移动指针指向下一个节点
        }
        return node;
    }


    /**
     * 获取链表中元素
     * @param index ：位置
     * @return
     */
    @Override
    public E get(int index) {
        //效验index的合法性
        this.checkindex(index);
        //根据位置获取指定节点
        Node<E> node = this.getnode(index);
        //将该节点元素返回
        return node.item;
    }


    /**
     *判断index的合法性
     */

    private void checkindex(int index){
        if (!(index>=0&&index<this.size)){
            throw new IndexOutOfBoundsException("Index"+index+"size"+this.size);
        }
    }


    /**
    * 根据位置获取节点
    */
    private Node getnode(int index){
        Node<E> node =this.hand;
        for (int i = 0;i<index;i++){
            node=node.next;
        }
        return node;
    }


    /**
     * 获取链表大小
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }


    /**
     * 根于元素位置删除元素
     * @param index ：元素位置
     * @return
     */
    @Override
    public E remove(int index) {
        //判断位置合法性
        this.checkindex(index);
        //根据位置找到指定节点
        Node<E>node=this.getnode(index);
        //通过节点对象获取该节点对象中的元素
        E item = node.item;
        //将该节点对象从单向链表中移除
        //判断删除的节点是否为头节点
        if (this.hand==node){
            this.hand=node.next;
        }else {
            Node<E> temp = this.hand;
            for (int i = 0;i<index-1;i++){
                temp=temp.next;
            }
            temp.next=node.next;
        }
        node.next=null;
        //元素个数记录
        this.size--;
        //将该元素返回
        return item;
    }

    public static void main(String[] args) {
        Mysinglylinedlist<String>mysinglylinedlist=new Mysinglylinedlist<>();
        mysinglylinedlist.add("a");
        mysinglylinedlist.add("b");
        mysinglylinedlist.add("c");
        mysinglylinedlist.add("d");
        System.out.println(mysinglylinedlist.size);
//        System.out.println(mysinglylinedlist.remove(1));
        for (int i = 0 ; i < mysinglylinedlist.size;i++){
            System.out.println(mysinglylinedlist.get(i) );
        }
    }

为什么会报错啊  

map底层为什么不用两层数组进行实现，是因为内层如果用数组实现需要设计到数组扩容的原因么

想问下在URL中，端口数据是否会体现呢？

我记得的之前讲URL时候说，域名后是端口，然后才是要访问的资源文件，但是当时讲的jd.com的例子，这这里讲的baidu.com的例子，都没有在URL中体现出端口数值。

为啥我的压缩包也传不上去，代码放到代码块中也显示乱码，屏幕截图也提交不了？？？

老师好：

请看一下，运行结果不一样，请老师看一下

XML解析类：

package com.bjsxt.server;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class WebDom4j {//解析XML文档
	private List<Entity> entityList;//多个servlet存在，集合存储
	private List<Mapping> mappingList;
	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(List<Entity> entityList, List<Mapping> mappingList) {
		super();
		this.entityList = entityList;
		this.mappingList = mappingList;
	}
	public WebDom4j() {//成员变量初始化
		super();
		// TODO Auto-generated constructor stub
		entityList = new ArrayList<Entity>();
		mappingList = new ArrayList<Mapping>();
	}
	public Document getDocument() {
		SAXReader saxReader = new SAXReader();//创建saxReader对象
		try {
			return saxReader.read(new File("src/WEB_INFO/web.xml"));//调用reader方法，获取docment对象
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	public void parse(Document doc) {
		Element rootElement = doc.getRootElement();//获取根元素
		for(Iterator<Element> ite=rootElement.elementIterator("servlet");ite.hasNext();) {
			Element subElement = ite.next();//获取每一个servlet
			Entity ent = new Entity();//用于存储servlet
			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());//获取文本值，赋值
				}else if ("servlet-class".equals(ele.getName())) {
					ent.setClazz(ele.getText());
				}
			}
			entityList.add(ent);//添加到集合中
		}
		//测试
		for (Entity entity : entityList) {
			System.out.println(entity.getName()+"\t"+entity.getClazz());
		}
		//解析servlet-mapping
		for(Iterator<Element> ite=rootElement.elementIterator("servlet-mapping");ite.hasNext();) {//获取每一个maping
			Element subEle = ite.next();
			Mapping mapping = new Mapping();
			for(Iterator<Element> subite=subEle.elementIterator();subite.hasNext();) {//获取每一个mapping中的元素
				Element ele = subite.next();
				if ("servlet-name".equals(ele.getName())) {
					mapping.setName(ele.getText());
				}else if("url-pattern".equals(ele.getName())) {
					mapping.getUrlPattern().add(ele.getText());
				}
			}
			mappingList.add(mapping);//添加大集合中
		}
		//测试
		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());
				
	}
	
}

XML类：

<?xml version="1.0" encoding="gbk"?>
<web-app>
	<servlet>
		<servlet-name>log</servlet-name>
		<servlet-class>com.bjsxt.servlet.LoginServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>log</servlet-name>
		<url-patter>/log</url-patter>
		<url-patter>/login</url-patter>
	</servlet-mapping>	
	<servlet>
		<servlet-name>register</servlet-name>
		<servlet-class>com.bjsxt.servlet.Register</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>register</servlet-name>
		<url-pattern>/register</url-pattern>
		<url-pattern>/regist</url-pattern>
		<url-pattern>/reg</url-pattern>
	</servlet-mapping>
</web-app>

运行结果截图：

代码包；

这样讲的话，数据流毫无用武之地啊