面试题总结

时间：2023-06-23 11:07:00 端子环形连接器 by934g压力变送器连接器s10b

文章目录

Java(待补充！
- 1. 基础
- - Java关键字
  - 自增自减运算符
  - &和&&的区别
  - continue、break 和 return 有什么区别？
  - heap和stack有什么区别
  - 静态方法为什么不能调用非静态成员?
  - 静态法和实例法的区别
  - 静态变量与实例变量的区别
  - 基本数据类型
  - - 八种基本数据类型
    - 基本类型和包装类型的区别
    - 缓存机制的包装类型
    - 自动装箱和拆箱
  - 成员变量与局部变量的区别
  - 相等和引用对象的差异
  - 类结构方法的作用是什么？
  - 能否重写构造器的特性？（override）
  - 接口和抽象有什么共同点和区别？
  - 深拷贝和浅拷贝有区别吗？什么是引用拷贝？
  - == 和 equals 有什么区别？
  - switch 它能起作用吗？byte上，它能起作用吗？long上，它能起作用吗？String上?
  - Hash Code有什么用？
  - Hash Code 存在的原因
  - 为什么要同时提供？ hash code 和 equals这两个方法
  - 为什么有两个对象？hash code 他们不一定相等
  - 为什么重写equals 方法必须重写hash code 方法
  - 数组有没有length()这个方法 String有没有length()这个方法？
  - 可变字符串
  - String, String Buffer 和 String Builder 有什么区别？
  - Stirng为什么不可改变？
  - String equals 和 obj equals 的区别
  - 字符串常量池的作用
  - String str="i"与 String str=new String("i")一样吗？
  - 字符串池
  - String s=new String(“xyz)；创建了多少字符串对象？
  - final 在 java 它的作用是什么？
  - 重载（Overload）和重写（Override）的区别
  - 抽象的（abstract）方法是否可以同时静态（static）,是否可以同时进行本地方法（native），能同时被吗？synchronized修饰?
  - GC 是什么？为什么要有？GC？
  - 常量池
  - - 字符串常量池
    - Class 常量池
    - 常量池运行
  - 基本数据类型和包装数据类型使用标准
  - 接口是否可继承（extends）接口? 抽象是否可以实现（implements）接口? 抽象是否可以继承特定类别（concrete class）?
  - 内部类能引用其包含类(外部类)的成员吗？有什么限制吗？
  - final、finally、finalize 有什么区别
  - 结构方法的特点
  - 静态法和非静态法的区别
  - Java内存区域
- 2. 面向对象
- - 封装性
  - 继承性
  - 多态性
  - 方法重载（Overload）
  - 包装和访问控制
  - 静态变量和静态方法
  - 静态代码块
  - 构造方法
  - 重载结构方法
  - This 关键字
  - 继承（extends）
  - 调用父类结构方法
  - 方法覆盖（override）
  - 多态
  - 引用类型检查（instanceof）
  - Final 关键字
- 3. 抽象与接口
- - 抽象类（abstract）
  - 接口(interface)
  - 接口继承
  - 抽象与界面的区别
- 4. 异常
- - Error 和Exception 有什么区别？
  - Checked Exception 和 Unchecked Exception 有什么区别？
  - try{}里面有一个return然后跟着这个句子，try后的finally{}里的code什么时候执行，什么时候执行？return前还是后?
  - finally 代码会执行吗？
  - throw、throws的区别
- 5. 容器
- - Collection 和Collections 的区别？
  - List, Set, Map是否继承自Collection接口?
  - List , set ,map 之间的区别
  - 收集底层数据结构
  - - Lsit
    - Set
    - Map
  - List 集合
  - Set集合
  - Map集合
  - 线程安全的集合类是什么？
  - Java集合快速失败机制 “fail-fast”？
  - ArrayList 的扩容机制
  - ArrayList 的优缺点
  - LinkedList 的优缺点
  - ArrayList 和 LinkedList 有什么区别？
  - ArrayList 和 Vector 有什么区别？
  - ArrayList、Vector、LinkedList 存储性能和特性？
  - List和Map的区别
  - List 和 Set 的区别
  - Set元素不能重复，那么如何区分重复呢？
  - HashSet 的实现原理
  - HashSet如何检查重复？HashSet如何确保数据不可重复？
  - HashSet与HashMap的区别
  - HashMap 的实现原理
  - HashMap 与 HashTable 有什么区别？
  - Hash Map 和 Concurrent Hash Map 的区别
  - Concurrent Hash Map 和 Hash table 的区别？
  - comparable 和 comparator的区别？
- 6. 多线程
- - 实现线程的方法
  - sleep() ?法和 wait() ?法律差异和共同点
  - Thread 类中的start() 和 run() 方法有什么区别？
  - start() ?法时会执? run() ?法，为什么不能直接调? run() ?法？
  - synchronized 关键字
  - synchronized锁的是什么
  - synchronized 关键字使用方式
  - 构造⽅法可以使⽤ synchronized 关键字修饰么？
  - synchronized 关键字和 volatile 关键字的区别
- I/O流
- - 什么是序列化？什么是反序列化
  - Java 序列化中如果有些字段不想进行序列化时怎么办？
  - BIO、NIO、AIO 有什么区别
  - - BIO(Blocking I/O):
    - NIO(New I/O):
    - AIO(NIO.2):
    - 总结:
  - Java 中有几种类型的流
  - 字节流和字符流的区别
- 8. 正则表达式
- 9. 数据结构
- - 数组
  - 链表
  - 堆
  - 栈
  - 队列
  - 树
  - 哈希表
  - 图(Graph)
- 10. 网络协议
- - UDP和TCP的特点
  - TCP的三次握手
  - TCP三次握手的原因
- 11. 算法（待总结！）
- - 顺序查找
  - 二分查找(必须是有序的)
  - 冒泡排序:
  - 快速排序:
  - 归并排序:
- 12. Lambda表达式
- 13. 设计模式（需要了解各个模式的思想）
- - 创建型模式
  - - 工厂方法模式
    - 抽象工厂模式
    - 原型模式
    - 单例模式
    - 建造者模式
  - 结构性模式
  - - 适配器模式
    - 装饰器模式
    - 代理模式
    - 外观模式
    - 桥接模式
    - 组合模式
    - 享元模式
  - 行为模式
  - - 策略模式
    - 模板方法模式
    - 观察者模式
    - 迭代器模式
    - 责任链模式
    - 命令模式
    - 备忘录模式
    - 状态模式
    - 访问者模式
    - 中介者模式
    - 解释器模式
Scala（待总结！）
MySQL（注意SQL练习）
- 索引
- - 什么是索引:
  - 索引设计原则:
  - 优缺点:
  - 创建索引的方法:
  - 类型:
  - 索引数据结构:
  - - HASH(哈希):
    - BTREE(b树):
- truncate和delete的区别是什么？
- 索引，主键，唯一索引，联合索引的区别
- 关联查询语句都有哪些
- 数据类型
- 查询
- - count(\*) 和 count(1)和count(列名)区别
  - MySQL中 in和 exists 的区别？
  - UNION和UNION ALL的区别
  - SQL执行顺序
- 什么是事务
- 事务的四大特征
Pgsql（PostgreSQL）未总结！
Redis（完结！）
- Redis介绍
- Redis 适合场景
- 优缺点
- 数据类型
- Redis 缓存雪崩怎么解决
- Keys 命令和 scan 命令
- 为什么 Redis 需要把所有数据放到内存中
- 持久化
- 持久化机制
- - RDB(默认)(Redis DataBase):
  - AOF(Append Only File):
- Redis持久化数据和缓存怎么做扩容
- Redis 过期键的删除策略
- - 定时过期:
  - 惰性过期:
  - 定期过期:
- Redis内存淘汰策略
- 事务
- 什么是 Redis 事务？原理是什么？
- 如果有大量的key需要设置同一时间过期，一般需要注意什么？
- Redis 哨兵和集群的区别
- Redis 的哨兵有什么功能？
- Redis 事务的注意点有哪些？
- Redis 为什么不支持回滚
- Redis 为什么设计成单线程的？
- pipeline 有什么好处，为什么要用 pipeline？
- Redis 同步机制
- Redis是怎么持久化的？服务主从数据怎么交互的？
- Redis 持久化机制 AOF 和 RDB 有哪些不同之处？
- RDB 持久化机制的优缺点
- AOF 持久化机制的优缺点
- 如果 AOF 文件的数据出现异常，Redis 服务怎么处理？
- Redis 持久化机制 AOF 和 RDB 有哪些不同之处？
Linux（需总结练习！）
Shell脚本（需总结练习！）
Hadoop（完结！）
- Hadoop 组成架构
- 常用端口号
- 常用配置文件
- HDFS
- - HDFS概念
  - HDFS优缺点
  - HDFS组成架构
  - - Name Node
    - Data Node
    - Client
    - Secondary Name Node
  - HDFS文件块大小
  - 命令行操作
  - HDFS 读写数据流程
  - - HDFS写数据流程
    - HDFS读数据流程
  - 副本节点选择
  - 网络拓扑节点距离计算
  - 机架感知(副本存储节点选择)
  - Name Node和Secondary Name Node
  - - Name Node中的元数据是存储在哪里的
    - Name Node 和Secondary Name Node 工作机制
    - Name Node 和Secondary Name Node 工作机制详解
  - 集群安全模式(什么是集群的安全模式)
  - DataNode工作机制
  - 如何保证数据的完整性
- MapReduce
- - MapReduce概述
  - MapReduce优缺点
  - MapReduce核心思想
  - MapReduce进程
  - 常用数据序列化类型
  - MapReduce编程规范
  - Hadoop 序列化
  - - 概述
    - 自定义bean对象实现序列化接口（Writable）
  - 切片与MapTask并行度决定机制
  - FileInputFormat切片机制
  - FileInputFormat切片机制流程
  - CombineTextInputFormat切片机制
  - KeyValueTextInputFormat
  - NLineInputFormat
  - MapReduce工作流程
  - Shuffle机制
  - WritableComparabl
  - Combiner合并
  - MapTask工作机制
  - ReduceTask工作机制
  - mapTask和reduceTask之间如何衔接
  - Hadoop序列化和反序列化及自定义bean对象实现序列化?
  - 数据切片与MapTask并行度决定机制
  - 计算切片大小的公式
  - Hadoop 数据压缩
  - MR支持的压编码
  - 压缩方式
- YARN
- - Yarn概述
  - Yarn 架构
  - - Resource Manager
    - Node Manager
    - Application Master
    - Container
  - YARN 工作机制
  - YARN工作流程
  - - 作业提交阶段
    - 作业初始化阶段
    - 任务分配阶段
    - 任务运行阶段
    - 作业完成阶段
  - 资源调度器
  - YARN通信协议
Zookeeper（完结！）
- Zookeeper概述
- Zookeeper 工作机制
- Zookeeper特点
- Zookeeper文件系统
- Zookeeper集群⻆⾊
- - - Leader
    - Follower
    - Observer
- Zookeeper中的zNode是什么样的结构
- Zookeeper中zNode节点的类型
- Stat中保存了哪些数据
- Zookeeper 定义了几种权限
- Zookeeper的watch机制
- ZAB协议
- Chroot特性
- 监听器原理
- Leader 选举机制
- zookeeper是如何保证事务的顺序一致性的
- zookeeper节点宕机如何处理？
- Zookeeper对节点的watch监听通知为什么不是永久的
- Zookeeper应用场景 (需要了解)
- - 数据发布/订阅
  - 负载均衡
  - Zookeeper命名服务(文件系统)
  - Zookeeper分布式协调/通知
  - Zookeeper集群管理(文件系统.通知机制)
  - Master选举
  - Zookeeper分布式锁(文件系统、通知机制)
  - Zookeeper队列（文件系统、通知机制）
Kafka（完结！）
- 什么是kafka
- 消息模型
- Kafka 都有哪些特点？
- Kafka 的设计架构
- Kafka工作流程及文件存储机制
- Kafka 高效文件存储的特点
- 分区
- 副本
- leader副本挂掉后，如何选举新副本？
- 如何保证数据的可靠性
- ISR
- ACK应答机制
- 故障处理
- 消费方式
- 分区分配策略
- - Range Assignor
  - Round Robin Assignor
- offset的维护
- Zookeeper在Kafka中的作用
- Kafka中是怎么体现消息顺序性的？
- Kafka中的分区器、序列化器、拦截器是否了解？它们之间的处理顺序是什么？
Hive（完结！）
- 什么是hive
- Hive的组成部分
- Hive的优缺点
- Hive的UDF、UDAF、UDTF函数有什么区别
- Hive 索引（不推荐使用）
- 导入数据的常用发方法
- HSQL转换为Map Reduce的过程
- 提交一条SQL到Hive后，Hive的执行流程是怎样的？
- Hive的两张表关联，使用Map Reduce怎么实现？
- Hive的表存储模型有哪些
- 分区表和分桶表的区别
- Hive内部表和外部表的区别？
- Hive压缩格式
- Hive 中的文件存储格式；
- Hive有哪些保存元数据的方式，有什么特点
- hive中 Sort By，Order By，Cluster By，Distrbute By各代表什么意思？
- Hive的优化
Flume（完结！）
- 基础架构
- Flume的使用场景
- Flume与Kafka的选取
- Flume Agent的内部原理
- Flume的事务机制
- Flume采集数据会丢失吗
- flume管道内存，flume宕机了数据丢失怎么解决
- 简单介绍下Flume的参数调优
Sqoop（待总结！）
HBASE（完结！）
- Hbase 和 hive 的区别
- Hbase特点
- Hbase 架构及基本组件
- 基本概念
- Hbase 中的角色
- 读数据流程
- 写数据流程
- HMaster宕机的时候,哪些操作还能正常工作
- Hbase 和 hive 有什么区别hive 与 hbase 的底层存储是什么？hive是产生的原因是什么？habase是为了弥补hadoop的什么缺陷？
- 直接将时间戳作为行健，在写入单个 region 时候会发生热点问题，为什么呢？
- 解释下 hbase 实时查询的原理
- Hbase中的Memstore
- Memstore Flush触发机制
- Memstore Flush执行流程
- 数据合并过程
- HBase寻址机制
- HBase 适用场景
- RowKey设计原则
- 描述HBase中scan和get的功能以及实现的异同
- HBase中scan对象的setCache和setBatch方法的使用？
- HBase中一个cell的结构
- HBase中compact用途是什么
- 每天百亿数据存入HBase，如何保证数据的存储正确和在规定的时间里全部录入完毕，不残留数据？
- Hbase 优化方式
- HRegionServer宕机如何处理？
- 如何提高HBase客户端的读写性能
- HBase在进行模型设计时重点在什么地方？一张表中定义多少个Column Family最合适？为什么？
- 直接将时间戳作为行健，在写入单个region 时候会发生热点问题，为什么呢？
- 如何解决HBase中region太小和region太大带来的冲突？
- HBase过滤器（待总结！）
Spark（待总结！）
- a
- a
- a
- a
- a
Flink(待学习)

Java（待补充！）

1. 基础

Java关键字

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，声明布尔类型的关键字
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++)和自减运算符（–）。
++ 和 - - 运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。例如，当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”。

