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

为什么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,集合当中存放的是什么？是任务吗？

老师 我的代码都是照着视频弄的。为什么会出现这种情况

老师我这个怎么没有show in explorer

public void showFlag(Generic<Integer>generic)

<Integer>后面的genericyou 什么作用