java基础知识

phn555

已于 2022-03-18 10:51:36 修改

阅读量1k

点赞数

文章标签： java javaee

于 2022-03-17 15:21:42 首次发布

本文链接：https://blog.csdn.net/phn555/article/details/123498444

版权

关于String

String的实现原理及存储方式

答

String类被final关键字修饰，不能被继承，并且它的成员方法都默认为final方法。
值是通过char数组存储的，并且char数组被private和final修饰，字符串一旦创建就不能再修改。（jdk9之后采用byte数组）
所有看似修改的操作，都是返回的新字符串。

String为什么要用final修饰？

答

安全性：因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享
效率：字符串不变性保证了hash码的唯一性，因此可以放心的进行缓存，这也是一种性能优化手段，意味着不必每次都取计算新的哈希码，且可以从字符串常量池中获取，更快。
空间：在应用中字符串使用时最多的，也占据大量的内存，只有当字符串是不可变的，字符串常量池才能实现，得以节省大量空间。

new String(“abc”)创建了几个对象？

答

当"abc"已存在时，只创建一个，即堆中创建一个对象存放指向常量池的地址。

当不存在时，先在字符串常量池创建一个"abc",还有堆中的对象

+ 的实现原理？

答

当使用 +直接拼接字符串（“a”+“b”）或者拼接常量时，是在编译期就以经完成了。
当使用+拼接变量时，则字节码层面采用StringBuilder拼接，然后在调用toString()生成字符串，且不会入池。

下面代码s与s3有什么区别？

String s = "a" + "b";
String s1 = "a";
String s2 = "b";
String s3 = s1 + s2 ;

答

s在编译期编译完成 s =“ab”;
s3需要在运行是，先创建StringBuilder，然后调用append拼接s1,s2，再调用toString()生成新的字符串给S3。

关于intern

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);

答

false :new的对象自然与池中不一样

String s3 = new String("1") +  new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);

答

jdk 6结果：false。由于s3入池时，池中没有，所有会新建一个，所以s3!=s4.
jsk 7 8：true。由于s3入池时，池中没有,但字符串常量池已经是在堆中了，所以只是在字符串常量池存放指向堆中“11”的地址。所以是true.

字符串常量池存放在哪里？

答

jdk7之前存放在永久代，jsk7开始字符串常量池、静态变量移到堆中

字符串常量池的位置为什么要调整呢？

答

永久代回收效率低，几乎不会进行垃圾回收，只有在full gc时才触发，而字符串又是最常使用的。
永久代默认空间也不大，容易内存溢出

关于集合

Arraylist 的实现？

答

ArrayList 的底层是数组队列，相当于动态数组。与的数组相比，它的容量能动态增长。在添加大量元素前，应提前设置数组大小。这可以减少递增式再分配的数量。

Arraylist 与 LinkedList 区别?？

答

底层数据结构： Arraylist 底层使用的是数组；LinkedList底层使用的是链表结构（JDK1.6之前为循环链表，JDK1.7取消了循环）
插入和删除是否受元素位置的影响：ArrayList会，LinkedList不会）
是否支持快速随机访问： LinkedList不支持， ArrayList 支持。
内存空间占用： ArrayList的空间浪费主要体现在list的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间。

ArrayList 扩容机制分析？

答

jdk8