&和&&的区别

& 有两个作用，分别是位与和逻辑与

&& 就是逻辑与

作为逻辑与， & 和 && 分别表示长路与和短路与

长路与 两侧，都会被运算

短路与 只要第一个是false，第二个就不进行运算了

continue、break 和 return 的区别是什么？

continue ：指跳出当前的这一次循环，继续下一次循环。
break：指跳出整个循环体，继续执行循环下面的语句。
return 用于跳出所在方法，结束该方法的运行。return 一般有两种用法：
- return ：直接使用 return 结束方法执行，用于没有返回值函数的方法
- return value ：return 一个特定值，用于有返回值函数的方法

heap和stack有什么区别

heap: 堆
stack: 栈 (在一些书籍里，会被翻译为堆栈，实际上指的就是单纯的这个栈)
存放的内容不一样：

heap: 是存放对象的
stack: 是存放基本类型(int, float, boolean 等等)、引用(对象地址)、方法调用

存取方式不一样：

heap: 是自动增加大小的，所以不需要指定大小，但是存取相对较慢
stack: 是固定大小的，并且是FILO 先入后出的顺序，并且存取速度比较快

静态方法为什么不能调用非静态成员?

静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。
在类的非静态成员不存在的时候静态成员就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作

静态方法和实例方法的区别

