package integre.fang.com;
/**
 * 自己手写得包装类
 *
 * */
public class MyInteger01 {
    private int value;
    public static final int LOW=-128;
    public static final int HIGH=127;
    private static MyInteger01[] myInteger01;

    static {
        for (int i=LOW;i<=HIGH;i++){
          myInteger01[i+128]=MyInteger01.getMyinteger(i);//核心得点在这里，有点迷糊
        }
    }

    public  MyInteger01(int a) {
        this.value = a;
    }

    public static MyInteger01 getMyinteger(int a){
        if (LOW<=a && a<=HIGH){
            return myInteger01[a+128];
        }
            return new MyInteger01(a);

    }

    public static void main(String[] args) {
        int a=100;
        int b=100;
        MyInteger01 m1=new MyInteger01(300);
        MyInteger01 m2=new MyInteger01(300);
        MyInteger01 m3=new MyInteger01(100);
        MyInteger01 m4=new MyInteger01(100);
        System.out.println(m1==m2);
        System.out.println(m3==m4);
        //System.out.println(MyInteger01.getMyinteger(a)==MyInteger01.getMyinteger(b));
        //System.out.println(MyInteger01.getMyinteger(a).equals(MyInteger01.getMyinteger(b)));

        int c=1000;
        int d=1000;
        //System.out.println(MyInteger01.getMyinteger(c)==MyInteger01.getMyinteger(d));
        //System.out.println(MyInteger01.getMyinteger(c).equals(MyInteger01.getMyinteger(d)));
    }

}

Exception in thread "main" java.lang.ExceptionInInitializerError

老师帮忙看看哪里出错了？

老师，这个再[-127,127]不是自动拆箱吧？只不过是Integer在这个区间内规定了是对象在这个常量池里。老师帮忙解释一下。 

package com.bjsxt;

public class TestThread extends Thread {
    public TestThread() {
        System.out.println(this.getName());
    }

