再高大上的框架,也需要扎实的基础才能玩转,高频面试问题更是基础中的高频实战要点。
Java 学习者和爱好者,有一定工作经验的技术人,准面试官等。
本教程是系列教程,包含 Java 基础,JVM,容器,多线程,反射,异常,网络,对象拷贝,JavaWeb,设计模式,Spring-Spring MVC,Spring Boot / Spring Cloud,Mybatis / Hibernate,Kafka,RocketMQ,Zookeeper,MySQL,Redis,Elasticsearch,Lucene
微信搜:JavaPub,阅读全套系列面试题教程
toc
JDK 和 JRE
JDK(Java Development Kit)是Java开发运行环境,是java开发工具包,JDK包含了JRE的所有东西,同时还包含了编译java源码的编译器javac,还包含了很多java程序调试和分析的工具:jconsole,jvisualvm等工具软件,还包含了java程序编写所需的文档和demo例子程序。
JRE(Java Runtime Environment)它是Java运行环境,如果你不需要开发只需要运行Java程序,那么你可以安装JRE。(但是在运行JSP程序时,我们还是需要JDK,因为应用服务器会将 JSP 转换为 Java servlet,并且需要使用 JDK 编译 servlet。)
如果你需要运行java程序,只需安装JRE就可以了。如果你需要编写java程序,需要安装JDK。
JVM
JVM(Java Virtual Machine) 就是我们常说的 java 虚拟机是 JRE 的一部分,它是整个 java 实现跨平台的最核心的部分,所有的 java 程序会首先被编译为 .class 的类文件,这种类文件可以在虚拟机上执行。
JVM 主要工作是解释自己的指令集(即字节码)并映射到本地的 CPU 指令集和 OS 的系统调用。Java 语言是跨平台运行的,不同的操作系统会有不同的 JVM 映射规则,使之与操作系统无关,完成跨平台性。
JVM是Java Virtual Machine(Java虚拟机)的缩写,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。由一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域等组成。JVM屏蔽了与操作系统平台相关的信息,使得Java程序只需要生成在Java虚拟机上运行的目标代码(字节码),就可在多种平台上不加修改的运行,这也是Java能够“一次编译,到处运行的”原因。
附一张关系图:
总结:使用JDK(调用JAVA API)开发JAVA程序后,通过JDK中的编译程序(javac)将Java程序编译为Java字节码,在JRE上运行这些字节码,JVM会解析并映射到真实操作系统的CPU指令集和OS的系统调用。
equals 和 == 都是来判断两个对象是否相等
public boolean equals(Object obj) {
return (this == obj);
}
从源码可以看出,里面使用的就是 == 比较,所以这种情况下比较的就是它们在内存中的存放地址。
@Override
public boolean equals(Object other) {
if (other == this) {
return true;
}
if (other instanceof String) {
String s = (String)other;
int count = this.count;
if (s.count != count) {
return false;
}
if (hashCode() != s.hashCode()) {
return false;
}
char[] value1 = value;
int offset1 = offset;
char[] value2 = s.value;
int offset2 = s.offset;
for (int end = offset1 + count; offset1 < end; ) {
if (value1[offset1] != value2[offset2]) {
return false;
}
offset1++;
offset2++;
}
return true;
} else {
return false;
}
}
从源码可以看出, String 类复写了 equals 方法,当使用 == 比较内存的存放地址不相等时,接下来会比较字符串的内容是否 相等,所以 String 类中的 equals 方法会比较两者的字符串内容是否一样。
答案是不一定的
java.lang.Object类中有两个非常重要的方法:
public boolean equals(Object obj)
public int hashCode()
Object
类是类继承结构的基础,所以是每一个类的父类。所有的对象,包括数组,都实现了在 Object
类中定义的方法。
以下是Object对象API关于equal方法和hashCode方法的说明:
简而言之,在集合查找时,hashcode能大大降低对象比较次数,提高查找效率!
Java对象的eqauls方法和hashCode方法是这样规定的:
对以上俩点的说明
想象一下,假如两个Java对象A和B,A和B相等(eqauls结果为true),但A和B的哈希码不同,则A和B存入HashMap时的哈希码计算得到的HashMap内部数组位置索引可能不同,那么A和B很有可能允许同时存入HashMap,显然相等/相同的元素是不允许同时存入HashMap,HashMap不允许存放重复元素。
也就是说,不同对象的hashCode可能相同;假如两个Java对象A和B,A和B不相等(eqauls结果为false),但A和B的哈希码相等,将A和B都存入HashMap时会发生哈希冲突,也就是A和B存放在HashMap内部数组的位置索引相同这时HashMap会在该位置建立一个链接表,将A和B串起来放在该位置,显然,该情况不违反HashMap的使用原则,是允许的。当然,哈希冲突越少越好,尽量采用好的哈希算法以避免哈希冲突。
总而言之(all in all):
换句话说,equals()方法不相等的两个对象,hashcode()有可能相等(我的理解是由于哈希码在生成的时候产生冲突造成的)。反过来,hashcode()不等,一定能推出equals()也不等;hashcode()相等,equals()可能相等,也可能不等。
这是一个很基础,很能体现你基础是否扎实、是否有钻研精神的知识点。
final关键字的字面意思是最终的, 不可修改的. 这似乎是一个看见名字就大概能知道怎么用的语法。
这三点必须要答出来:
要注意final类中的所有成员方法都会被隐式地指定为final方法。
第三点尤为重要
当final修饰的是一个基本数据类型数据时, 这个数据的值在初始化后将不能被改变; 当final修饰的是一个引用类型数据时, 也就是修饰一个对象时, 引用在初始化后将永远指向一个内存地址, 不可修改. 但是该内存地址中保存的对象信息, 是可以进行修改的.
JavaPub参考巨人(有一些简单例子,便于更好的理解final):https://www.cnblogs.com/dolphin0520/p/3736238.html
返回值:-1
四舍五入的原理是在参数上加0.5然后做向下取整。
一些案例:
public class test {
public static void main(String[] args){
System.out.println(Math.round(1.3)); //1
System.out.println(Math.round(1.4)); //1
System.out.println(Math.round(1.5)); //2
System.out.println(Math.round(1.6)); //2
System.out.println(Math.round(1.7)); //2
System.out.println(Math.round(-1.3)); //-1
System.out.println(Math.round(-1.4)); //-1
System.out.println(Math.round(-1.5)); //-1
System.out.println(Math.round(-1.6)); //-2
System.out.println(Math.round(-1.7)); //-2
}
}
当然,每一个Java学习者都知道它不是基础类型,但是你要知道更多细节。
Java中的数据类型分为两大类,基本数据类型和引用数据类型。
基本数据类型只有8种,可按照如下分类
引用数据类型非常多,大致包括:
类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型。
简单来说,所有的非基本数据类型都是引用数据类型。
在方法中定义的非全局基本数据类型变量的具体内容是存储在栈中的
只要是引用数据类型变量,其具体内容都是存放在堆中的,而栈中存放的是其具体内容所在内存的地址(引用/句柄)
ps:通过变量地址可以找到变量的具体内容,就如同通过房间号可以找到房间一般
在方法中定义的非全局基本数据类型变量,调用方法时作为参数是按数值传递的
//基本数据类型作为方法参数被调用
public class Main{
public static void main(String[] args){
int msg = 100;
System.out.println("调用方法前msg的值:\n"+ msg); //100
fun(msg);
System.out.println("调用方法后msg的值:\n"+ msg); //100
}
public static void fun(int temp){
temp = 0;
}
}
引用数据类型变量,调用方法时作为参数是按引用传递的
//引用数据类型作为方法参数被调用
class Book{
String name;
double price;
public Book(String name,double price){
this.name = name;
this.price = price;
}
public void getInfo(){
System.out.println("图书名称:"+ name + ",价格:" + price);
}
public void setPrice(double price){
this.price = price;
}
}
public class Main{
public static void main(String[] args){
Book book = new Book("Java开发指南",66.6);
book.getInfo(); //图书名称:Java开发指南,价格:66.6
fun(book);
book.getInfo(); //图书名称:Java开发指南,价格:99.9
}
public static void fun(Book temp){
temp.setPrice(99.9);
}
}
调用时为temp在栈中开辟新空间,并指向book的具体内容,方法执行完毕后temp在栈中的内存被释放掉
JavaPub参考巨人:https://blog.csdn.net/py1215/article/details/107524483
String、StringBuffer、StringBuilder
答:不一样。
因为内存的分配方式不一样。String str="i"的方式,Java 虚拟机会将其分配到常量池中;而 String str=new String(“i”)方式,则会被分到堆内存中。
String str1 = "i";
String str2 = "i";
String str3 = new String("i");
System.out.println(str1 == str2);//ture
System.out.println(str2 == str3);//false
解释:
在String str1="i"中,把i值存在常量池,地址赋给str1。假设再写一个String str2="i",则会把i的地址赋给str2,但是i对象不会重新创建,他们引用的是同一个地址值,共享同一个i内存。(需要注意的是:String str="i"; 因为String 是final类型的,所以“i”应该是在常量池。)
假设再写一个String str3=new String(“i”),则会创建一个新的i对象,然后将新对象的地址值赋给str3。虽然str3和str1的值相同但是地址值不同。(而new String("i");则是新建对象放到堆内存中。)
拓展知识:
俩种办法:
public static void main(String[] args) {
String str = "ABCDE";
System.out.println(reverseStringByStringBuilderApi(str));
System.out.println(reverseString(str));
}
/**
* 和StringBuffer()一样,都用了Java自实现的方法,使用位移来实现
* @param
* @return
*/
public static String reverseStringByStringBuilderApi(String str) {
if (str != null && str.length() > 0) {
return new StringBuilder(str).reverse().toString();
}
return str;
}
public static String reverseString(String str) {
if (str != null && str.length() > 0) {
int len = str.length();
char[] chars = new char[len];
for (int i = len - 1; i >= 0; i--) {
chars[len - 1 - i] = str.charAt(i);
}
return new String(chars);
}
return str;
}
更多交换方式参考:https://blog.csdn.net/py1215/article/details/107549222
下面列举了20个常用方法。格式:返回类型 方法名 作用。
答案是:不必须
这道题考察的是抽象类的知识:
抽象类的基本使用示例:
//定义一个抽象类
abstract class A{
//普通方法
public void fun(){
System.out.println("存在方法体的方法");
}
//抽象方法,没有方法体,有abstract关键字做修饰
public abstract void print();
}
//单继承
//B类是抽象类的子类,是一个普通类
class B extends A{
//强制要求覆写
@Override
public void print() {
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String[] args) {
//向上转型
A a = new B();
//被子类所覆写的过的方法
a.print();
}
}
JavaPub参考巨人:https://www.jianshu.com/p/0530e14192b4
包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意,抽象类和普通类的主要有三点区别:
不能,抽象类是被用于继承的,final修饰代表不可修改、不可继承的。
这个在前面几题有过介绍。
语法层面上的区别,也是我们日常官方的一些说法:
接口的设计目的,是对类的行为进行约束。而抽象类的设计目的,是代码复用。总结来说,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系。
抽象和继承是 Java 中非常重要的东西,深入理解可以让我们对 Java 技术理解更深刻,参考的这篇知乎博文非常好。
JavaPub参考巨人:https://www.zhihu.com/question/20149818
Java中的流分为两种,一种是字节流,另一种是字符流,分别由四个抽象类来表示(每种流包括输入和输出两种所以一共四个):InputStream,OutputStream,Reader,Writer。Java中其他多种多样变化的流均是由它们派生出来的.
字符流和字节流是根据处理数据的不同来区分的。字节流按照8位传输,字节流是最基本的,所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。
读文本的时候用字符流,例如txt文件。读非文本文件的时候用字节流,例如mp3。理论上任何文件都能够用字节流读取,但当读取的是文本数据时,为了能还原成文本你必须再经过一个转换的工序,相对来说字符流就省了这个麻烦,可以有方法直接读取。
字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节, 操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!
代码Demo参考:https://www.yisu.com/zixun/128625.html
BIO
BIO全称是Blocking IO,是JDK1.4之前的传统IO模型,本身是同步阻塞模式。
线程发起IO请求后,一直阻塞IO,直到缓冲区数据就绪后,再进入下一步操作。针对网络通信都是一请求一应答的方式,虽然简化了上层的应用开发,但在性能和可靠性方面存在着巨大瓶颈,试想一下如果每个请求都需要新建一个线程来专门处理,那么在高并发的场景下,机器资源很快就会被耗尽。
NIO
NIO也叫Non-Blocking IO 是同步非阻塞的IO模型。线程发起io请求后,立即返回(非阻塞io)。同步指的是必须等待IO缓冲区内的数据就绪,而非阻塞指的是,用户线程不原地等待IO缓冲区,可以先做一些其他操作,但是要定时轮询检查IO缓冲区数据是否就绪。Java中的NIO 是new IO的意思。其实是NIO加上IO多路复用技术。普通的NIO是线程轮询查看一个IO缓冲区是否就绪,而Java中的new IO指的是线程轮询地去查看一堆IO缓冲区中哪些就绪,这是一种IO多路复用的思想。IO多路复用模型中,将检查IO数据是否就绪的任务,交给系统级别的select或epoll模型,由系统进行监控,减轻用户线程负担。
NIO主要有buffer、channel、selector三种技术的整合,通过零拷贝的buffer取得数据,每一个客户端通过channel在selector(多路复用器)上进行注册。服务端不断轮询channel来获取客户端的信息。channel上有connect,accept(阻塞)、read(可读)、write(可写)四种状态标识。根据标识来进行后续操作。所以一个服务端可接收无限多的channel。不需要新开一个线程。大大提升了性能。
AIO
AIO是真正意义上的异步非阻塞IO模型。
上述NIO实现中,需要用户线程定时轮询,去检查IO缓冲区数据是否就绪,占用应用程序线程资源,其实轮询相当于还是阻塞的,并非真正解放当前线程,因为它还是需要去查询哪些IO就绪。而真正的理想的异步非阻塞IO应该让内核系统完成,用户线程只需要告诉内核,当缓冲区就绪后,通知我或者执行我交给你的回调函数。
AIO可以做到真正的异步的操作,但实现起来比较复杂,支持纯异步IO的操作系统非常少,目前也就windows是IOCP技术实现了,而在Linux上,底层还是是使用的epoll实现的。
资料:
BIO (Blocking I/O): 同步阻塞I/O模式,数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高(小于单机1000)的情况下,这种模型是比较不错的,可以让每一个连接专注于自己的 I/O 并且编程模型简单,也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗,可以缓冲一些系统处理不了的连接或请求。但是,当面对十万甚至百万级连接的时候,传统的 BIO 模型是无能为力的。因此,我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
NIO (New I/O): NIO是一种同步非阻塞的I/O模型,在Java 1.4 中引入了NIO框架,对应 java.nio 包,提供了 Channel , Selector,Buffer等抽象。NIO中的N可以理解为Non-blocking,不单纯是New。它支持面向缓冲的,基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样,比较简单,但是性能和可靠性都不好;非阻塞模式正好与之相反。对于低负载、低并发的应用程序,可以使用同步阻塞I/O来提升开发速率和更好的维护性;对于高负载、高并发的(网络)应用,应使用 NIO 的非阻塞模式来开发
AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的,也就是应用操作之后会直接返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写,虽然 NIO 在网络操作中,提供了非阻塞的方法,但是 NIO 的 IO 行为还是同步的。对于 NIO 来说,我们的业务线程是在 IO 操作准备好时,得到通知,接着就由这个线程自行进行 IO 操作,IO操作本身是同步的。查阅网上相关资料,我发现就目前来说 AIO 的应用还不是很广泛,Netty 之前也尝试使用过 AIO,不过又放弃了。
Files.exists():检测文件路径是否存在。
Files.createFile():创建文件。
Files.createDirectory():创建文件夹。
Files.delete():删除一个文件或目录。
Files.copy():复制文件。
Files.move():移动文件。
Files.size():查看文件个数。
Files.read():读取文件。
Files.write():写入文件。
微信关注:JavaPub ,带走全套宝典
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。