调用方式
1. 静态方法：
  可以直接通过类名.方法名的方式进行方法调用
2. 非静态方法：
  必须通过对象的实例进行方法调用
访问类成员是否存在限制
静态方法在访问本类的成员时，只允许访问静态成员（静态成员和静态方法），不允许访问实例成员（成员变量和实例方法），而实例方法不存在这个限制

静态变量和实例变量的区别

静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个；静态变量可以实现让多个对象共享同一个变量。

实例变量必须依存于某一实例，创建对象的实例通过对象的实例才能访问到它。

基本数据类型

所有整型包装类对象之间值的比较，全部使用 equals 方法比较。

八种基本数据类型

数字类型
1. 整数型： byte，short，int ，long
2. 浮点型： float，double
字符类型
1. char
布尔类型
1. Boolean

八种基本数据类型的默认值以及所占空间的大小如下：

基本类型	位数	字节	默认值	取值范围
byte	8	1	0	-128 ~ 127
short	16	2	0	-32768 ~ 32767
int	32	4	0	-2147483648 ~ 2147483647
long	64	8	0L	-9223372036854775808~9223372036854775807
char	16	2	‘u0000’	0 ~ 65535
float	32	4	0f	1.4E-45 ~ 3.4028235E38
double	64	8	0d	4.9E-324 ~ 1.7976931348623157E308
boolea	1		false	true、false

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

