JAVA面试汇总第一章基础强化

最新推荐文章于 2022-09-28 15:58:12 发布

办公模板库素材蛙

最新推荐文章于 2022-09-28 15:58:12 发布

阅读量1.6k

点赞数 2

分类专栏： java 教程文章标签： java 开发语言面试

本文链接：https://blog.csdn.net/fegus/article/details/124496154

版权

教程同时被 2 个专栏收录

1193 篇文章 229 订阅

订阅专栏

java

564 篇文章 136 订阅

订阅专栏

如何轻松获得 Offer

你好，我是王磊，某上市公司技术研发经理，前奇虎 360 员工，有着 10
余年的编程工作经验，目前主要负责新员工技术面试和构建企业技术架构的相关事宜。随着面试过的人数增加，我发现面试者们暴露出了技术方面的很多问题，为了让更多面试者少走一些弯路，也为了让企业能招到合适的技术人才，于是就诞生了这个专栏。

为了写好这个专栏内容，我先后拜访了一二十家互联网公司，与不同的面试官和面试者进行面对面探讨，深入了解了企业对于面试者的要求和常见的 Java
面试题型。之后我花了大半年的时间，结合自己 4 年多作为面试官的经历，把这些内容整理成文，用大约 10 万字的内容对 Java 的核心知识点和常见的 500
多道面试题，做了详细的介绍，也就是本专栏中你所看到的全部内容，希望对你能有所帮助。

为什么要学这个专栏内容？

「因为它能为你赢得面试的主动权，让你获得更多的 Offer。」

从业十多年，我从面试者变成面试官，在 Java 面试上积累了比较丰富的经验。

其实，很多面试者在搜集面试资料的时候都踩过一些“坑”，你是不是也遇到过：

免费搜索的面试题，内容 不全面 ，这就算了，有时候答案都 不准确 ；
很多培训机构提供的面试宝典内容虽然不少，但 深度不够 ，且面试题 过于老旧 脱离了企业实际需要；
还有很多付费的面试题存在滥竽充数，提供了很多没有价值的面试题， 钱花了，干货没学到 ；
市面上大部分面试题只讲了基础概念， 没有提供题目解析和示例代码 ，不利于读者真正的掌握背后的原理，只能死记硬背，且容易忘记。

为了规避这些“坑”，我跑了很多家互联网公司，来确认 Java
面试中实际考察的高频知识点和常见题型。可是有了第一手素材后，我要如何让大家真正从我的讲解中学到干货、用到实处呢？

经过反复验证，我才设计了如下的内容讲述模式。

第一，500+ 面试题详解。

如果你是还没走入职场的新人，我会为你提供完整的 Java 技术栈讲解，以及最新、最全、最实用的 500 多道 Java 面试题详解。

第二，10万字 Java 核心知识点梳理。

本专栏的每一篇内容，都采用的是「核心知识点 + N 道相关面试题」的模式，让你不单能应付面试，还能学到更多的 Java 核心知识。

第三，技术、面试搭配平衡，不但让你学到心里，还助你展示出来。

面对目前技术市场的相对冷淡和一个职位多个应聘者竞争的现状，面试者们只有掌握更多 Java 核心技能和面试理论知识，才能在众多面试者中脱颖而出。

本专栏每篇文章大致分为两个部分： Java 核心点介绍 + 相关面试题详解
，这两部分内容相辅相成，前面的核心知识点介绍让后面的面试题更容易理解，后面的面试题加深了读者对于 Java
核心点的掌握。如此一来，让你所学及所用，不仅能够应付面试，更能学习到更多有价值的 Java 技术点，让你在面试中和工作中都能展示的更加出色。

专栏大纲

本专栏分为七大部分，共计 37 讲，约 10 万字。

第一部分：Java 基础强化

这部分包含 7 篇文章，我会从 Java 最基础的内容讲起。有最常见的 String 面试题从表象到原理的深入讲解；还有 Java 8
中新特性的介绍，比如时间和日期模块，让你使用更简洁和优化的方式写出更完美的代码；还有我们日常用的很多包装类不为人知的有趣现象和知识盲点介绍；还有数组以及算法的介绍，虽然基础但容易被面试者忽略和容易出错的问题……

第二部分：各种类和克隆

这部分包含 4 篇文章，除了会深入讲解 Java
中的各种类和接口的相关内容，还会深入讲解浅克隆和深克隆的各种实现方式，以及配合各种图片让你更形象地理解深/浅克隆的本质。

第三部分：数据结构和队列

这部分包含 4
篇文章，对面试中必考的集合，除了相关的面试题讲解，更要理清各种集合之间的关系，创建集合之间的联系，这样才能对集合的整体理解做到心中有数。我使用了归纳法和各种关系图，帮你理清思路，打通你的“任督二脉”。其中还有队列的内容，可能开发者经常会听到，但实际的工作中使用的较少，本部分内容也会带你玩转这些数据结构，让你在面试中能够应对自如。

第四部分：反射和动态代理

这部分会帮你理清反射和动态代理的关系，并提供很多实际使用的场景，让你更好地使用到反射和动态代理，当然这部分也会为你提供各种形式反射和动态代理的实现方式，让你可以随心所欲的使用它们。这部分内容还提供了
IO 的相关知识，并提供详细的示例和原理分析，也会试着编写一个简单 Socket 服务器。

第五部分：多线程编程

这部分包含 7 篇文章，讲述了包含 Java 8 在内的 8 种线程池，以及线程池的正确使用姿势，还有死锁代码的编写和死锁的解决方案。本部分还会介绍
Java 中的各种锁，以及它们的区别和使用场景，还会介绍 CAS 和著名的 ABA 问题的解决方案，还有多线程中的各种高频面试题。

第六部分：Java 热门框架和分布式消息队列

这部分包含 6 篇文章，从 Spring 到最近比较热门的微服务框架 SpringBoot，还有国内常用的 Mybatis 和 Java
技术栈中其他常用的框架，比如 Dubbo 和 Zookeeper，还有分布式消息队列 RabbitMQ 和 Kafka 的介绍和面试题汇总。

第七部分：Java 高手进阶

本部分内容包含 6 篇文章，可谓 Java 技术栈最实用的面试补充“大礼包”，有设计模式的面试题汇总；还有 DBA 级别的 MySQL 和 Redis
面试题汇总；还有成为高手必懂的 JVM 和算法的面试题汇总；最后回到本专栏的主题内容，提供了 Java
最容易出错的面试题汇总作为收束篇目，助你稳健地拿到想要的 Offer。

以下是这个专栏的知识树：

avatar

专栏寄语

希望通过本专栏的学习，你不但能拿到 Offer、取得更好的工作，还能建立一个完整的 Java
知识体系，让你学到的所有内容都能转化为实际的生产力，帮你在工作中取得不凡的成绩。并且希望明白原理后的你，能把这些记忆一直存储在自己大脑中，这样它将会成为你一辈子的财富。

我坚信：持续学习才是最有价值的投资，让我们一起行动起来，一起来做这件最有价值的事情。

最后，预祝每一位学习本专栏的朋友，都能找到一份自己理想中的工作。

Java 程序是如何执行的

了解任何一门语言的精髓都是先俯览其全貌，从宏观的视角把握全局，然后再深入每个知识点逐个击破，这样就可以深入而快速的掌握一项技能。同样学习 Java
也是如此，本节就让我们先从整体来看一下 Java 中的精髓。

Java 介绍

Java 诞生于 1991 年，Java 的前身叫做
Oak（橡树），但在注册商标的时候，发现这个名字已经被人注册了，后来团队的人就在咖啡馆讨论这件事该怎么办，有人灵机一动说叫 Java
如何，因为当时他们正在喝着一款叫做 Java 的咖啡。就这样，这个后来家喻户晓的名字，竟以这种“随意”的方式诞生了，并一直沿用至今。

Java 发展历程：

