Java基础面试题

最新推荐文章于 2024-10-05 19:00:00 发布

九九lx

最新推荐文章于 2024-10-05 19:00:00 发布

阅读量185

点赞数

分类专栏： Java面试文章标签： java 面试

本文链接：https://blog.csdn.net/lixu_1030/article/details/119937667

版权

Java面试专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1. final（最终的）

修饰类：表示类不可被继承
修饰方法：表示方法不可被子类覆盖，但是可以重载
修饰变量：表示变量一旦被赋值就不可以更改它的值

修饰成员变量
(1) 如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值。
(2) 如果final修饰的是成员变量，可以在非静态初始化块、声明该变犀或者构造器中执行初始值。
修饰局部变量
系统不会为同部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时，即可以在定义时指定默认值(后面的代码不能对变量再赋值)，也可以不指定默认值,而在后面的代码中对final变量赋初值(仅一次)

2. 重载与重写的区别

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

3. 接口和抽象类的区别

抽象类可以存在普通成员函数，而接口中只能存在public abstract方法。
抽象类只能继承一个，接口可以实现多个。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。

4. List和Set的区别

List：有序，按对象进入的顺序保存对象，可重复，允许多个Null元索对象，可以使用terator（迭代器）取出所有元索，再逐一遍历，还可以使用get(int index)获取指定下表的元素
Set：无序，不可重复，最多允许有一个Null元素对象，取元素时只能用Iterator接口取得所有元素，在逐一遍历各个元素

5. hashCode与equals

hashCode介绍
hashCode()的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode()定义在JDK的Object.java中，Java中的任何类都包含有hashCode0函数。散列表存储的是键值对(key，value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码! (可以快速找到所需要的对象)
为什么要有hashCode
以“HashSet如何检查重复”为例子来说明为什么要有hashCode：
对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，看该位置是否有值，如果没有HashSet会假设对象没有重复出现。但是如果发现有值，这时会调用equals()方法来检查两个对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样就大大减少了equals的次数，相应就大大提高了执行速度。

如果两个对象相等，则hashcode一定也是相同的
两个对象相等，对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不一定是相等的
因此，equals方法被覆盖过，则hashCode方法也必须被覆盖

6. equals和==的区别

equals：
　　引用类型：Objec类比较的是地址值，但是继承他的类大都重写了equals方法比较成员变量的值是否相同，即比较的是是否是同一个对象。
　　基本类型：equals方法不能作用于基本数据类型的变量，所以equals方法可以比较两个字符串内容是否相等。
= =：
　　基本类型：比较值是否相同；比较基本类型只能用"=="，不能用"equals"。
　　引用类型：比较内存地址是否相同。

总结：equals比较的是两个字符串内容是否相等；= =比较的是两个字符串的内存地址是否相同。

7. ArrayList和LinkedList的区别

ArrayList：基于动态数组，连续内存存储，适合下标访问(随机访问)，扩容机制：因为数组长度固定，超出长度存数据时需要新建数组，然后将老数组的数据拷贝到新数组，如果不是尾部插入数据还会涉及到元素的移动(往后复制一份，插入新元索)，使用尾插法并指定初始容量可以极大提升性能、甚至超过linkedList (需要创建大量的node对象)
LinkedList：基于链表，可以存储在分散的内存中，适合做数据插入及删除操作，不适合查询：需要逐一遍历遍历LinkedList必须使用iterator不能使用for循环，因为每次for循环体内通过get取得某一元素时都需要对list重新进行遍历，性能消耗极大。另外不要试图使用indexOf等返回元索索引，并利用其进行遍历，使用indexIOf对list进行了遍历，当结果为空时会遍历整个列表。

8. HashMap和HashTable有什么区别?其底层实现是什么?

区别：
(1) HashMap方法没有synchronized修饰，线程非安全，HashTable线程安全；
(2) HashMap允许key和value为null，而HashTable不允许
底层实现：数组+链表实现
jdk8开始链表高度到8，数组长度超过64，链表转变为红黑树，元索以内部类Node节点存在
(1) 计算key的hash值，二次hash然后对数组长度取模，对应到数组下标
(2) 如果没有产生hash冲突(下标位置没有元索)，则直接创建Node存入数组
(3) 如果产生hash冲突，先进行equal比较，相同则取代该元素，不同则判断链表高度插入链表，链表高度达到8，并且数组长度到64则转变为红黑树，长度低于6则将红黑树转回链表
(4) key为null，存在下标0的位置

9. HashSet的原理

HashSet使用HashMap实现，新增元素相当于HashMap的key，value默认为一个固定的Object，当有元素插入的时候，会计算元素的hashCode值，将元素插入到哈希表对应的位置中来。

具有如下特点：
(1) 不允许出现重复因素
(2) 允许插入Null值
(3) 元素无序（添加顺序和遍历顺序不一致）
(4) 线程不安全，若2个线程同时操作HashSet，必须通过代码实现同步
HashSet默认容量为16，加载因子为0.75，扩容等基本操作与HashMap，只不过value为固定的。

10. Throws和Throw的区别

throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常抛给指定异常对象。
throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要跑出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句。

11. Collection 和 Collections 有什么区别

java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。
Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

12. java 中操作字符串都有哪些类？它们之间有什么区别？

操作字符串的类有：String、StringBuffer、StringBuilder。
String 和 StringBuffer、StringBuilder 的区别在于 String 声明的是不可变的对象，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象，而 StringBuffer、StringBuilder 可以在原有对象的基础上进行操作，所以在经常改变字符串内容的情况下最好不要使用 String。
StringBuffer 和 StringBuilder 最大的区别在于，StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的，但 StringBuilder 的性能却高于 StringBuffer，所以在单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。

13. String 类的常用方法

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

14. 普通类和抽象类有哪些区别

普通类不能包含抽象方法，抽象类可以包含抽象方法。
抽象类不能直接实例化，普通类可以直接实例化。

15. BIO、NIO、AIO 有什么区别

BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
NIO：New IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。

16. Files的常用方法都有哪些

Files.exists()：检测文件路径是否存在。
Files.createFile()：创建文件。
Files.createDirectory()：创建文件夹。
Files.delete()：删除一个文件或目录。
Files.copy()：复制文件。
Files.move()：移动文件。
Files.size()：查看文件个数。
Files.read()：读取文件。
Files.write()：写入文件。

17. 迭代器 Iterator 是什么

迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

18. Iterator 怎么使用？有什么特点？

Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。
注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。　
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

19. Iterator 和 ListIterator 有什么区别

Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。
ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等。

20. 四种内部类

成员内部类：即作为外部类的一个成员存在，与外部类的属性、方法并列。
注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员。
优点：
(1) 内部类作为外部类的成员，可以访问外部类的私有成员或属性。(即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的)
(2) 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。
局部内部类：即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。
注意：
(1) 局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。
(2) 在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。
静态内部类：定义在类中，任何方法外，用static定义。
注意：
(1) 静态内部类中可以定义静态或者非静态的成员。
(2) 生成(new)一个静态内部类不需要外部类成员，这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成。而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义。
(3) 当类与接口(或者是接口与接口)发生方法命名冲突的时候，此时必须使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。
匿名内部类：是一种特殊的局部内部类，它是通过匿名类实现接口。
特点：
(1) 一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
(2) 只是为了获得一个对象实例，不需要知道其实际类型。
(3) 类名没有意义，也就是不需要使用到。
注意：
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。因他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法，所以其使用范围非常的有限。当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
总结
(1)
a. 把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private，protected，默认(friendly)，public；
b. 它有类成员的修饰符: static，final，abstract。
(2)
a. 非静态内部类nested inner class，内部类隐含有一个外部类的指针this，因此，它可以访问外部类的一切资源(当然包括private)；
b. 外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级；
c. 非静态内部类不能包含任何static成员。
(3)
a. 静态内部类:static inner class，不再包含外部类的this指针，并且在外部类装载时初始化；
b. 静态内部类能包含static或非static成员；
c. 静态内部类只能访问外部类static成员；
d. 外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.成员即可访问，对于非static成员，只能用对象.成员进行访问。
(4)
a. 对于方法中的内部类或块中内部类只能访问块中或方法中的final变量；
b. 类成员有两种static，non-static，同样内部类也有这两种；
c. non-static 内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter))，并且可直接访问外部类的信息，外部类对象可通过OuterClassName.this来引用；
d. static 内部类的实例，直接创建即可，没有对外部类实例的引用；
e. 内部类不管static还是non-static都有对外部类的引用；
f. non-static 内部类不允许有static成员；
g. 方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没什么区别。但方法中的内部类不能在方法以外访问，方法中不可以有static内部类；
h. 匿名内部类如果继承自接口，必须实现指定接口的方法，且无参数；
i. 匿名内部类如果继承自类，参数必须按父类的构造函数的参数传递。