基本类型和包装类型的区别

1.包装类型不赋值就是 null ，而基本类型有默认值且不是 null。
2. 包装类型可用于泛型，而基本类型不可以。
3. 基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。
4. 相比于对象类型，基本数据类型占用的空间非常小。

包装类型的缓存机制

自动装箱和拆箱

什么是自动拆装箱？

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

成员变量和局部变量的区别

语法形式：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
存储方式：从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
生存时间：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
默认值：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

对象的相等和引用相等的区别

对象的相等一般比较的是内存中存放的内容是否相等。
引用相等一般比较的是他们指向的内存地址是否相等。

类的构造方法的作用是什么?

构造方法是一种特殊的方法，主要用于完成对象的初始化工作。
一个类中默认有一个无参构造，如果自己添加一个类的构造器时，java 便不再添加默认的无参构造方法

构造器的特点，是否可以重写（override）

名字与类名相同
没有返回值，不能使用void声明构造函数
生成类的对象时自动执行，无需调用

构造方法不能被重写（override），但是可以重载（overload），一个类中可以有多个构造函数的情况，也就构成了构造器重载。

接口和抽象类有什么共同点和区别

相同点:

都不可被实例化
接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化

不同点:

抽象类中的方法可以有方法体，接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能有静态代码块以及静态方法，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，一个类可以实现多个接口。
接口只有定义，不能有方法的实现，抽象类可以有定义与实现
接口强调特定功能的实现，而抽象类强调所属关系。
接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。