1990，Sun 成立了“Green Team”项目小组
1991，Java 语言前身 Oak（橡树）诞生
1995，Oak 语言更名为 Java
1996，Java 1.0 发布
1997，Java 1.1 发布
1998，Java 1.2 发布
2000，Java 1.3 发布
2000，Java 1.4 发布
2004，Java 5 发布
2006，Java 6 发布
2011，Java 7 发布
2014，Java 8 发布
2017，Java 9（非长期支持版）发布
2018.03，Java 10（非长期支持版）发布
2018.09，Java 11（长期支持版）发布
2019.03, Java 12（非长期支持版）发布

注：长期支持版指的是官方发布版本后的一段时间内，通常以“年”为计数单位，会对此版本进行持续维护和升级。

版本发布时间

Java 10 之后，官方表示每半年推出一个大版本，长期支持版本（LTS）每三年发布一次。

Java 和 JDK 的关系

JDK（Java Development Kit）Java 开发工具包，它包括：编译器、Java 运行环境（JRE，Java Runtime
Environment）、JVM（Java 虚拟机）监控和诊断工具等，而 Java 则表示一种开发语言。

Java 程序是怎么执行的？

我们日常的工作中都使用开发工具（IntelliJ IDEA 或 Eclipse 等）可以很方便的调试程序，或者是通过打包工具把项目打包成 jar 包或者
war 包，放入 Tomcat 等 Web 容器中就可以正常运行了，但你有没有想过 Java 程序内部是如何执行的？

其实不论是在开发工具中运行还是在 Tomcat 中运行，Java 程序的执行流程基本都是相同的，它的执行流程如下：

1. 先把 Java 代码编译成字节码，也就是把 .java 类型的文件编译成 .class 类型的文件。这个过程的大致执行流程：Java 源代码 -> 词法分析器 -> 语法分析器 -> 语义分析器 -> 字节码生成器 -> 最终生成字节码，其中任何一个节点执行失败就会造成编译失败；
2. 把 class 文件放置到 Java 虚拟机，这个虚拟机通常指的是 Oracle 官方自带的 Hotspot JVM；
3. Java 虚拟机使用类加载器（Class Loader）装载 class 文件；
4. 类加载完成之后，会进行字节码校验，字节码校验通过之后 JVM 解释器会把字节码翻译成机器码交由操作系统执行。但不是所有代码都是解释执行的，JVM 对此做了优化，比如，以 Hotspot 虚拟机来说，它本身提供了 JIT（Just In Time）也就是我们通常所说的动态编译器，它能够在运行时将热点代码编译为机器码，这个时候字节码就变成了编译执行。

Java 程序执行流程图如下：

avatar

Java 虚拟机是如何判定热点代码的？

Java 虚拟机判定热点代码的方式有两种：

基于采样的热点判定

主要是虚拟机会周期性的检查各个线程的栈顶，若某个或某些方法经常出现在栈顶，那这个方法就是“热点方法”。这种判定方式的优点是实现简单；缺点是很难精确一个方法的热度，容易受到线程阻塞或外界因素的影响。

基于计数器的热点判定

主要就是虚拟机给每一个方法甚至代码块建立了一个计数器，统计方法的执行次数，超过一定的阀值则标记为此方法为热点方法。

Hotspot 虚拟机使用的基于计数器的热点探测方法。它使用了两类计数器：方法调用计数器和回边计数器，当到达一定的阀值是就会触发 JIT 编译。

方法调用计数器：在 client 模式下的阀值是 1500 次，Server 是 10000 次，可以通过虚拟机参数：
-XX:CompileThreshold=N 对其进行设置。但是JVM还存在热度衰减，时间段内调用方法的次数较少，计数器就减小。

回边计数器：主要统计的是方法中循环体代码执行的次数。

由上面的知识我们可以看出， 要想做到对 Java 了如指掌，必须要好好学习 Java 虚拟机 ，那除了 Java
虚拟机外，还有哪些知识是面试必考，也是 Java 工程师必须掌握的知识呢？

1. Java 基础中的核心内容

字符串和字符串常量池的深入理解、Array 的操作和排序算法、深克隆和浅克隆、各种 IO 操作、反射和动态代理（JDK 自身动态代理和 CGLIB）等。

2. 集合

集合和 String
是编程中最常用的数据类型，关于集合的知识也是面试备考的内容，它包含：链表（LinkedList）、TreeSet、栈（Stack）、队列（双端、阻塞、非阻塞队列、延迟队列）、HashMap、TreeMap
等，它们的使用和底层存储数据结构都是热门的面试内容。

3. 多线程

多线程使用和线程安全的知识也是必考的面试题目，它包括：死锁、6
种线程池的使用与差异、ThreadLocal、synchronized、Lock、JUC（java.util.concurrent包）、CAS（Compare
and Swap）、ABA 问题等。

4. 热门框架

Spring、Spring MVC、MyBatis、SpringBoot

5. 分布式编程

消息队列（RabbitMQ、Kafka）、Dubbo、Zookeeper、SpringCloud 等。

6. 数据库

MySQL 常用引擎的掌握、MySQL 前缀索引、回表查询、数据存储结构、最左匹配原则、MySQL 的问题分析和排除方案、MySQL 读写分离的实现原理以及
MySQL 的常见优化方案等。 Redis 的使用场景、缓存雪崩和缓存穿透的解决方案、Redis 过期淘汰策略和主从复制的实现方案等。

7. Java 虚拟机

虚拟机的组成、垃圾回收算法、各种垃圾回收器的区别、Java 虚拟机分析工具的掌握、垃圾回收器的常用调优参数等。

8. 其他

常用算法的掌握、设计模式的理解、网络知识和常见 Linux 命令的掌握等。

值得庆幸的是以上所有内容都包含在本专栏中，接下来就让我们一起学习，一起构建 Java 的认知体系吧!

你不知道的基本数据类型和包装类 + 面试题

基本数据类型

Java 基本数据按类型可以分为四大类：布尔型、整数型、浮点型、字符型，这四大类包含 8 种基本数据类型。

布尔型：boolean
整数型：byte、short、int、long
浮点型：float、double
字符型：char

8 种基本类型取值如下：

数据类型	代表含义	默认值	取值	包装类
boolean	布尔型	false	0(false) 到 1(true)	Boolean
byte	字节型	(byte)0	﹣128 到 127	Byte
char	字符型	‘\u0000’(空)	‘\u0000’ 到 ‘\uFFFF’	Character
short	短整数型	(short)0	- $2^{15}$ 到 $2^{15}$
﹣1	Short
int	整数型	0	﹣ $2^{31}$ 到 $2^{31}$ ﹣1	Integer
long	长整数型	0L	﹣ $2^{63}$ 到 $2^{63}$ ﹣1	Long
float	单浮点型	0.0f	1.4e-45 到 3.4e+38	Float
double	双浮点型	0.0d	4.9e-324 到 1.798e+308	Double

除 char 的包装类 Character 和 int 的包装类 Integer
之外，其他基本数据类型的包装类只需要首字母大写即可。包装类的作用和特点，本文下半部分详细讲解。

我们可以在代码中，查看某种类型的取值范围，代码如下：

public static void main(String[] args) {
    // Byte 取值：-128 ~ 127
    System.out.println(String.format("Byte 取值：%d ~ %d", Byte.MIN_VALUE, Byte.MAX_VALUE));
    // Int 取值：-2147483648 ~ 2147483647
    System.out.println(String.format("Int 取值：%d ~ %d", Integer.MIN_VALUE, Integer.MAX_VALUE));
}

包装类型

我们知道 8 种基本数据类型都有其对应的包装类，因为 Java
的设计思想是万物既对象，有很多时候我们需要以对象的形式操作某项功能，比如说获取哈希值（hashCode）或获取类（getClass）等。

那包装类特性有哪些？

1. 功能丰富

包装类本质上是一个对象，对象就包含有属性和方法，比如 hashCode、getClass 、max、min 等。

2. 可定义泛型类型参数

包装类可以定义泛型，而基本类型不行。