    /**
     * 线程的线程体
     */
    @Override
    public void run() {
        System.out.println(this.getName()+"线程开始");
        for (int i=0;i<20;i++){
            System.out.println(this.getName()+" "+i);
        }
        System.out.println(this.getName()+"线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        TestThread t1 = new TestThread();
        TestThread t2 = new TestThread();
        t1.start();
        t2.start();
        System.out.println("主线程结束");
    }
}

老师为什么我的线程只会一个一个进行，

如果有对参数操作的-就需要使用泛型，不操作，光是获取查看就可以使用通配符

没理解，老师，能实例说明下？

通配符？和泛型T有什么区别？

什么情况用通配符？ 什么情况用泛型T呢？

听完还是懵逼的。

关于查找尾节点，有问题：

Node node = this.head;
while(true){
    if(node.next==null) break;
    node = node.next;
}

问题是：

Node node = this.head;

node节点第一次是指向head的，所以，node.next就是指向head节点的地址，

那么此时，运行第四行代码：

node = node.next;

node指向node.next节点（就是head的地址），node不就是一直指向head节点吗？

若想向后移动，不应该是

node= node.next.next //可能代码不对，但就是这个意思

即： node.next (head的地址） 然后再next（head的地址的next，就是第二个节点）

我能想到解释的通的逻辑是：

node=this.head，就是把head赋值给node了，就相当于node就是head节点，所以node.next就是些相当于head.next。

但是，此时运行 node = node.next

因为node是head节点，相当于 head= head.next，这总理解下，node又不动了。。。

这里真的非常晕，希望老师能详细解释一下，我两个想法到底哪里想错了。。。

为什么客户端和服务端监听的端口不一样

如果我在定义验证菜单项的正则表达式的时候定义的是[1-7]，那是不是就不需要再在这里进行校验了？

int inputNum = Integer.parseInt(input);     
if (inputNum >= min && inputNum <= max){
    return inputNum;
}else {
    System.out.println("您输入的菜单项不符，请重新输入！");
    }

老师，守护线程的意思是，如果给哪个线程加上了守护线程，该线程终止 守护线程也同样会终止对吧

package thread;

/**
 * 守护线程（辅助线程）
 * 1、给用户线程添加守护线程
 * 2、守护线程的生命周期会随着用户线程的结束而结束
 */
class Daemon implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class DaemonThread {
    public static void main(String[] args) throws Exception {
        Thread thread=new Thread(new Daemon(),"守护线程");
        //将该线程设置为守护线程
        thread.setDaemon(true);
        thread.start();
        Thread.sleep(1000);
        System.out.println("主线程结束");
    }
}

这个我给主线程加入了守护线程，主线程结束，守护线程就不能在运行了，但是我的还是会运行一下才会停止，如果改变一下守护线程的休眠时间就正确了 这是为啥？

老师，电话本项目作业，我在operate类的addOpration中添加了ObjectOutputStream，

public void addOperation() {
    TelNoteRegex telNoteRegex=new TelNoteRegex();
    String name=telNoteRegex.nameValidate();
    String age=telNoteRegex.ageValidate();
    String sex=telNoteRegex.sexValidate();
    String telNum=telNoteRegex.telNumValidate();
    String address=telNoteRegex.addressValidate();
    Person person=new Person(name,age,sex,telNum,address);
    this.list.add(person);
    person.setId(this.list.size());
    ObjectOutputStream oos=null;
    try {
        oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/person.txt",true)));
        oos.writeObject(person);
        oos.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if (oos!= null) {
                oos.close();
            }
        }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

然后在Operate类创建了一个ObjectInputStream方法，

/**
 * 对象输入流
 * 初始化list
 */
public void ObjectInputStream(){
    ObjectInputStream ois=null;
    try{
        ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/person.txt")));
        List list=(List<Person>)ois.readObject();
        this.list=list;
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        try{
            if (ois!=null){
                ois.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

再在app类的start方法里调用operate的ObjectInputStream方法，初始化list内的信息，以便下次打开程序时读取之前存储的信息。

public void start(){
    Menu menu=new Menu();
    TelNoteRegex regex=new TelNoteRegex();
    Operate operate=new Operate();
    operate.ObjectInputStream();//初始化Operate中的list
    while (true) {
        menu.mainMenu();
        int item=regex.menuItemValidate(1,6);
        switch (item){
            case 1:operate.addLogic();break;
            case 2:operate.searchLogic();break;
            case 3:operate.modifyLogic();break;
            case 4:operate.deleteLogic();break;
            case 5:operate.orderLogic();break;
            case 6:System.exit(0);  //结束虚拟机

程序运行后有如下报错。

java.io.EOFException
	at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2638)
	at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:3113)
	at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:853)
	at java.io.ObjectInputStream.<init>(ObjectInputStream.java:349)
	at com.wxc.Operate.ObjectInputStream(Operate.java:159)
	at com.wxc.App.start(App.java:28)
	at com.wxc.App.main(App.java:18)

不知道这个思路问题出在哪里。

像这种方法都必须要添加this.吗，this.表示当前调用它的对象，但是我觉得这种不写也是可以的吧，对结果不影响，好像就get set方法，构造函数，构造函数调用其他构造器，这里面才需要this吧

老师，为什么这里声明ArrayList的时候，要用List<>

List<String> list = new ArrayList<>();

好像其他地方也有这样的，用父类来声明，new 子类。

Iterator<String> iterator = list.iterator();
System.out.println("--------------------while-------------------------");
while(iterator.hasNext()){
    //不要在一次循环中多次调用next方法。
    String value = iterator.next();
    if ("狗蛋".equals(value)){
        iterator.remove();
    }
    System.out.println(value);
    //错误示范
    //System.out.println(iterator.next());
}

老师，为什么我的代码输出结果没有被删除呢；但是写一个else放在里面结果就正确了，为什么？？？执行顺序都是一样的呀？

Iterator<String> iterator = list.iterator();
System.out.println("--------------------while-------------------------");
while(iterator.hasNext()){
    //不要在一次循环中多次调用next方法。
    String value = iterator.next();
    if ("狗蛋".equals(value)){
        iterator.remove();
    }
    System.out.println(value);
    //错误示范
    //System.out.println(iterator.next());
}

老师，为什么我的代码输出结果没有被删除呢；但是写一个else放在里面结果就正确了，为什么？？？执行顺序都是一样的呀？

还是3分30秒的讲解，有两个问题：

for(int i = 0; i < list.size() ; i++){

}

（1）

for内部三个条件的执行顺序是如何的？

因为内部一定要遍历index=0位置的元素，因此是否是：先i=0，判断是否<list.size, 先执行循环内部语句，最后执行i++？

因为如果在进入循环语句前就执行了i++，那么遍历就是从index=1 开始的。

（2）

回到讲解本身的问题：

在执行完i=2，删除c后，i=3(如何按照我上面理解的执行顺序的话）

执行下一次循环，size（）会变成3，此时i=list.size(), 那么应该跳出循环，不该执行循环体，这才是d没有被打印出来的原因吧？

为什么按照老师讲的，是仍然进入了循环体，d因为本移动到index=2的位置，被remove掉了才不执行？