深拷贝和浅拷贝区别了解吗？什么是引用拷贝？

深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。
浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。
引用拷贝：就时两个不同的引用指向同一个对象

== 和 equals 的区别是什么

基本数据类型 : 比较的是他们的值是否相等
引用数据类型 : 比较的是引用的地址是否相同\

因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

equals

用来比较两个对象是否相等
两个对象的内容是否相等

equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals()方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals()方法。

switch 是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch 可以作用在 byte，short，int，String，Enum(枚举) 上，但是不能作用在long上面

注: switch 作用在String上从JDK1.7开始支持，实质是编译时将字符串替换为了其对应的hash值

Hash Code有什么用？

Hash Code() 的作用是获取哈希码（int 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

Hash Code 存在的原因

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hash Code？

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hash Code 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hash Code 值作比较，如果没有相符的 hash Code，HashSet 会假设对象没有重复出现。但是如果发现有相同 hash Code 值的对象，这时会调用 equals() 方法来检查 hash Code 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

Hash Code() 和 equals()都是用于比较两个对象是否相等。

为什么要同时提供 hash code 和 equals这两个方法

hash code：性能高，只需要计算对象的哈希值

equals：可靠性高

因为在一些容器中比如：hash map , hash set 中，有了hash code 后，判断元素是否在对应的容器中的效率会比较高。