比如使用 Integer 定义泛型，代码：

List<Integer> list = new ArrayList<>();

如果使用 int 定义就会报错，代码：

List list = new ArrayList<>();  // 编译器代码报错

3. 序列化

因为包装类都实现了 Serializable 接口，所以包装类天然支持序列化和反序列化。比如 Integer 的类图如下：

Integer 类图

4. 类型转换

包装类提供了类型转换的方法，可以很方便的实现类型之间的转换，比如 Integer 类型转换代码：

String age = "18";
int ageInt = Integer.parseInt(age) + 2;
// 输出结果：20
System.out.println(ageInt);

5. 高频区间的数据缓存

此特性为包装类很重要的用途之一，用于高频区间的数据缓存，以 Integer 为例来说，在数值区间为 -128~127
时，会直接复用已有对象，在这区间之外的数字才会在堆上产生。

我们使用 == 对 Integer 进行验证，代码如下：

public static void main(String[] args) {
        // Integer 高频区缓存范围 -128~127
        Integer num1 = 127;
        Integer num2 = 127;
        // Integer 取值 127 == 结果为 true（值127 num1==num2 => true）
        System.out.println("值127 num1==num2 => " + (num1 == num2));
        Integer num3 = 128;
        Integer num4 = 128;
        // Integer 取值 128 == 结果为 false（值128 num3==num4 => false）
        System.out.println("值128 num3==num4 => " + (num3 == num4));
    }

从上面的代码很明显可以看出，Integer 为 127 时复用了已有对象，当值为 128 时，重新在堆上生成了新对象。

为什么会产生高频区域数据缓存？我们查看源码就能发现“线索”，源码版本 JDK8，源码如下：

public static Integer valueOf(int i) {
  if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
  return new Integer(i);
}

由此可见，高频区域的数值会直接使用已有对象，非高频区域的数值会重新 new 一个新的对象。

各包装类高频区域的取值范围：

Boolean：使用静态 final 定义，就会返回静态值
Byte：缓存区 -128~127
Short：缓存区 -128~127
Character：缓存区 0~127
Long：缓存区 -128~127
Integer：缓存区 -128~127

包装类的注意事项

int 的默认值是 0，而 Integer 的默认值是 null。
推荐所有包装类对象之间的值比较使用 equals() 方法，因为包装类的非高频区数据会在堆上产生，而高频区又会复用已有对象，这样会导致同样的代码，因为取值的不同，而产生两种截然不同的结果。代码示例：

public static void main(String[] args) {
// Integer 高频区缓存范围 -128~127
Integer num1 = 127;
Integer num2 = 127;
// Integer 取值 127 == 结果为 true（值127 num1num2 => true）
System.out.println("值127 num1num2 => " + (num1 == num2));
Integer num3 = 128;
Integer num4 = 128;
// Integer 取值 128 == 结果为 false（值128 num3num4 => false）
System.out.println("值128 num3num4 => " + (num3 == num4));
// Integer 取值 128 equals 结果为 true（值128 num3.equals(num4) => true）
System.out.println("值128 num3.equals(num4) => " + num3.equals(num4));
}
Float 和 Double 不会有缓存，其他包装类都有缓存。
Integer 是唯一一个可以修改缓存范围的包装类，在 VM optons 加入参数：

-XX:AutoBoxCacheMax=666 即修改缓存最大值为 666 。

示例代码如下：

public static void main(String[] args) {
    Integer num1 = -128;
    Integer num2 = -128;
    System.out.println("值为-128 => " + (num1 == num2));
    Integer num3 = 666;
    Integer num4 = 666;
    System.out.println("值为666 => " + (num3 == num4));
    Integer num5 = 667;
    Integer num6 = 667;
    System.out.println("值为667 => " + (num5 == num6));
}

执行结果如下：

值为-128 => true
值为666 => true
值为667 => false

由此可见将 Integer 最大缓存修改为 666 之后，667 不会被缓存，而 -128~666 之间的数都被缓存了。

深入理解字符串 + 面试题

字符串介绍

字符串是程序开发当中，使用最频繁的类型之一，有着与基础类型相同的地位，甚至在 JVM（Java
虚拟机）编译的时候会对字符串做特殊的处理，比如拼加操作可能会被 JVM 直接合成为一个最终的字符串，从而到达高效运行的目的。

1 String 特性

String 是标准的不可变类（immutable），对它的任何改动，其实就是创建了一个新对象，再把引用指向该对象；
String 对象赋值之后就会在常量池中缓存，如果下次创建会判定常量池是否已经有缓存对象，如果有的话直接返回该引用给创建者。

2 字符串创建

字符串创建的两种方式：

String str = “laowang”;
String str = new String(“laowang”);

3 注意事项

查看下面代码：

String s1 = "laowang";
String s2 = s1;
String s3 = new String(s1);
System.out.println(s1 == s2);
System.out.println(s1 == s3);

输出结果：true、false。

为什么会这样？原因是 s3 使用 new String 时一定会在堆中重新创建一个内存区域，而 s2 则会直接使用了 s1
的引用，所以得到的结果也完全不同。

字符串的使用

1 字符串拼加

字符串拼加的几种方式：

String str = “lao” + “wang”;
String str = “lao”; str += “wang”;
String str = “lao”; String str2 = str + “wang”;

2 JVM 对字符串的优化

根据前面的知识我们知道，对于 String 的任何操作其实是创建了一个新对象，然后再把引用地址返回该对象，但 JVM 也会对 String
进行特殊处理，以此来提供程序的运行效率，比如以下代码：

String str = "hi," + "lao" + "wang";

经过 JVM 优化后的代码是这样的：

String str = "hi,laowang";

验证代码如下：

String str = "hi," + "lao" + "wang";
String str2 = "hi,laowang";
System.out.println(str == str2);

执行的结果：true。

这就说明 JVM 在某些情况下会特殊处理 String 类型。

3 字符串截取

字符串的截取使用 substring() 方法，使用如下：

String str = "abcdef";
// 结果：cdef（从下标为2的开始截取到最后，包含开始下标）
System.out.println(str.substring(2));
// 结果：cd（从下标为2的开始截取到下标为4的，包含开始下标不包含结束下标）
System.out.println(str.substring(2,4));

4 字符串格式化

字符串格式化可以让代码更简洁更直观，比如，“我叫老王，今年 30
岁，喜欢读书”在这条信息中：姓名、年龄、兴趣都是要动态改变的，如果使用“+”号拼接的话很容易出错，这个时候字符串格式化方法 String.format()
就派上用场了，代码如下：

String str = String.format("我叫%s，今年%d岁，喜欢%s", "老王", 30, "读书");

转换符说明列表：

转换符	说明
%s	字符串类型
%d	整数类型（十进制）
%c	字符类型
%b	布尔类型
%x	整数类型（十六进制）
%o	整数类型（八进制）
%f	浮点类型
%a	浮点类型（十六进制）
%e	指数类型
%%	百分比类型
%n	换行符

5 字符对比

根据前面的知识我们知道，使用 String 和 new String 声明的对象是不同的，那有没有简单的方法，可以忽略它们的创建方式（有没有
new）而只对比它们的值是否相同呢？答案是肯定的，使用 equals() 方法可以实现，代码如下：

String s1 = "hi," + "lao" + "wang";
String s2 = "hi,";
s2 += "lao";
s2 += "wang";
String s3 = "hi,laowang";
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // true
System.out.println(s2.equals(s3)); // true

以上使用 equals 对比的结果都为 true。

如果要忽略字符串的大小写对比值可以使用 equalsIgnoreCase()，代码示例：

String s1 = "Hi,laowang";
String s2 = "hi,laowang";
System.out.println(s1.equals(s2)); // false
System.out.println(s1.equalsIgnoreCase(s2)); // true

s1.equals(s2) 执行的结果为：false，s1.equalsIgnoreCase(s2) 执行的结果为：true。

6 String、StringBuffer、StringBuilder

