老师，为什么把条件写在这里就不行呢，就显示空指针异常了呢？

老师，如果在user类中重写toString()方法，然后调用的话，会出现一个异常，java.io.InvalidClassException: com.college.User; local class incompatible: stream classdesc serialVersionUID = 4908776578495550668, local class serialVersionUID = 1941108881546884415，可以讲讲吗

老师，请问为什么继承Mylist后，重写的add方法中element是Object类型的啊

package com.bjsxt;

public class MyDoublyLinkedList<E> implements MyList {

    private Node head;  //记录头节点
    private Node tail;  //记录尾节点
    private int size;   //记录元素个数

    /*
    定义双向链表的节点对象
     */
    class Node<E> {
        E item;  //记录元素
        Node<E> prev;  //记录前一个节点对象
        Node<E> next;  //记录后一个节点对象

        Node(Node<E> prev, E item, Node<E> next) {
            this.prev = prev;
            this.item = item;
            this.next = next;
        }
    }


    /*
    向双向链表中添加元素
     */


    public void add(Object element){
        this.LinkList(element);
    }

    /*
        将指定对象添加到双向链表的尾部
     */

    private void LinkList(E element) {
        //获取尾节点
        Node t = this.tail;
        //创建节点对象
        Node<E> node = new Node<>(t, element, null);
        //将新节点定义为尾节点
        this.tail = node;
        if (t == null) {
            this.head = node;
        } else {
            t.next = node;
        }
        this.size++;
    }


    /*
   通过指定位置获取元素
     */
    @Override
    public Object get(int index) {
        //校验index的合法性
        this.checkIndex(index);
        //根据位置查找节点对象
        Node<E> node=this.getNode(index);
        return node;
    }

    /*
    对index进行合法性校验
     */
    private void checkIndex(int index) {
        if (!(index >= 0 && index < this.size)) {
            throw new IndexOutOfBoundsException("index:" + index + "size:" + size);
        }
    }

    /*
    根据指定位置获取元素
     */

    private Node getNode(int index) {
        //判断当前位置距离头部还是尾部更近
        if (index < (this.size >> 1)) {
            Node node = this.head;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        } else {
            Node node = this.tail;
            for (int i = this.size - 1; i > index; i--) {
                node = node.prev;
            }
            return node;
        }
    }


    /*
    获取双向链表中元素的个数
     */
    @Override
    public int size() {
        return this.size;
    }

    /*
    通过指定位置删除元素
     */
    @Override
    public Object remove(int index) {
        //对index进行合法性校验
        this.checkIndex(index);
        //跟据指定位置获取节点对象
        Node <E>node=this.getNode(index);
        //获取节点对象中的元素
        E item=node.item;
        //判断当前节点是否为头节点
        if(node.prev==null){
            this.head=node.next;
        }else{
            //完成当前节点的直接前驱节点与当前节点的直接后继节点的挂接
            node.prev.next=node.next;
        }
        //判断当前节点是否为尾节点
        if(node.next==null){
            this.tail=node.prev;
        }else{
            //完成当前节点的直接后继节点与当前节点的直接前驱节点的挂接
            node.next.prev=node.prev;
        }

        //当前节点断掉与直接前驱节点的挂接
        node.prev=null;
        //当前节点断掉与直接后继节点的挂接
        node.next=null;
        node.item=null;
        //记录元素个数
        this.size--;
        return item;
    }

    public static void main(String[] args) {
        MyList<String> my=new MyDoublyLinkedList<>();
        my.add("a");
        my.add("b");
        my.add("c");
        System.out.println(my.get(2));
        System.out.println(my.size());
        for(int i=0;i<my.size();i++){
            System.out.println(my.get(i));
        }

    }
}

package com.bjsxt;
/*
基于链表结构存取元素的方法API定义

 */


public interface MyList<E> {
    void add(E element);
    E get(int index);
    int size();
    E remove(int index);


}

老师我问一个我自己觉得有点蠢的问题

为什么sort();方法返回值是空，排序后会出现返回值

老师，请问为什么会报错啊

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;       //操作数组下标的指针


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

    }


    //获取栈顶元素
    public E pop() {
        //如果栈容器中没有元素则抛出异常
        if (this.index == -1) {
            throw new EmptyStackException();
        }
        //记录元素个数
        this.index--;
        //如果有元素，则返回栈顶元素
        return (E) this.arr[index--];
    }


    //向栈顶添加元素
    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 >= 0) {
            this.stackLength = this.stackLength + this.stackLength >> 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");

        System.out.println(myStack.size);

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



    }

}

老师，请问为什么会报错啊

package com.bjsxt;

/*
基于单向链表
 */
public class MySinglyLinkedList<E> implements MyList<E> {

    /*
    定义单向链表中的节点对象
     */
    class Node<E> {
        private E item;                  //存储元素
        private Node next;               //存储下一个节点对象的地址