如果两个对象的hash Code 值相等，那这两个对象不一定相等（哈希碰撞）。
如果两个对象的hash Code 值相等并且equals()方法也返回 true，我们才认为这两个对象相等。
如果两个对象的hash Code 值不相等，我们就可以直接认为这两个对象不相等。

为什么两个对象的hash code 值他们也不一定相等

因为 hash code 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值，越糟糕的哈希算法越容易碰撞（指的是不同的对象得到相同的hash code）

为什么重写equals 方法时必须重写hash code 方法

因为两个相同的对象的hash code 值必须相等，也就是说如果equals 方法判断两个对象相等，那这两个对象的hash code 值也要相等。
如果重写 equals 方法时没有重写hash code 方法的话就会导致equals 方法判断时相等的两个对象他们的hash code 不相同

总结：

equals 方法判读两个对象是相等的，那这两个对象的hash code 值也要相等
两个对象有相同的hash code 值，他们有不一定是相等的（哈希碰撞）

数组有没有length()这个方法? String有没有length()这个方法？

数组获取长度的手段是 .length 属性
String获取长度的手段是 length()方法
集合获取长度的手段是 size()方法
文件获取长度的手段是 length()方法

可变字符串

可变字符串在追加，删除，修改，插入和拼接等操作不会产生新的对象。
String Buffer 和 String Builder
Java 提供了两个可变字符串类 string buffer 和 string builder ，中文翻译为字符串缓冲区

String Buffer 是线程安全的，他的方法是支持线程同步，线程同步会操作串行顺序执行，在单线程环境下会影响效率。
StringBuilder 是 StringBuffer单线程版本，它不是线程安全的，但它的执行效率很高。

StringBuffer和 StringBuilder 具有完全相同的 API ，即构造方法和方法等内容一样。

线程同步是一个多线程概念，就是当多个线程访问一个方法时，只能由一个优先级别高的线程先访问，在访问期间会锁定该方法，其他线程只能等到它访问完成释放锁，才能访问。

String, String Buffer 和 String Builder 的区别是什么?

可变性：
- Stirng 是不可变的，内部采用的是final数组的方式来实现存储的所以string 是不可被修改的，如果使用字符串拼接的时候是两个不同的空间
- String Builder 与 String Buffer 都继承自 Abstract String Builder 类，在 Abstract String Builder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，使用字符串拼接时都是使用的是append()方法在原有的基础上进行拼接的
线程安全性：
- String 中的对象是不可变的，可以理解为常量，线程安全
- String Buffer 是线程安全的
- String Builder 是线程不安全的
性能：
- 每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。String Buffer 每次都会对 String Buffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 String Buffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
总结：
- 操作少量的数据: 适用 String
- 单线程操作字符串缓冲区下操作大量数据: 适用 String Builder
- 多线程操作字符串缓冲区下操作大量数据: 适用 String Buffer
- 所以 String< String Buffer < String Builder

Stirng为什么是不可变的

String 中使用final关键字来修饰字符数组保存字符串，
使用final关键字修饰的类不可以被继承，修饰的方法不可以被重写，修饰的变量是基本数据类型值不可被再次修改，修饰的变量是引用数据类型则不能再指向其他对象。
主要原因如下几点：

板寸字符串的数组被final修饰且为私有，并且string 类没有提供/暴露修改这个字符串的方法
String 类被final 修饰导致其不可被继承，进而避免了子类破坏string不可变

String equals 和 obj equals 的区别