构造器：默认有三种方式的构造器
1. 默认构造函数，构造一个空列表(无参数构造)。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。
  
  public ArrayList(){ this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
2. 带初始容量参数的构造函数。（指定容量推荐）
  
  public ArrayList(int initialCapacity)
3. 构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
  
  public ArrayList(Collection<? extends E> c)
添加元素时
1. 当我们要 add 进第 1 个元素到 ArrayList时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal(确保内部容量) 方法，所以 minCapacity 此时为 10。此时，minCapacity - elementData.length > 0成立，所以会进入 grow(minCapacity) 方法。
2. 直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入 grow 方法进行扩容。
3. grow中每次扩容之后容量都会变为原来的 1.5 倍左右，然后调用Arrays.copyOf复制数据。

对于集合的求和，有什么优化方法吗？

答

可以先排序，在求和,一个数组求和的函数，把数组排序后求和比无序求和的计算性能高6倍。

原因：由于分支预测，会根据历史的记录预测下一次的执行，有序的预测是准确的；而无序的没有规律，预测不准确，所以效率低。

这也正好解释了加减乘除操作没有位运算高效的原因，因为位运算去除了分支预测，所以性能就会更高

示例


public static void main(String[] args) {
    List list = getArray(10000);
    getSum(list);
    getSum2(list);
}
private static List getArray(int n){
    List list = new ArrayList<>(n);
    Random random = new Random();
    for (int i = 0; i < n; i++) {
        list.add(random.nextInt(n));
    }
    return list;
}

private static Integer getSum(List list){
long l = System.nanoTime();
Integer collect = list.stream().collect(Collectors.summingInt(Integer::intValue));
long l2 = System.nanoTime();
System.out.println(“不排序就求和用时:”+(l2-l)+",结果="+collect);
return collect;
}
private static Integer getSum2(List list){
long l = System.nanoTime();
Stream list2 = list.stream().sorted();
Integer collect = list2.collect(Collectors.summingInt(Integer::intValue));
long l2 = System.nanoTime();
System.out.println(“先排序再求和用时:”+(l2-l)+",结果="+collect);
return collect;
}

HashMap

1. HashMap的数据结构

答

哈希表结构（数组+链表），在jdk1.8之后当链表超过8时转为红黑树结构，当链表少于6时，转回链表

2. 链表超过8时立即转为树吗？

答

不是，需要判断table的个数是否超过64,没有就扩容，超了才转变

3. HashMap的put过程

答

计算key的hash值，并计算下标，得出元素的存储位置
如果没有hash冲突，则插入
如果hash冲突，则进行equals比较，相同则覆盖，不同则在尾部插入
调整数组大小(当容器中的元素个数大于容量*载入因子时，容器会进行扩容resize 为 2n)

4.获取hash值的方法如下，为何这样做

static final int hash(Object key) {
        int h;
        // 通过key hashCode() 的高 16位异或低16位实现
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

答

主要是从速度，功效和质量来考虑的，减少系统的开销，也不会造成因为高位没有参与下标的计算，从而增大碰撞概率。

5. 为什么HashMap数组的长度是2的幂次方？

答

为了提高获取插入元素位置的效率（i = (n - 1) &hash）如果被除数是2的幂次方，那么这对数组长度取余的方法就等价于对数组长度减一的值进行按位与操作。在计算机中，位运算的效率远高于取模运算。

6. 拉链法导致的链表过深问题为什么不用二叉查找树代替，而选择红黑树？为什么不一直使用红黑树？

答

红黑树是为了解决二叉查找树的缺陷，二叉查找树在特殊情况下会变成一条线性结构（这就跟原来使用链表结构一样了，造成树过高问题），遍历查找会非常慢。

9. 为什么要把链表转为红黑树，阈值为什么是8？

答

当key的哈希码分布均匀时，数组同一个位置上的元素数量是成泊松分布的，同一个位置上出现8个元素的概率已经接近千分之一了，这侧面说明如果链表的长度达到了8，key的hashCode()肯定是出了大问题，这个时候需要红黑树来保证性能，所以选择8作为阈值。

10. 加载因子默认为0.75，如果改为0.4会怎样？0.95呢？

答

提高空间利用率和减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小，
加载因子过高，虽然减少了空间开销，提高了空间利用率，但增加了查询时间成本；
加载因子过低，可以减少查询时间成本，但是空间利用率降低，同时提高了rehash的次数。

11. 为何说HashMap不安全？

答

在多线程下，①JDK1.7采用头插发，可能导致死循环；
② JDK8采用尾插发，解决了该问题，但值可能会被覆盖；
③ size++ 计算是统计不准确

LinkedHashMap的有序与TreeMap的有序有何不同？

答

LinkedHashMap 内部维护了一个单链表，有头尾节点，同时 LinkedHashMap 节点 Entry 内部除了继承 HashMap 的 Node 属性，还有 before 和 after 用于标识前置节点和后置节点。可以实现按插入的顺序或访问顺序排序。
TreeMap 是按照 Key 的自然顺序或者 Comprator 的顺序进行排序，内部是通过红黑树来实现。所以要么 key 所属的类实现 Comparable 接口，或者自定义一个实现了 Comparator 接口的比较器，传给 TreeMap 用户 key 的比较。

ConcurrentHashMap

1. JDK 1.7ConcurrentHashMap类的是实现方式

答

JDK 1.7中，采用分段锁的机制，实现并发的更新操作，当多个线程put时，只要被加入的数据不在同一个segment中,就可以并行。

底层采用数组+链表的存储结构，包括两个核心静态内部类Segment 和 HashEntry。

Segment 继承 ReentrantLock（重入锁）用来充当锁的角色，每个 Segment对象守护每个散列映射表的若干个桶；

HashEntry 用来封装映射表的键-值对；每个桶是由若干个 HashEntry 对象链接起来的链表

2 JDK 8ConcurrentHashMap类

答

在JDK1.8之后摒弃了segment这种臃肿的设计，底层用的也是数组加链表/红黑树。在新实现中，在put方法里使用了CAS + synchronized进行同步。

如果插入元素的位置为空，则使用CAS进行插入。如果插入的位置不为空，则对当前位置的对象进行加锁，也就是对链表或红黑树的头节点加锁后再进行后续的插入操作。

这样设计的好处是：

CAS是十分轻量的加锁操作，如果能够直接插入，用CAS能够大幅度节省加锁的开销。
如果发生冲突，只用锁住当前位置的头结点，理论上数组的长度有多大，并发操作的线程数就能有多少，比原来只能有16个线程效率更高。

3. ConcurrentHashMap 在 JDK 8中，为什么要使用内置锁 synchronized 来代替重入锁 ReentrantLock？

答

synchronized在JDK1.6之后做了大量的优化，使锁粒度降低了，并且 JVM 开发团队没有放弃 synchronized，而且基于 JVM 的 synchronized 优化空间更大，更加自然。
在大量的数据操作下，对于 JVM 的内存压力，基于 API 的 ReentrantLock 会开销更多的内存。

4.ConcurrentHashMap 存储对象时（put() 方法）：

答

计算key的hash值
如果没有初始化，就调用 initTable() 方法来进行初始化；
如果没有 hash 冲突就直接 CAS 无锁插入；
如果存在 hash 冲突，就加锁来保证线程安全，两种情况：一种是链表形式就直接遍历到尾端插入，一种是红黑树就按照红黑树结构插入；
判断需要帮助扩容；
如果该链表的数量大于阀值
就要先转换成红黑树的结构，break 再一次进入循环
如果添加成功就调用 addCount() 方法统计 size，并且检查是否需要扩容。

扩容方法:

transfer()：默认容量为 16，扩容时，容量变为原来的两倍。
helpTransfer()：调用多个工作线程一起帮助进行扩容，这样的效率就会更高。

5. 获取对象时（get()方法）：

答

计算 hash 值，定位到该 table 索引位置，如果是首结点符合就返回；
如果遇到扩容时，会调用标记正在扩容结点 ForwardingNode.find()方法，查找该结点，匹配就返回；
以上都不符合的话，就往下遍历结点，匹配就返回，否则最后就返回 null。

6.ConcurrentHashMap 的并发度是什么？

答

程序运行时能够同时更新ConccurentHashMap 且不产生锁竞争的最大线程数。默认为16，且可以在构造函数中设置。当用户设置并发度时，ConcurrentHashMap会使用大于等于该值的最小2幂指数作为实际并发度（假如用户设置并发度为17，实际并发度则为32）