Java 基础知识

Love The Way You Lie 2021-09-22 20:06 421阅读 0赞

## 引言 ##

> 下面都是我对java基础知识的集锦，查看详细的内容请参照下面的技术文章。

## 重载和重写的区别 ##

**重载**： 发生在同一个类中，方法名必须相同，**参数类型不同、个数不同、顺序不同**，方法返回值和访问修饰符可以不同，发生在编译时。     
**重写**： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

## String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？ ##

1.  **可变性**

**String** 类中使用 **final 关键字**字符数组保存字符串，private final char value\[\]，所以 String 对象是不可变的。  
**StringBuilder** 与 **StringBuffer** 都继承自 **AbstractStringBuilder** 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串char\[\]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

1.  **线程安全性**

**String** 中的对象是不可变的，也就可以理解为常量，线程安全。  
**StringBuffer** 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。  
**StringBuilder** 并没有对方法进行加同步锁，所以是非线程安全的。

1.  **性能**

每次对 **String** 类型进行改变的时候，都会生成一个**新的 String 对象**，然后将指针指向新的 String 对象。  
**StringBuffer** 每次都会对 **StringBuffer 对象本身**进行操作，而不是生成新的对象并改变对象引用。  
相同情况下使用 **StirngBuilder** 相比使用 **StringBuffer** 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

1.  **总结**：

操作少量的数据 = **String**  
单线程操作字符串缓冲区下操作大量数据 = **StringBuilder**  
多线程操作字符串缓冲区下操作大量数据 = **StringBuffer**

## 自动装箱与拆箱 ##

**装箱**：将基本类型用它们对应的引用类型包装起来；  
**拆箱**：将包装类型转换为基本数据类型；

具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86704036][https_blog.csdn.net_weixin_43287508_article_details_86704036]

## == 与 equals ##

== 比较运算符，它的作用是判断两个对象的**地址**是不是相等。  
即，判断两个对象是不是同一个对象。  
(基本数据类型比较的是值，引用数据类型比较的是内存地址)

**equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：  
情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。  
情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；  
说明：String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。

具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86702352][https_blog.csdn.net_weixin_43287508_article_details_86702352]

## 关于 final 关键字的一些总结 ##

final关键字主要用在三个地方：**变量、方法、类**。

1.  **final变量**

如果是**基本数据类型的变量**，则其数值一旦在初始化之后便不能更改；  
如果是**引用类型的变量**，则在对其初始化之后便不能再让其指向另一个对象。

1.  **final修饰一个类**

表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

1.  **final方法**

使用final方法的原因有两个。  
第一个原因是把方法锁定，以防任何继承类修改它的含义；  
第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。类中所有的private方法都隐式地指定为final。

## Java 集合框架 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI4NzUwOA_size_16_color_FFFFFF_t_70]  
具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86701981][https_blog.csdn.net_weixin_43287508_article_details_86701981]

## Arraylist 与 LinkedList 异同 ##

1.  是否保证线程安全： **ArrayList** 和 **LinkedList** 都是不同步的，也就是不保证线程安全；
2.  底层数据结构： **Arraylist** 底层使用的是Object数组；**LinkedList** 底层使用的是双向循环链表数据结构；
3.  插入和删除是否受元素位置的影响： ① **ArrayList** 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。② **LinkedList** 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响。
4.  是否支持快速随机访问： **LinkedList** 不支持高效的随机元素访问，而**ArrayList** 实现了RandmoAccess 接口，所以有随机访问功能。
5.  内存空间占用： **ArrayList**的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而**LinkedList**的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。

## ArrayList 与 Vector 区别 ##

**Vector**类的所有方法都是同步的。可以由两个线程安全地访问一个**Vector**对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。  
**Arraylist**不是同步的，所以在不需要保证线程安全时时建议使用**Arraylist**。

**List**接口下一共实现了三个类：ArrayList，Vector，LinkedList。  
**ArrayList** 主要保持数据的插入顺序的时候使用，采用链表结构。

**ArrayList**，**Vector**主要区别为以下几点：

1.  **Vector**是线程安全的，源码中有很多的**synchronized**可以看出，而**ArrayList**不是。导致**Vector**效率无法和**ArrayList**相比；
2.  **ArrayList**和**Vector**都采用线性连续存储空间，当存储空间不足的时候，**ArrayList**默认增加为原来的50%，**Vector**默认增加为原来的一倍；

## HashMap 和 Hashtable 的区别 ##

1.  线程是否安全：

**HashMap** 是非线程安全的，**HashTable** 是线程安全的；**HashTable** 内部的方法基本都经过 synchronized 修饰。**HashMap** 是非线程安全的。

1.  效率：

因为线程安全的问题，**HashMap** 要比 **HashTable** 效率高一点。另外，**HashTable** 基本被淘汰，不要在代码中使用它；