字符串相关类型主要有这三种：String、StringBuffer、StringBuilder，其中 StringBuffer、StringBuilder
都是可以变的字符串类型，StringBuffer 在字符串拼接时使用 synchronized 来保障线程安全，因此在多线程字符串拼接中推荐使用
StringBuffer。

StringBuffer 使用：

StringBuffer sf = new StringBuffer("lao");
// 添加字符串到尾部
sf.append("wang"); // 执行结果：laowang
// 插入字符串到到当前字符串下标的位置
sf.insert(0,"hi,"); // 执行结果：hi,laowang
// 修改字符中某个下标的值
sf.setCharAt(0,'H'); // 执行结果：Hi,laowang

StringBuilder 的使用方法和 StringBuffer 一样，它们都继承于 AbstractStringBuilder。

Java 中的运算符和流程控制 + 面试题

算术运算符

Java 中的算法运算符，包括以下几种：

算术运算符	名称	举例

| 加法 | 1+2=3

| 减法 | 2-1=1

| 乘法 | 2*3=6
/ | 除法 | 24/8=3
% | 求余 | 24%7=3
++ | 自增1 | int i=1;i++
– | 自减1 | int i=1;i–

我们本讲要重点讲的是 “++” 和 “–”，其他的算术运算符相对比较简单直观，本讲就不花精力去讲解了，之所以要把 “++” 和 “–”
单独拿出来讲，是因为在使用他们的时候有很多坑需要开发者注意，最重要的是 “++” 和 “–” 也是面试中高频出现的面试题。

先来看 “++” 的基本使用：

int i = 1;
int i2 = ++i; // ++i 相当于 i = 1+i;
System.out.println(i);  // 2
System.out.println(i2); // 2

++i 和 i++ 的区别

++i 先自加再赋值
i++ 先赋值再自加

比如：

int i = 0;
int i2 = i++;
int j = 0;
int j2 = ++j;
System.out.println("i2=" + i2);
System.out.println("j2=" + j2);

输出的结果：

i2=0
j2=1

代码解析：i++ 是先给 i2 赋值再自身 +1 ，所以 i2 等于0，而 ++j 是先自加等于 1 之后，再赋值给 j2，所以 j2 等于 1。

注意事项

++/-- 是非线程安全的，也就是说 ++/-- 操作在多线程下可能会引发混乱，例如下面代码：

new Thread() {
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            System.out.println("thread:" + this.getName() + ",count=" + (++count));
        }
    }
}.start();
new Thread() {
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            System.out.println("thread:" + this.getName() + ",count=" + (++count));
        }
    }
}.start();

执行的结果，如下图：

执行结果

如上图所示，每台机器的执行可能略有差距，但大多数情况下并不能给我们想要的真实值 200000。

原理分析

“++” 操作在多线程下引发混乱的原因：因为 ++ 操作对于底层操作系统来说，并不是一条 CPU 操作指令，而是三条 CPU
操作指令——取值、累加、存储，因此无法保证原子性，就会出现上面代码执行后的误差。

如何避免 ++/-- 操作在多线程下的“误差”？

方法一：++/-- 操作放在同步块 synchronized 中。
方法二：自己申明锁，把 ++/-- 操作放入其中。
方法三：使用 AtomicInteger 类型替代 int 类型。

最后，因为 – 的语法和 ++ 完全一致，所以 – 的操作，请参照上面的 ++ 语法。

条件运算符（三元运算符）

条件运算符（?:）也叫“三元运算符”。

语法：

布尔表达式 ? 表达式1 ：表达式2

运算过程：如果布尔表达式的值为 true，则返回 表达式 1 的值 ，否则返回 表达式 2 的值 。

例如：

String s = 3 > 1 ? "三大于一" : "三小于一";
System.out.println(s);

执行结果：三大于一。

流程控制

在 Java 语言中使用条件语句和循环结构来实现流程控制。

1 条件语句

条件语句的语法格式：

if(…) …

其中的条件判断必须使用括号括起来不能省略。

基础用法使用：

int i = 1;
if (i > 1) {
    System.out.println("i大于一");
} else if (i == 1) {
    System.out.println("i等于一");
} else {
    System.out.println("其他");
}

2 循环

while 当条件成立的时候执行下一条语句。

while 语法格式：

while(…) …

基本语法使用：

int i = 0;
  while (i < 3) {
  System.out.println(++i);
}

while 是先判断再决定是否执行，有可能一次也不执行，如果希望至少执行一次，可以使用 do/while。

do/while 语法格式：

do{…}while(…);

基本语法使用：

int i = 0;
do {
  System.out.println(++i);
} while (i < 3);

3 确定循环

for 循环是程序中最长使用的循环之一，它是利用每次迭代之后更新计数器来控制循环的次数。

for 语法格式：

for(int i=0;i<n;i++){ … }

基础语法使用：

for (int i = 0; i < 10; i++) {
    System.out.println("i=" + i);
}

for 循环中可使用关键字 continue，跳过后续操作，继续下一次迭代。

例如：

for (int i = 1; i < 4; i++) {
    if (i == 2) continue;
    System.out.println("i=" + i);
}

执行结果：

i=1
i=3

如结果所示，第二次循环就会跳过，执行下一次循环。

for 注意事项

在循环中检查两个浮点数是否相等要格外小心，例如下面代码：

public static void main(String[] args) {
    for (float i = 0; i != 1; i += 0.1) {
        System.out.println(i);
    }
}

循环永远不会停下来，由于舍入误差，因为 0.1 无法精确的用二级制表示，所以上面代码到 0.9000001 之后，会直接跳到 1.0000001，不会等于
1，所以循环就永远不会停下来。

4 多重选择

switch 的特点是可以判断多个条件，if 的特点是执行少量判断，它们两个刚好形成互补的关系。

switch 语法格式：

switch(…){ case 1: … break; … default: … break; }

switch 基础使用：

int i = 3;
switch (i) {
    case 1:
        System.out.println("等于1");
        break;
    case 2:
        System.out.println("等于2");
        break;
    case 3:
        System.out.println("等于3");
        break;
    default:
        System.out.println("等于其他");
        break;
}

可用于 case 的类型有：

byte、char、short、int
枚举
字符串（Java SE 7 新加入）

switch 注意事项

switch 使用时，每个选项最末尾一定不要忘记加 break 关键字，否则会执行多个条件。

案例：

int i = 1;
switch (i) {
    case 1:
        System.out.println("等于1");
    case 2:
        System.out.println("等于2");
    case 3:
        System.out.println("等于3");
    default:
        System.out.println("等于其他");
}

程序执行的结果：

等于1
等于2
等于3
等于其他

所以使用 switch 时，每个选项的末尾一定得加 break 关键字。

深入了解 Java 中的异常处理 + 面试题

在程序开发中，异常处理也是我们经常使用到的模块，只是平常很少去深究异常模块的一些知识点。比如，try-catch 处理要遵循的原则是什么，finally
为什么总是能执行，try-catch
为什么比较消耗程序的执行性能等问题，我们本讲内容都会给出相应的答案，当然还有面试中经常被问到的异常模块的一些面试题，也是我们本篇要讲解的重点内容。

异常处理基础介绍

先来看看 异常处理的语法格式 ：

try{ … } catch(Exception e){ … } finally{ … }

其中，

try ：是用来监测可能会出现异常的代码段。
catch ：是用来捕获 try 代码块中某些代码引发的异常，如果 try 里面没有异常发生，那么 catch 也一定不会执行。在 Java 语言中，try 后面可以有多个 catch 代码块，用来捕获不同类型的异常，需要注意的是前面的 catch 捕获异常类型一定不能包含后面的异常类型，这样的话，编译器会报错。
finally ：不论 try-catch 如何执行，finally 一定是最后执行的代码块，所有通常用来处理一些资源的释放，比如关闭数据库连接、关闭打开的系统资源等。

异常处理的基本使用 ，具体可以参考下面的代码段：