21. 三种排序方式

冒泡排序：
两两相比较，将较大值放在后面，每一次循环将最大的一个数值放在最后面：
java代码如下：

public class Test {
	public static void main(String[] args) {
		int [] array = {5,4,3,2,1};
		for (int i = 0; i < array.length-1; i++) { //控制循环次数，比长度少一次。
			for (int j = 0; j < array.length-i-1; j++) { //后面排好的值不需要进行比较，所以减去i。
				if(array[j]>array[j+1])
				{
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
	}
}

插入排序：
① 插入排序分为有序区和无序区。
② 将无序区的元素一一与有序区进行比较，进行排序。
java代码如下：

public class Test {
	public static void main(String[] args) {
		int[] array = { 5, 4, 3, 2, 1 };

		for (int i = 1; i < array.length; i++) { //无序区的元素。刚开始将第一个元素设置为有序区，从第二个元素开始插入。
			int score = array[i]; 
			int j = 0;
			for (; j < i; j++) { 
				if (array[j] > score) { //找到应该插入的位置。
					break;
				}
			}

			if (i == j) { //如果相同，则直接跳出循环，不必进行下面的for循环。
				continue;
			}

			for (int k = i; k > j; k--) { //将要插入位置后面的元素一一后移。
				array[k] = array[k - 1];
			}
			array[j] = score; //将插入元素放入应该插入的位置。
		}
	}
}

选择排序：
将第一个元素与后面每个一一比较，最小值放在最前面，然后将第二个元素与后面每个一一比较，然后第三个…
java代码如下：

public class Test {
	public static void main(String[] args) {
		int [] array= {5,4,3,2,1};
		for (int i = 0; i < array.length-1; i++) { //i为要比较的元素。
			for (int j = i+1; j < array.length; j++) { //i后的每一次元素。
				if(array[i]>array[j]) //两者比较，将较小值放在前面位置。
				{
					int temp = array[i];	
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
	}
}