1.  对Null key 和Null value的支持：

HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 **HashTable** 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。

1.  初始容量大小和每次扩充容量大小的不同 ：

①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。

1.  底层数据结构：

JDK1.8 以后的 **HashMap** 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。**Hashtable** 没有这样的机制。

## HashSet 和 HashMap 区别 ##

看过 HashSet 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI4NzUwOA_size_16_color_FFFFFF_t_70 1]

**HashMap**

1.  HashMap实现了Map接口
2.  HashMap储存键值对
3.  使用put()方法将元素放入map中
4.  HashMap中使用键对象来计算hashcode值
5.  HashMap比较快，因为是使用唯一的键来获取对象

**HashSet**

1.  HashSet实现了Set接口
2.  HashSet仅仅存储对象
3.  使用add()方法将元素放入set中
4.  HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false
5.  HashSet较HashMap来说比较慢

## ArrayList和LinkedList的区别 ##

1.  ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.  对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.  对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/87002475][https_blog.csdn.net_weixin_43287508_article_details_87002475]

## 集合框架底层数据结构 ##

**Collection**

*  List

Arraylist： Object数组  
Vector： Object数组  
LinkedList： 双向循环链表

*  Set

HashSet（无序，唯一）: 基于 HashMap 实现的，底层采用 HashMap 来保存元素  
LinkedHashSet： LinkedHashSet 继承与 HashSet，并且其内部是通过 LinkedHashMap 来实现的。  
TreeSet（有序，唯一）： 红黑树(自平衡的排序二叉树。)

**Map**  
HashMap：HashMap由数组+链表组成的，数组是HashMap的主体。  
LinkedHashMap: LinkedHashMap 继承自 HashMap，底层是基于拉链式散列结构即由数组和链表或红黑树组成。  
HashTable: 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的  
TreeMap: 红黑树（自平衡的排序二叉树）

具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86704594][https_blog.csdn.net_weixin_43287508_article_details_86704594]

## Java多线程 ##

①悲观锁和乐观锁  
具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86704174][https_blog.csdn.net_weixin_43287508_article_details_86704174]  
②synchronized和lock区别以及volatile和synchronized的区别  
③可重入锁与非可重入锁的区别  
④多线程是解决什么问题的  
⑤线程池解决什么问题  
⑥线程池的原理  
⑦线程池使用时的注意事项  
⑧AQS原理  
⑨ReentranLock源码

具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86704174][https_blog.csdn.net_weixin_43287508_article_details_86704174]

## Java虚拟机 ##

关于Java虚拟机的知识点有：  
  ①Java内存区域  
  ②虚拟机垃圾算法  
  ③虚拟机垃圾收集器  
  ④JVM内存管理  
  ⑤JVM调优。  
    
具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86688014][https_blog.csdn.net_weixin_43287508_article_details_86688014]

## 设计模式 ##

手写一个单例模式（注意单例模式的几种不同的实现方法）  
或者让你说一下某个常见的设计模式在你的项目中是如何使用的，  
抽象工厂和工厂方法模式的区别、工厂模式的思想。  
代理模式、观察者模式、（抽象）工厂模式这三个设计模式也很重要。

具体查看我的博客：[https://blog.csdn.net/weixin\_43287508/article/details/86611916][https_blog.csdn.net_weixin_43287508_article_details_86611916]

[https_blog.csdn.net_weixin_43287508_article_details_86704036]: https://blog.csdn.net/weixin_43287508/article/details/86704036
[https_blog.csdn.net_weixin_43287508_article_details_86702352]: https://blog.csdn.net/weixin_43287508/article/details/86702352
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI4NzUwOA_size_16_color_FFFFFF_t_70]: /images/20210920/7fa786c55d0d4af08f1a30f6d0ebad66.png
[https_blog.csdn.net_weixin_43287508_article_details_86701981]: https://blog.csdn.net/weixin_43287508/article/details/86701981
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzI4NzUwOA_size_16_color_FFFFFF_t_70 1]: /images/20210920/1e3b83001b0d4239999b2b463a0d664e.png
[https_blog.csdn.net_weixin_43287508_article_details_87002475]: https://blog.csdn.net/weixin_43287508/article/details/87002475
[https_blog.csdn.net_weixin_43287508_article_details_86704594]: https://blog.csdn.net/weixin_43287508/article/details/86704594
[https_blog.csdn.net_weixin_43287508_article_details_86704174]: https://blog.csdn.net/weixin_43287508/article/details/86704174
[https_blog.csdn.net_weixin_43287508_article_details_86688014]: https://blog.csdn.net/weixin_43287508/article/details/86688014
[https_blog.csdn.net_weixin_43287508_article_details_86611916]: https://blog.csdn.net/weixin_43287508/article/details/86611916