JavaSE知识点

1.基本类型的数组可不可以用于泛型？         

List<int> list = new ArrayList<>();
//此时代码报错

List<int[]> list = new ArrayList<>();
//替换为引用类型数组，没有报错
list.add()//此时需要传入1个数组类型


int[] arr= new int[10];
System.out.println(arr instanceof Object);
//此时输出为true

int[][] arr= new int[2][];
//相当于可以存2个对1维数组的引用，并非二维矩阵（C语言）

数组继承自Object，属于Object的子类，属于引用类型，引用类型存引用，并不是存真正的对象只是对于编程不可见，底层使用C++实现，所以基本类型的数组可以用于泛型。

2.使用一个类的静态内部类中的静态属性，会不会导致两个类都加载？

Test：
package org.example;
public class Test {
    static {
        System.out.println("我是外部类");
    }
    public static class Inner{
        static {
            System.out.println("我是内部类");
        }
        public static  String str="hello";
    }
    }


Main:
package org.example;
public class Main {
    public static void main(String[] args) {
        System.out.println(Test.Inner.str);
    }
}

输出为：
我是内部类
hello

此时外部类没有被加载，

打开目录可以看到内部类Inner并没有包含在Test.class里面，而是单独生成了一个class文件，所以当外部类没有被使用的时候，是不会被加载的。

3.可以创建泛型类的数组吗？

ArrayList<String>[] arr =new ArrayList<String>[10];
//此时代码报错
ArrayList<String>[] arr =null;
arr[0]= new ArrayList<String>();
//但作为变量是没有报错的，并且会进行类型检查
//泛型实际上是不支持的，因为泛型的类型擦除机制，只是在编译阶段的类型检查。

如果要使用的话只可以创建原始类型，不可以指定类型参数 

ArrayList<String>[] arr =new ArrayList[10];
//原始类型

 4.HashMap的put方法返回值是什么

查看HashMap.java可以看到

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;//
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;//
    }

当插入的键值对不存在冲突，正常插入的话，返回值为空

当插入相同键值时，会进行覆盖，此时返回值为被覆盖的内容 

Map<Integer,String> map= new HashMap<>();
System.out.println(map.put(1,"xxx"));
System.out.println(map.put(1, "123"));

输出结果：
null
xxx 

5.抽象类里的普通成员方法可以调用其他未实现的抽象方法吗? 

package org.example;
public abstract class Test {
    public abstract void a();
    public void test() {
        a();
    }
}

通过实际检验发现是可以的，抽象方法会由子类实现。

6.缓存池与equals

    public static void main(String[] args) {
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);
        System.out.println(a.equals(b));
        System.out.println(Objects.equals(a, b));
    }

输出为：

false              //超出缓存池-128到127    -XX:AutoBoxCacheMax=120 修改缓存池大小

true                //比较内容相等

true             

//该方法先判断对象a和b的引用是否相等，如果相等则直接返回true。

//如果引用不相等，则判断a是否为空，如果a为空则返回false。

//如果a不为空，调用对象的equals方法进一步判断值是否相等。