        Node(E item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    private Node head;  //存放链表中的头节点
    private int size;   //记录元素个数

    //向链表中添加元素
    @Override
    public void add(E element) {
        //创建节点
        Node<E> node = new Node<>(element, null);
        //找到尾节点
        Node tail = getTail();
        if (tail == null) {
            this.head = node;
        } else {
            tail.next = node;
        }
        //记录元素个数
        this.size++;

    }

    private Node getTail() {
        //头节点是否存在
        if (this.head == null) {
            return null;
        }
        //查找尾节点
        Node node = this.head;
        while (true) {

            if (node.next == null) break;
            node = node.next;
        }
        return node;
    }

    //根据元素位置获取元素
    @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 < size)) {
            throw new IndexOutOfBoundsException();
        }
    }

    /*
    根据位置获取节点
     */

    private Node getNode(int index) {
        Node<E> node = this.head;
        for (int i = 0; i < index;i++) {
            node = node.next;
        }
        return node;
    }


    //获取元素个数
    @Override
    public int size() {
        return size;
    }

    //根据元素位置删除元素
    @Override
    public E remove(int index) {
        //检验index合法性
        this.checkIndex(index);
        //根据位置找到该节点对象
        Node<E> node = this.getNode(index);
        //获取该节点对象中的元素
        E item = node.item;
        //将还节点对象从单向链表中删除
        //判断当前删除订的节点是否尾头节点
        if (this.head == node) {
            this.head = node.next;
        } else {
            Node<E> temp = this.head;
            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) {
        MySinglyLinkedList<String> my=new MySinglyLinkedList<>();
        my.add("a");
        my.add("b");
        my.add("c");
        my.add("d");
        System.out.println(my.size());
        System.out.println(my.get(3));
        System.out.println(my.remove(2));
        for(int i=0;i<my.size();i++){
            System.out.println(my.get(i));
        }
    }


}

package com.bjsxt;
/*
基于链表结构存取元素的方法API定义

 */


public interface MyList<E> {
    void add(E element);
    E get(int index);
    int size();
    E remove(int index);


}

数组初始化, 这里的16,12怎么来的???怎么知道初始化的时候是左移4位呢???? 2的4次方=16,

为什么我没有给定泛型类型直接返回String类型

老师这个为什么从大到小排列可以三个全部输出 

从小到大 第三个为空了 这是为什么啊

Test_4 是User 

老师，请问在获取compareTo所需参数时，使用get方法与直接调用属性有什么区别呀(o.userage与0.getUserage区别)

@Override
public int compareTo(Users o) {
    if(this.userage>o.userage)
    {
        return 1;
    }
    if(this.userage==o.userage)
    {
        System.out.println(o.userage);
        System.out.println(o.getUserage());
        System.out.println("-----------");
        return  this.username.compareTo(o.getUsername());
    }
    return -1;
}

问题：代码一样，为什么我的输出是这个，配置问题吗？？？

我这里为什么会报错。。。。。。。。。。。。。。

我这个程序就很离谱——为什么我是八个？（好家伙 为什么非得20个字才能提问。。。。。）

MyInteger {
    ;
    MyInteger[] ;

    = -;
    = ;

    {
        (i=;i<=;i++){
            [i+] = MyInteger.(i);
        }
    }

    MyInteger valueOf(i){
        (i>=&&i<=){
            [i+];
        }
        MyInteger(i);
    }

    MyInteger(i){
        .= i;
    }

    main(String[] args) {
        MyInteger m = MyInteger.();

    }
}

我按照老师代码一个不差的敲得，上面是我的代码，但是运行的时候报错了（视频中老师并没有运行这个代码）

运行报错：

我仔细研究了一下代码，想问一下：

1.静态方法

public static MyInteger valueOf(int i){
    if (i>=LOW&&i<=HIGH){
        return cache[i+128];
    }
    return new MyInteger(i);
}

方法中能new对象吗？关于这个问题我百度了一下，但是并没有查到关于static方法中能不能调用构造函数的问题解答，但是就我理解来讲是不能的，希望老师解答XD。

2.i在【-128，127】区间里可以直接cache【i+128】 =MuInteger.valueOf(i) = cache【i+128】吗，这样不就是一个死循环吗，只是有个256个数组空间但是没有并没有赋东西进去啊，有点搞不懂这个

3.我将

(i=;i<=;i++){
    [i+] = MyInteger.(i);
}

改为

(i=;i<=;i++){
    [i+] = MyInteger(i);
}

运行报错变为：

我不知道是不是问题2的代码问题导致的，还是我对数组赋值部分理解有问题，希望老师可以解答一下，帮忙找下代码错误，我按照老师的代码比对很久了，但是没找到不同的地方，也可能是我自己看自己的代码很难看出错，希望老师看下，辛苦老师了XD

老师，由于前面的线程记得不太清，所以有以下几个疑问。

一、多线程是创造几个线程，然后cpu自由调度执行。为什么多线程会减少时间，是因为这个线程在堵塞的时候，其他线程就来执行了？所以导致效率变高。那线程安全的话，是加把锁，只有等这个执行完了其他再执行，那多个线程的时间效率就不存在了？

二、线程池的execute和submit方法，是处理runnable等任务，但这个是在for循环里面的，是怎么执行了20次任务？

三、线程池处理Callable,集合当中存放的是什么？是任务吗？