try {
    int i = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println(e);
} finally {
    System.out.println("finally");
}

多 catch 的使用 ，具体可以参考下面的代码段：

try {
    int i = Integer.parseInt(null);
} catch (ArithmeticException ae) {
    System.out.println("ArithmeticException");
} catch (NullPointerException ne) {
    System.out.println("NullPointerException");
} catch (Exception e) {
    System.out.println("Exception");
}

需要注意的是 Java 虚拟机会从上往下匹配错误类型，因此前面的 catch 异常类型不能包含后面的异常类型。比如上面的代码如果把 Exception
放在最前面编译器就会报错，具体可以参考下面的图片。

enter image description
here

异常处理的发展

随着 Java 语言的发展，JDK 7 的时候引入了一些更加便利的特性，用来更方便的处理异常信息，如 try-with-resources 和
multiple catch，具体可以参考下面的代码段：

try (FileReader fileReader = new FileReader("");
     FileWriter fileWriter = new FileWriter("")) { // try-with-resources
    System.out.println("try");
} catch (IOException | NullPointerException e) { // multiple catch
    System.out.println(e);
}

异常处理的基本原则

先来看下面这段代码，有没有发现一些问题？

try {
  // ...
  int i = Integer.parseInt(null);
} catch (Exception e) {
}

以上的这段代码，看似“正常”，却违背了异常处理的两个基本原则：

第一，尽量不要捕获通用异常，也就是像 Exception 这样的异常，而是应该捕获特定异常，这样更有助于你发现问题；
第二，不要忽略异常，像上面的这段代码只是加了 catch，但没有进行如何的错误处理，信息就已经输出了，这样在程序出现问题的时候，根本找不到问题出现的原因，因此要切记不要直接忽略异常。

异常处理对程序性能的影响

异常处理固然好用，但一定不要滥用，比如下面的代码片段：

// 使用 com.alibaba.fastjson
JSONArray array = new JSONArray();
String jsonStr = "{'name':'laowang'}";
try {
    array = JSONArray.parseArray(jsonStr);
} catch (Exception e) {
    array.add(JSONObject.parse(jsonStr));
}
System.out.println(array.size());

这段代码是借助了 try-catch 去处理程序的业务逻辑，通常是不可取的，原因包括下列两个方面。

try-catch 代码段会产生额外的性能开销，或者换个角度说，它往往会影响 JVM 对代码进行优化，因此建议仅捕获有必要的代码段，尽量不要一个大的 try 包住整段的代码；与此同时，利用异常控制代码流程，也不是一个好主意，远比我们通常意义上的条件语句（if/else、switch）要低效。
Java 每实例化一个 Exception，都会对当时的栈进行快照，这是一个相对比较重的操作。如果发生的非常频繁，这个开销可就不能被忽略了。

以上使用 try-catch 处理业务的代码，可以修改为下列代码：

// 使用 com.alibaba.fastjson
JSONArray array = new JSONArray();
String jsonStr = "{'name':'laowang'}";
if (null != jsonStr && !jsonStr.equals("")) {
    String firstChar = jsonStr.substring(0, 1);
    if (firstChar.equals("{")) {
        array.add(JSONObject.parse(jsonStr));
    } else if (firstChar.equals("[")) {
        array = JSONArray.parseArray(jsonStr);
    }
}
System.out.println(array.size());

玩转时间操作 + 面试题

在 JDK 8 之前，Java 语言为我们提供了两个类用于操作时间，它们分别是：java.util.Date 和 java.util.Calendar，但在
JDK 8
的时候为了解决旧时间操作类的一些缺陷，提供了几个新的类，用于操作时间和日期，它们分别是：LocalTime、LocalDateTime、Instant，都位于
java.time 包下。

时间的操作在我们日常的开发中经常见到，比如，业务数据都要记录创建时间和修改时间，并要把这些时间格式化之后显示到前端页面，再比如我们需要计算业务数据的时间间隔等，都离不开对时间的操作，那如何正确而优雅地使用时间？这就是我们接下来要讨论的话题。

时间基础知识科普

格林威治时间

格林威治（又译格林尼治）是英国伦敦南郊原格林威治天文台的所在地，它是世界计算时间和地球经度的起点，国际经度会议 1884
年在美国华盛顿召开，会上通过协议，以经过格林威治天文台的经线为零度经线（即本初子午线），作为地球经度的起点，并以格林威治为“世界时区”的起点。

格林威治时间和北京时间的关系

格林威治时间被定义为世界时间，就是 0 时区，北京是东八区。也就是说格林威治时间的 1 日 0 点，对应到北京的时间就是 1 日 8 点。

时间戳

时间戳是指格林威治时间 1970-01-01 00:00:00（北京时间 1970-01-01 08:00:00）起至现在的总秒数。

JDK 8 之前的时间操作

1 获取时间

Date date = new Date();
System.out.println(date);
Calendar calendar = Calendar.getInstance();
Date time = calendar.getTime();
System.out.println(time);

2 获取时间戳

long ts = new Date().getTime();
System.out.println(ts);
long ts2 = System.currentTimeMillis();
System.out.println(ts2);
long ts3 = Calendar.getInstance().getTimeInMillis();
System.out.println(ts3);

3 格式化时间

SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sf.format(new Date()));  // output:2019-08-16 21:46:22

SimpleDateFormat 构造参数的含义，请参考以下表格信息：

字符	含义	示例
y	年	yyyy-1996
M	月	MM-07
d	月中的天数	dd-02
D	年中的天数	121
E	星期几	星期四
H	小时数（0-23）	HH-23
h	小时数（1-12）	hh-11
m	分钟数	mm-02
s	秒数	ss-03
Z	时区	+0800

使用示例：

获取星期几：new SimpleDateFormat(“E”).format(new Date())
获取当前时区：new SimpleDateFormat(“Z”).format(new Date*())

注意事项 ：在多线程下 SimpleDateFormat 是非线程安全的，因此在使用 SimpleDateFormat
时要注意这个问题。在多线程下，如果使用不当，可能会造成结果不对或内存泄漏等问题。

4 时间转换

SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// String 转 Date
String str = "2019-10-10 10:10:10";
System.out.println(sf.parse(str));
//时间戳的字符串 转 Date
String tsString = "1556788591462";
// import java.sql
Timestamp ts = new Timestamp(Long.parseLong(tsString)); // 时间戳的字符串转 Date
System.out.println(sf.format(ts));

注意事项 ：当使用 SimpleDateFormat.parse() 方法进行时间转换的时候，SimpleDateFormat
的构造函数必须和待转换字符串格式一致。

5 获得昨天此刻时间

Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, -1);
System.out.println(calendar.getTime());

JDK 8 时间操作

JDK 8 对时间操作新增了三个类：LocalDateTime、LocalDate、LocalTime。

LocalDate 只包含日期，不包含时间，不可变类，且线程安全。
LocalTime 只包含时间，不包含日期，不可变类，且线程安全。
LocalDateTime 既包含了时间又包含了日期，不可变类，且线程安全。

线程安全性

值得一提的是 JDK 8 中新增的这三个时间相关的类，都是线程安全的，这极大地降低了多线程下代码开发的风险。

1 获取时间

// 获取日期
LocalDate localDate = LocalDate.now();
System.out.println(localDate);    // output:2019-08-16
// 获取时间
LocalTime localTime = LocalTime.now();
System.out.println(localTime);    // output:21:09:13.708
// 获取日期和时间
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDateTime);    // output:2019-08-16T21:09:13.708

2 获取时间戳

long milli = Instant.now().toEpochMilli(); // 获取当前时间戳（精确到毫秒）
long second = Instant.now().getEpochSecond(); // 获取当前时间戳（精确到秒）
System.out.println(milli);  // output:1565932435792
System.out.println(second); // output:1565932435

3 时间格式化

// 时间格式化①
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String timeFormat = dateTimeFormatter.format(LocalDateTime.now());
System.out.println(timeFormat);  // output:2019-08-16 21:15:43
// 时间格式化②
String timeFormat2 = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println(timeFormat2);    // output:2019-08-16 21:17:48