String 中的equals 方法是被重写过的，比较的是string 字符串的值是否相等。

Obj 中的equals 方法比较的是对象的内存地址

字符串常量池的作用

是JVM为了提升性能和减少内存消耗针对字符串（string类）专门开辟的一块区域，主要目的是为了字符串的重复创建

String str="i"与 String str=new String(“i”)一样吗？

不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。

字符串池

在前面的学习过程中细心的读者可能会发现，前面的示例代码中获得字符串对象时都是直接使用字符串常量，但Java中对象是使用new关键字创建，字符串对象也可以使用new关键字创建，代码如下：

String s9 = "Hello"; // 字符串常量

String s7 = new String("Hello"); //使用new关键字创建

使用new关键字与字符串常量都能获得字符串对象，但它们之间有一些区别。先看下面代码运行结果：

String s7 = new String("Hello"); ① 

String s8 = new String("Hello"); ② 

String s9 = "Hello"; ③ 

String s10 = "Hello"; ④ 

System.out.printf("s7 == s8 : %b%n", s7 == s8); 

System.out.printf("s9 == s10: %b%n", s9 == s10); 

System.out.printf("s7 == s9 : %b%n", s7 == s9); 

System.out.printf("s8 == s9 : %b%n", s8 == s9);

输出结果：

s7 == s8 : false 

s9 == s10: true 

s7 == s9 : false 

s8 == s9 : false

==运算符比较的是两个引用是否指向相同的对象，从上面的运行结果可见，s7和s8指的是不同对象，s9和s10指向的是相同对象。

这是为什么？Java中的不可变字符串String常量，采用字符串池（StringPool）管理技术，字符串池是一种字符串驻留技术。采用字符串常量赋值时（见代码第③行），如图所示，会字符串池中查找"Hello"字符串常量，如果已经存在把引用赋值给s9，否则创建"Hello"字符串对象，并放到池中。根据此原理，可以推定s10与s9是相同的引用，指向同一个对象。但此原理并不适用于new所创建的字符串对象，代码运行到第①行后，会创建"Hello"字符串对象，而它并没有放到字符串池中。代码第②行又创建了一个新的"Hello"字符串对象，s7和s8是不同的引用，指向不同的对象。

										字符串池

String s=new String(“xyz”);创建了几个字符串对象？

简洁答案:
两个对象，一个是静态存储区的"xyz",一个是用new创建在堆上的对象。

标准答案:
两个，一个是字符串字面量"xyz"所对应的、存在于全局共享的常量池中的实例，另一个是通过new String(String)创建并初始化的、内容（字符）与"xyz"相同的实例。考虑到如果常量池中如果有这个字符串，就只会创建一个。同时在栈区还会有一个对new出来的String实例的s。

final 在 java 中有什么作用？

final 修饰的类叫最终类，该类不能被继承。
final 修饰的方法不能被重写。
final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

重载（Overload）和重写（Override）的区别

重载：
(方法名相同,参数列表不同) 构成方法的重载
重载就是同⼀个类中多个同名⽅法根据不同的参数来执⾏不同的逻辑处理。⽅法名必须相同，参数列表不同，⽅法返回值和访问修饰符可以不同。

重写：
发生在继承中, 子类重写父类的公开方法
⼦类对⽗类⽅法的重新改造，外部样⼦不能改变

是⼦类对⽗类允许访问的⽅法的实现过程进⾏重新编写。(子类重写父类的公开方法)

返回值类型、⽅法名、参数列表必须相同，抛出的异常范围⼩于等于⽗类，访问修饰符范围⼤于等于⽗类。
如果⽗类⽅法访问修饰符为 private/final/static 则⼦类就不能重写该⽅法，但是被 static 修饰的⽅法能够被再次声明。
构造⽅法⽆法被重写

用于存放编译器生成的各种字面量(Literal)和符号引用(Symbolic References)。

由于不同的Class 文件中包含的常量的个数是不固定的，所以在Class 文件的常量池

入口处会设置两个字节的常量池容量计数器，记录了常量池中常量的个数。

面试题总结

文章目录

相关文章