4 时间转换

String timeStr = "2019-10-10 06:06:06";
LocalDateTime dateTime = LocalDateTime.parse(timeStr,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println(dateTime);

5 获得昨天此刻时间

LocalDateTime today = LocalDateTime.now();
LocalDateTime yesterday = today.plusDays(-1);
System.out.println(yesterday);

总结

JDK 8 之前使用 java.util.Date 和 java.util.Calendar
来操作时间，它们有两个很明显的缺点，第一，非线程安全；第二，API 调用不方便。JDK 8 新增了几个时间操作类 java.time 包下的
LocalDateTime、LocalDate、LocalTime、Duration（计算相隔时间）、Period（计算相隔日期）和
DateTimeFormatter，提供了多线程下的线程安全和易用性，让我们可以更好的操作时间。

数组和排序算法的应用 + 面试题

数组的定义与使用

数组是 Java 编程中最重要的数据结构之一，也是最基本的数据结构，Java 中的常用集合 ArrayList、HashMap
等内部的实现都使用到了数组结构。数组是只能用来存储一种类型的集合，可以通过下标访问数值中的所有元素。

数组的声明方式有以下两种，如整数型数组，请参考下面代码：

方式一：int[] arr;
方式二：int arr[];

大部分情况下，我们会使用第一种方式 int[] arr; 来声明数组。

数组初始化

数组可使用 new int[n] 进行初始化，每个元素初始化为 0，声明了 n 个元素。也可以直接赋值，例如 new int[]{ 1,2,3…
}，具体用法可参照下面代码：

// 初始化方式一
int[] arr = new int[5];
// 初始化方式二
int[] arr2 = new int[]{1, 2, 3, 4, 5};
// 初始化方式二的延伸版，可省略 new int[] 直接赋值
int[] arr3 = {1, 2, 3, 4, 5};

注意：在 Java 中，数组初始化如果声明了数组长度，则不能直接赋值。例如，int[] arr = new int[5]{1, 2, 3,
4, 5}; 给这段初始化数组长度并赋值时，编译器会报错，编译不通过。

数组遍历

数组遍历的常见方式有三种：传统的 for 循环、for each 遍历、还有 JDK 8 中新增的 Lambda 表达式。具体的实现请参考以下实例。

方式一：传统 for 循环

Integer[] arr = {2, 3, 6, 7, 9};
// 方式一：传统 for
for (int i = 0; i < arr.length; i++) {
  System.out.println(arr[i]);
}

方式二：for each

Integer[] arr = {2, 3, 6, 7, 9};
// 方式二：for each
for (int i : arr) {
  System.out.println(i);
}

方式三：JDK 8 中的 Lambda 表达式

Integer[] arr = {2, 3, 6, 7, 9};
// 方式三：jdk 8 Lambda
Arrays.asList(arr).forEach(x -> System.out.println(x));

其中 for each 的方式，写法更简洁，也更不容易出错，不必为数组的越界而担心（大于元素的最大下标值）。

注意：数组的访问是从 0 开始，而不是 1 开始，也就是第一个元素的获取是 arr[0]，而非 arr[1]。

数组拷贝

数组拷贝使用的是 Arrays.copyof() 方法，具体实现请参考下面代码：

int[] arr = {3, 4, 9};
int[] arr2 = Arrays.copyOf(arr, arr.length);
System.out.println(Arrays.toString(arr2));

程序执行结果：[3, 4, 9]

注意：Arrays.copyOf(array,newLength) 第二个参数 newLength
表示声明此数组的长度，可以比拷贝的数组的长度长，多出来的元素会初始化为 0 值。

数组填充与合并

数组填充

即为每个元素统一赋值，使用 Arrays.fill() 进行数组填充，具体实现请参考下面代码：

int[] arr = new int[10];
Arrays.fill(arr, 6);
System.out.println(Arrays.toString(arr));

程序执行结果：[6, 6, 6, 6, 6, 6, 6, 6, 6, 6]

注意：使用 Arrays.fill() 会覆盖原有的值，即使数组之前有赋值操作，也会被覆盖。

数组合并

使用 org.apache.commons.lang3.ArrayUtils.addAll() 方法，具体实现请参考下面代码：

int[] arr = {2, 8, 13, 11, 6, 7};
int[] arr2 = {66, 88};
// 合并数组
int[] arr3 = org.apache.commons.lang3.ArrayUtils.addAll(arr, arr2);
System.out.println(Arrays.toString(arr3));

程序执行结果：[2, 8, 13, 11, 6, 7, 66, 88]

排序与算法

数组排序

使用 Arrays.sort() 方法，具体实现请参考下面代码：

int[] arr = {2, 8, 13, 11, 6, 7};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

程序执行结果：[2, 6, 7, 8, 11, 13]

数组逆序

使用 org.apache.commons.lang3.ArrayUtils.reverse(arr) 方法，具体实现请参考下面代码：

int[] arr = {2, 8, 13, 11, 6, 7};
int[] arr = {2, 8, 13, 11, 6, 7};
// 数组正序（排序）
Arrays.sort(arr);
// 数组逆序
org.apache.commons.lang3.ArrayUtils.reverse(arr);
System.out.println(Arrays.toString(arr));

程序执行结果：[13, 11, 8, 7, 6, 2]

注意：org.apache.commons.lang3.ArrayUtils.reverse() 是数组逆序，并不是数组倒序，也就是说
ArrayUtils.reverse() 只会把数组原顺序颠倒输出，并不会自然排序后再倒序输出。

冒泡排序

依次比较相邻的两个数，把较大的值放后面，执行整个循环之后，数组就从小到大进行排列了。具体实现请参考下面代码：

int[] arr = {2, 8, 13, 11, 6, 7};
System.out.println("排序前：" + Arrays.toString(arr));
for (int i = 0; i < arr.length; i++) {
    // 因为冒泡是把每轮循环中较大的数飘到后面，所以是 arr.length-i-1
    for (int j = 0; j < arr.length - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
            // 元素交换
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
        }
    }
}
System.out.println("排序后：" + Arrays.toString(arr));

程序执行结果：

排序前：[2, 8, 13, 11, 6, 7]
排序后：[2, 6, 7, 8, 11, 13]

选择排序

每次从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。具体实现请参考下面代码：

int[] arr = {2, 8, 13, 11, 6, 7};
System.out.println("排序前：" + Arrays.toString(arr));
for (int i = 0; i < arr.length; i++) {
  int lowerIndex = i;
  for (int j = i + 1; j < arr.length; j++) {
    // 找出最小的一个索引
    if (arr[j] < arr[lowerIndex]) {
      lowerIndex = j;
    }
  }
  // 交换
  int temp = arr[i];
  arr[i] = arr[lowerIndex];
  arr[lowerIndex] = temp;
}
System.out.println("排序后：" + Arrays.toString(arr));

程序执行结果：

排序前：[2, 8, 13, 11, 6, 7]
排序后：[2, 6, 7, 8, 11, 13]

关于更多的排序算法，后面会有专门的章节进行介绍。

元素查找

查找数组是否包含某个值，使用 Arrays.binarySearch() 方法查询。 Arrays.binarySearch()
是利用二分法查询某个值，如果查到包含某值会返回该值的下标，如果没有查到则返回负值。

int[] arr = {1, 3, 4, 5};
// Arrays.binarySearch() 使用二分法查询某值
int index = Arrays.binarySearch(arr, 5);
System.out.println(index);

注意：使用 Arrays.binarySearch 之前一定要先调用 Arrays.sort() 对数组进行排序，否则返回的结果有误。

多维数组

我们之前使用的数组可以称之为一维数组，而多维数组可以理解为数组的数组，可以用二维数组来举例，二维数组也是一种特殊的多维数组。

比如我们声明一个二维数组：int[][] arr = new int[2][4];

这就相当于我们创建了一个两行四列的表，它的使用、赋值与取值，请查看下面代码示例：

// 声明二维数组
int[][] arr = new int[2][4];
//循环二维数组
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[0].length; j++) {
        // 二维数组赋值
        arr[i][j] = j;
    }
}
// 二维数组取值
System.out.println(arr[0][1]);
// 打印二维数组
System.out.println(Arrays.toString(arr[0]));
System.out.println(Arrays.toString(arr[1]));

以上程序执行的结果是：

1
[0, 1, 2, 3]
[0, 1, 2, 3]

数组类型转换

字符串转数组

使用 split 分隔字符串就形成了数组，请参考以下代码：

String str = "laowang,stone,wanglei";
String[] arr = str.split(","); // 字符串转数组
System.out.println(arr[0]);

数组转字符串

使用 Arrays.toString() 方法，请参考以下代码：

String[] arr = {"laowang", "stone", "wanglei"};
String str = Arrays.toString(arr);
System.out.println(str);

若要查看更多数组转字符串的方式，请查看本文面试部分的介绍。

数组转集合

使用 Arrays.asList() 方法，请参考以下代码：

String[] strArr = {"cat", "dog"};
List list = Arrays.asList(strArr);
System.out.println(list);

集合转数组

使用 List.toArrray() 方法，请参考以下代码：

List<String> list = new ArrayList<String>();
list.add("cat");
list.add("dog");
// 集合转换为数组
String[] arr = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));

总结

在 Java 中数组本质是引用类型，数组只能用来存储固定大小的同类型元素。在 Java 中很多集合的内部都是依赖数组实现的，如 ArrayList 和
HashMap
等。数组的冒泡排序和选择排序也是面试常考的内容，很多公司会要求面试者手写冒泡排序。本文也介绍了数组、字符串和集合之间的相互转换，只有掌握好这些技能才能开发出更好的
Java 程序。

类与 Object 的应用 + 面试题

类介绍

Java 程序是由若干个类组成的，类也是面向对象编程思想的具体实现。

以下为类的基本使用：

public class Cat {
    // 私有属性
    private String name;
    private int age;
    // 构造方法
    public Cat() {
    }
    // 普通方法
    public void eat() {
        System.out.println("吃吃吃");
    }
    // 对外包装属性
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

类引用

当我们需要使用不同包下的类时，就需要使用 import 导入包或类，这个时候才能正常使用。例如，我们要使用 java.util 下的 ArrayList
就必须使用 import java.util.ArrayList，请参考以下代码：

// 导入 ArrayList 类
import java.util.ArrayList;
class importTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
    }
}

类引用的高级用法

import 还可以导入静态方法和静态域的功能，比如以下代码：

// 导入 static 静态域的功能
import static java.lang.System.*;
class staticTest {
    public static void main(String[] args) {
        out.println("hi");
    }
}

以上代码也可以顺利的执行，这也是 import 好玩的一个地方。

访问修饰符

在 Java 中访问修饰符有以下四种：

public
protected
默认
private

具体介绍如下表：

访问级别	访问控制修饰符	同类	同包	子类	不同的包
公开	public	✓	✓	✓	✓
受保护	protected	✓	✓	✓	×
默认	没有访问修饰符	✓	✓	×	×
私有	private	✓	×	×	×

（1）在开发中要尽可能地加上访问修饰符（提高程序的可读性）；

（2）无特殊要求的情况下，类内部的变量应该设置为私有的（防止外部篡改）。

构造方法

构造方法也叫构造器或构造函数，它的作用是对类进行初始化，比如以下代码：

class Cat {
    // 构造方法
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public static void main(String[] args) {
        Cat cat = new Cat("喵星人",2);
        System.out.println(cat.getName());
        System.out.println(cat.getAge());
    }
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

以上代码执行结果如下：

喵星人
2

构造方法五大原则：

1. 构造方法必须与类同名；
2. 构造方法的参数可以没有或者有多个；
3. 构造方法不能有返回值；
4. 每个类可以有一个或多个构造方法；
5. 构造方法总是伴随着 new 操作一起使用。

继承

用法：使用 extends 关键字来实现类的继承，示例代码如下：

class Animal {
    public void eat() {
        System.out.println("Animal");
    }
}
class Cat extends Animal {
}
public class eTest implements Cloneable {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.eat();
    }
}

以上程序执行结果：Animal

继承使用技巧：

将公共的变量或者方法提取到超类中；
除非所有的方法都有继承的意义，否则不要使用继承；
在方法覆盖时不要改变原有方法的预期行为。

Object

Object 类是 Java 中的一个特殊类，它是所有类的父类，Java 中的类都直接或间接的继承自 Object 类。

Object 类的常用方法如下：

equals()：对比两个对象是否相同
getClass()：返回一个对象的运行时类
hashCode()：返回该对象的哈希码值
toString()：返回该对象的字符串描述
wait()：使当前的线程等待
notify()：唤醒在此对象监视器上等待的单个线程
notifyAll()：唤醒在此对象监视器上等待的所有线程
clone()：克隆一个新对象

关于更多 Object 的内容，如克隆（深克隆、浅克隆）、线程等待和唤醒，会在后面的章节中详细介绍。

总结

本文我们学习了类的基础用法，类引用：import 和 import
static，访问修饰符的作用，构造函数和继承的特点以及使用技巧等，通过这些内容让我们对整个 Java 程序的组成，有了更加清晰直观的印象。

各种内部类和枚举类的使用 + 面试题

内部类不仅经常出现在各种面试题中，还会在 Java 源码中频频出现，因此只有搞明白了 Java 内部类，才能搞定面试和看懂各种 Java 源码。

内部类

Java 内部类，分为以下四种：

成员内部类
静态成员内部类
局部内部类
匿名内部类

下面分别来看这些内部类的使用。

成员内部类

定义

在一个类中定义了另一个类，则将定义在类中的那个类称之为成员内部类。成员内部类也是最普通的内部类。

使用

成员内部类的使用示例如下：

class Outer {
    public Outer() {
        System.out.println("Outer Class.");
    }
    class Inner {
        public void sayHi() {
            System.out.println("Hi, Inner.");
        }
    }
}

其中 Inner 类则为成员内部类。
而成员内部类的创建和使用，请参考以下完整的示例代码：

class InnerTest {
    public static void main(String[] args) {
        Outer out = new Outer();
        // 创建成员内部类
        Outer.Inner inner = out.new Inner();
        inner.sayHi();
    }
}
class Outer {
    public Outer() {
        System.out.println("Outer Class.");
    }
    class Inner {
        public void sayHi() {
            System.out.println("Hi, Inner.");
        }
    }
}

成员内部类的创建

语法：

Outer.Inner inner = new Outer().new Inner();

内部类访问外部类

语法：

Outer.this.xxx

代码示例：

class Outer {
    private String name = "OuterClass";
    public void sayHi() {
        System.out.println("Hi, Outer.");
    }
    class Inner {
        public void sayHi() {
            // 内部类访问外部类
            Outer.this.sayHi();
            System.out.println(Outer.this.name);
            System.out.println("Hi, Inner.");
        }
    }
}
class InnerTest {
    public static void main(String[] args) {
        Outer.Inner inner =  new Outer().new Inner();
        inner.sayHi();
    }
}

外部类访问内部类

语法：

new Inner().xxx

代码示例：

class Outer {
    public void sayHi() {
        System.out.println(new Inner().name);
        System.out.println("Hi, Outer.");
    }
    private class Inner {
        String name = "InnerClass";
        public void sayHi() {
            System.out.println("Hi, Inner.");
        }
    }
}
class InnerTest {
    public static void main(String[] args) {
        new Outer().sayHi();
    }
}

小结

成员内部类可直接访问外部类（使用：外部类.this.xxx）；
外部成员类要访问内部类，必须先建立成员内部类对象；
成员内部类可使用任意作用域修饰（public、protected、默认、private）；
成员内部类可访问外部类任何作用域修饰的属性和方法；
外部类建立成员内部类对象之后，可以访问任何作用域修饰的内部类属性和方法。

静态成员内部类

定义

在一个类中定义了另一个 static 类，则将定义在类中的那个 static 类称之为静态成员内部类。

静态成员内部类也就是给内部成员类加上 static 修饰符。

使用

静态成员内部类的使用示例如下：

class OuterClass {
    public OuterClass() {
        System.out.println("OuterClass Init.");
    }
    protected static class InnerClass {
        public void sayHi() {
            System.out.println("Hi, InnerClass.");
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.sayHi();
    }
}

与内部成员类的创建方式 new Outer().new Inner() 不同，静态成员内部类可使用 new OuterClass.InnerClass()
的方式进行创建。

注意：不能从静态成员内部类中访问非静态外部类对象。

局部内部类

定义

一个类定义在另一个类的局部（方法或者任意作用域），这个类就称之为局部内部类。

使用

局部内部类的使用示例如下：

class OutClass {
    public void sayHi() {
        class InnerClass {
            InnerClass(String name) {
                System.out.println("InnerClass:" + name);
            }
        }
        System.out.println(new InnerClass("Three"));
        System.out.println("Hi, OutClass");
    }
}
class OutTest {
    public static void main(String[] args) {
        new OutClass().sayHi();
    }
}

局部内部类特点

局部内部类不能使用任何访问修饰符；
局部类如果在方法中，可以直接使用方法中的变量，不需要通过 OutClass.this.xxx 的方式获得。

匿名内部类

定义

没有名字的内部类就叫做匿名内部类。

使用

匿名内部类的使用示例如下：

interface AnonymityOuter {
    void hi();
}
class AnonymityTest {
    public static void main(String[] args) {
        AnonymityOuter anonymityOuter = new AnonymityOuter() {
            @Override
            public void hi() {
                System.out.println("Hi, AnonymityOuter.");
            }
        };
        anonymityOuter.hi();
    }
}

其中，new AnonymityOuter() 之后的 {…} 大括号包含的部分就为匿名内部类。

匿名内部类特点

匿名内部类必须继承一个父类或者实现一个接口
匿名内部类不能定义任何静态成员和方法
匿名内部类中的方法不能是抽象的

枚举类

枚举类是 JDK 1.5 引入的新特性，使用关键字“enum”声明。枚举功能虽小，却非常实用，大大方便了程序的开发者。

枚举类的使用

请参考以下代码：

enum ColorEnum {
    RED,
    BLUE,
    YELLOW,
    GREEN
}
class EnumTest {
    public static void main(String[] args) {
        ColorEnum color = ColorEnum.GREEN;
        switch (color) {
            case RED:
                System.out.println("Red");
                break;
            case BLUE:
                System.out.println("Blue");
                break;
            case YELLOW:
                System.out.println("Yellow");
                break;
            case GREEN:
                System.out.println("Green");
                break;
            default:
                break;
        }
    }
}

枚举类命名规范

《阿里巴巴 Java 开发手册》对枚举类的命名规范建议，如下图：

enter image description
here

扩展枚举类

我们可以自定义一些枚举类方法，扩展枚举类的使用，请参考以下代码：

enum ColorsEnum {
    RED("红色", 1),
    BLUE("蓝色", 2),
    YELLOW("黄色", 3),
    GREEN("绿色", 4);
    ColorsEnum(String name, int index) {
        this.name = name;
        this.index = index;
    }
    private String name;
    private int index;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
}
class EnumTest {
    public static void main(String[] args) {
        System.out.println(ColorsEnum.RED.getName());
        System.out.println(ColorsEnum.RED.getIndex());
    }
}

执行以上代码返回的结果：

红色
1

总结

通过本文我们系统地学习了 Java
的各种内部类：静态内部类、成员内部类、局部内部类、匿名内部类，知道了它们特点和区别，并学习了枚举类了使用，知道了枚举类在编译之后，其实还是普通的最终类（final
class）。

抽象类和接口的应用 + 面试题

抽象类

定义

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。简单来说，使用关键字
abstract 修饰的类就叫做抽象类。

抽象类使用

示例代码，如下：

abstract class AbstractAnimal {
    public AbstractAnimal() {
        System.out.println("Init AbstractAnimal.");
    }
    static String name = "AbstractAnimal";
    public abstract void eat();
    public void run() {
        System.out.println("AbstractAnimal Run.");
    }
}
class Animal extends AbstractAnimal {
    public static void main(String[] args) {
        AbstractAnimal animal = new Animal();
        animal.run();
        System.out.println(animal.name);
        animal.eat();
    }
  // 必须重写抽象父类方法
    @Override
    public void eat() {
        System.out.println("Animal Eat.");
    }
}

以上代码执行的结果：

Init AbstractAnimal.
AbstractAnimal Run.
AbstractAnimal
Animal Eat.

抽象方法

使用 abstract 关键字修饰的方法叫做抽象方法，抽象方法仅有声明没有方法体。如下代码：

public abstract void m();

抽象类的特性

抽象类不能被初始化
抽象类可以有构造方法
抽象类的子类如果为普通类，则必须重写抽象类中的所有抽象方法
抽象类中的方法可以是抽象方法或普通方法
一个类中如果包含了一个抽象方法，这个类必须是抽象类
子类中的抽象方法不能与父类中的抽象方法同名
抽象方法不能为 private、static、final 等关键字修饰
抽象类中可以包含普通成员变量，访问类型可以任意指定，也可以使用静态变量（static）

接口

定义

接口（interface）是抽象类的延伸，它允许一个类可以实现多个接口，弥补了抽象类不能多继承的缺陷，接口是对类的描述，使用 interface
关键字来声明。

接口使用

示例代码，如下：

interface IAnimal {
    void run();
}
class AnimalImpl implements IAnimal {
    public static void main(String[] args) {
        IAnimal animal = new AnimalImpl();
        animal.run();
    }
    @Override
    public void run() {
        System.out.println("AnimalImpl Run.");
    }
}

Java 8 中接口的改动

1）接口中增加了 default 方法和 static 方法，可以有方法体
示例代码，如下：

interface IAnimal {
    static void printSex() {
        System.out.println("Male Dog");
    }
    default void printAge() {
        System.out.println("18");
    }
}
class AnimalImpl implements IAnimal {
    public static void main(String[] args) {
        IAnimal.printSex();
        IAnimal animal = new AnimalImpl();
        animal.printAge();
  }
}

注意：static 方法属于接口方法，可以直接使用；default 属于实例方法，必须先创建实例。

2）接口中的静态变量会被继承
示例代码，如下：

interface IAnimal {
    static String animalName = "Animal Name";
    static void printSex() {
        System.out.println("Male Dog");
    }
}
class AnimalImpl implements IAnimal {
    public static void main(String[] args) {
        System.out.println(animalName);
        IAnimal.printSex();
    }
}

注意：静态变量会被继承，静态方法不会被继承。

3）新增函数式接口

函数式接口（Function Interface）是一个特殊的接口，使用 @FunctionInterface 注解声明，定义这种接口可以使用
Lambda 表达式直接调用。
示例代码，如下：

@FunctionalInterface
interface IAnimal {
    static String animalName = "Animal Name";
    static void printSex() {
        System.out.println("Male Dog");
    }
    default void printAge() {
        System.out.println("18");
    }
    void sayHi(String name);
}
class FunctionInterfaceTest {
    public static void main(String[] args) {
        IAnimal animal = name -> System.out.println(name);
        animal.sayHi("WangWang");
    }
}

注意：使用 @FunctionInterface 声明的函数式接口，抽象方法必须有且仅有一个，但可以包含其他非抽象方法。

总结

抽象类和接口都是面向对象编程中多态的具体实现，在 Java 编程思想中占据着重要的地位，同时也是初级面试岗位必问的问题之一，但由于接口在 JDK 8

        IAnimal animal = new AnimalImpl();
        animal.printAge();
  }
}