来源：Dev.to 各位开发人员大家好，我整理了一份每个程序员都应该知道的基本 Java 面试问题列表。
![Java-университет]()
1. 如何在Java中不使用reverse()方法来反转字符串？
答： Java中没有标准的reverse()方法，尽管reverse()方法存在于多个库中，例如StringBuffer或StringBuilder。因此，面试中经常会遇到数组反转的问题。下面是一个可用于反转数组的简单算法。public class StringReverse {
public static void main(String[] args) {
String str = "Flexiple";
System.out.println(reverse(str));
}
public static String reverse(String in) {
if (in == null)
throw new IllegalArgumentException("Null is not valid");
StringBuilder out = new StringBuilder();
char[] chars = in.toCharArray();
for (int i = chars.length - 1; i >= 0; i--)
out.append(chars[i]);
return out.toString();
}
}2.编写代码片段，使用递归实现斐波那契数列
答案：下面的代码片段使用递归实现了斐波那契数列。这个问题在Java面试中也很常见。public class FibonacciNumbers {
public static int fibonacci(int n) {
if (n <= 1)
return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
public static void main(String args[]) {
int n = 10;
System.out.println(fibonacci(n));
}
}3. Java中如何删除字符串中的空格？
答案：strip()方法是一个字符串方法，用于删除所有前导和尾随空格。Strip()在内部使用Character.isWhitespace()方法来检查空格。它使用 Unicode 字符检测空格，并且是删除空格的推荐方法。也可以使用替代方法stripLeading()和stripTrailing()。如果您只想分别删除前导空格或尾随空格，它们将有所帮助。下面的代码是使用strip()方法的示例。String s = " flexiple ";
s = s.strip();
System.out.println(s);4. 什么原因导致死锁场景？编写代码造成死锁
答：当两个线程需要相同的锁来执行时，就会出现死锁情况。当两个线程都已获取一个锁并正在等待获取另一锁时，就会发生这些情况。但是，由于两个线程都在等待对方执行，因此它们会互相阻塞，从而导致死锁。多线程程序会遇到死锁，因为使用了synchronized关键字来使方法线程安全。这意味着只有一个线程可以阻塞并使用同步方法。其他线程必须等待当前线程完成。下面的代码创建了两个死锁的线程。class Util
{
static void sleep(long millis)
{
try
{
Thread.sleep(millis);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
class Shared
{
synchronized void test1(Shared s2)
{
System.out.println("test1-begin");
Util.sleep(1000);
s2.test2();
System.out.println("test1-end");
}
synchronized void test2()
{
System.out.println("test2-begin");
Util.sleep(1000);
System.out.println("test2-end");
}
}
class Thread1 extends Thread
{
private Shared s1;
private Shared s2;
public Thread1(Shared s1, Shared s2)
{
this.s1 = s1;
this.s2 = s2;
}
@Override
public void run()
{
s1.test1(s2);
}
}
class Thread2 extends Thread
{
private Shared s1;
private Shared s2;
public Thread2(Shared s1, Shared s2)
{
this.s1 = s1;
this.s2 = s2;
}
@Override
public void run()
{
s2.test2(s1);
}
}
public class Deadlock
{
public static void main(String[] args)
{
Shared s1 = new Shared();
Shared s2 = new Shared();
Thread1 t1 = new Thread1(s1, s2);
t1.start();
Thread2 t2 = new Thread2(s1, s2);
t2.start();
Util.sleep(2000);
}
}5.编写Java代码以特定格式打印日期
答案：SimpleDateFormat类有助于将日期从一种格式转换为另一种格式。此方法还允许用户使用日期字符串格式并将其更改为所需的格式。下面的代码将日期转换为标准格式：DD/MM/YYYYimport java.text.SimpleDateFormat;
import java.util.Date;
public class CurrentDateTimeExample2 {
public static void main(String[] args) {
SimpleDateFormat formatter = new SimpleDateFormat("DD/MM/YYYY HH:mm:ss");
Date date = new Date();
System.out.println(formatter.format(date));
}
}import java.text.SimpleDateFormat;
import java.util.Date;
public class CurrentDateTimeExample2 {
public static void main(String[] args) {
SimpleDateFormat formatter = new SimpleDateFormat("MM/DD/YYYY HH:mm:ss");
Date date = new Date();
System.out.println(formatter.format(date));
}
}
6. 如何根据 HashMap 的值对 HashMap 进行排序？
答： HashMap用于实现map接口。它们允许用户存储键值对，但键必须是唯一的。 HashMap不是有序集合，对它们进行排序没有意义，但由于对 hashmap 进行排序可能相当棘手，因此它们是 Java 面试中的常见问题。下面的代码显示了HashMap的实现。import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class SortHashMap {
public static void main(String[] args) {
Map scores = new HashMap<>();
scores.put("John", 6);
scores.put("Carol", 8);
scores.put("Martin", 9);
scores.put("Mona", 7);
scores.put("Eric", 5);
System.out.println(scores);
scores = sortByValue(scores);
System.out.println(scores);
}
private static Map sortByValue(Map scores) {
Map sorted = new LinkedHashMap<>();
Set> entrySet = scores.entrySet();
System.out.println(entrySet);
List> entryList = new ArrayList<>(entrySet);
System.out.println(entryList);
entryList.sort((x, y) -> x.getValue().compareTo(y.getValue()));
System.out.println(entryList);
for (Entry e : entryList)
sorted.put(e.getKey(), e.getValue());
return sorted;
}
}7. forEach() 方法的作用是什么？举例说明
Ans： forEach()是Java中用于迭代对象的方法。但与其他循环不同的是，这里的循环计数器没有声明或初始化，而是将变量作为可迭代对象传递。因此，forEach()通常与数组或集合类一起使用。句法：for (type var : array)
{
statements using var;
}class ExampleForEach
{
public static void main(String[] arg)
{
{
int[] scores = { 10, 13, 9, 11, 11};
int highest_score = maximum(scores);
System.out.println(highest_scores);
}
}
public static int maximum(int[] numbers)
{
int max = numbers[0];
// for each loop
for (int n : numbers)
{
if (n > max)
{
max = n;
}
}
return max;
}
}8. 什么是函数式接口以及它们是如何创建的？
答：仅包含一个抽象方法的接口称为函数式接口。因此，函数式接口只能有一个函数，但可以包含多个默认方法。在 Java 8 中，lambda 表达式可用于实例化函数式接口，使事情变得更加容易。函数式接口的示例：ActionListener、Comparable。这是用于定义功能接口的代码。@FunctionalInterface
interface Foo {
void test();
}9.举例描述重载
答：重载是解析具有相同名称但根据其签名、数据类型或参数数量而不同的多个方法的过程。重载允许用户重用单个方法，而不是创建和记住多个方法。简而言之，重载与编译时多态性有关。方法重载示例代码：public class Sum {
public int sum(int x, int y)
{
return (x + y);
}
public int sum(int x, int y, int z)
{
return (x + y + z);
}
public double sum(double x, double y)
{
return (x + y);
}
public static void main(String args[])
{
Sum s = new Sum();
System.out.println(s.sum(10, 20));
System.out.println(s.sum(10, 20, 30));
System.out.println(s.sum(10.5, 20.5));
}
}10.通过示例描述覆盖
Ans：重写是Java中的一项功能，它允许子类或子类为父类中的现有方法提供单独的实现。当子类中的方法与父类中的方法具有相同的名称、参数和返回类型时，该方法将覆盖父类中的方法。并且被调用方法的版本决定了将执行哪个方法。重写是一种在运行时实现多态性的方法。方法覆盖代码示例：class Parent {
void show()
{
System.out.println("Parent's show()");
}
}
class Child extends Parent {
@Override
void show()
{
System.out.println("Child's show()");
}
}
class Main {
public static void main(String[] args)
{
Parent obj1 = new Parent();
obj1.show();
Parent obj2 = new Child();
obj2.show();
}
}11.什么是二分查找？这是如何实施的？
答案：二分查找算法用于在排序数组或集合类型中查找值。这种搜索方法比线性搜索方法要快得多。二分查找将数组分成更小的集合，然后应用规则来检查输入键。 实现二分（binary）搜索的阶段：- 按升序对数组进行排序。
- 找到数组的平均值并将其与键进行比较。
- 如果键等于平均值，则返回 true。
- 如果为 false，则检查键是否大于或小于平均值。
- 接下来，根据结果，分别检查上半部分或下半部分的密钥。
- 迭代每个值并将其与键进行比较。
import java.util.Scanner;
public class BinarySearch {
public static void main(String[] args) {
Scanner commandReader = new Scanner(System.in);
System.out.println("Enter total number of elements : ");
int length = commandReader.nextInt();
int[] input = new int[length];
System.out.printf("Enter %d integers %n", length);
for (int i = 0; i < length; i++) {
input[i] = commandReader.nextInt();
}
System.out.println("Please enter number to be searched in array
(sorted order)");
int key = commandReader.nextInt();
int index = performBinarySearch(input, key);
if (index == -1) {
System.out.printf("Sorry, %d is not found in array %n", key);
} else {
System.out.printf("%d is found in array at index %d %n", key,
index);
}
commandReader.close();
}
public static int performBinarySearch(int[] input, int number) {
int low = 0;
int high = input.length - 1;
while (high >= low) {
int middle = (low + high) / 2;
if (input[middle] == number) {
return middle;
} else if (input[middle] < number) {
low = middle + 1;
} else if (input[middle] > number) {
high = middle - 1;
}
}
return -1;
}
}12. Java中防止死锁的最佳方法是什么？
回答：- 嵌套锁：死锁的主要原因是将锁传递给多个线程。如果已存在具有阻塞的线程，则避免阻塞多个线程有助于防止死锁。
- 使用Thread.join()：当一个线程等待另一个线程的资源时，也可能会发生死锁。但是，在这种情况下，可以使用Thread.join()来实现最大执行时间。
- 仅在必要时使用锁定：练习仅在必要时对元素使用锁。不必要的锁是死锁的主要原因。
13、编写Java实现LRU缓存的代码
答： LRU 代表最少使用的缓存。LRU缓存方案用于删除最后使用的缓存。当现有缓存已满并且被引用的新页面不在现有缓存中时，会发生此过程。下面的代码展示了实现：import java.util.Deque;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Iterator;
public class LRUCache {
private Deque doublyQueue;
private HashSet hashSet;
private final int CACHE_SIZE;
LRUCache(int capacity) {
doublyQueue = new LinkedList<>();
hashSet = new HashSet<>();
CACHE_SIZE = capacity;
}
public void refer(int page) {
if (!hashSet.contains(page)) {
if (doublyQueue.size() == CACHE_SIZE) {
int last = doublyQueue.removeLast();
hashSet.remove(last);
}
}
else {/* The found page may not be always the last element, even if it's an
intermediate element that needs to be removed and added to the start
of the Queue */
doublyQueue.remove(page);
}
doublyQueue.push(page);
hashSet.add(page);
}
public void display() {
Iterator itr = doublyQueue.iterator();
while (itr.hasNext()) {
System.out.print(itr.next() + " ");
}
}
public static void main(String[] args) {
LRUCache cache = new LRUCache(4);
cache.refer(1);
cache.refer(2);
cache.refer(3);
cache.refer(1);
cache.refer(4);
cache.refer(5);
cache.refer(2);
cache.refer(2);
cache.refer(1);
cache.display();
}
}14. 数组如何根据 K 的位置进行旋转，例如 k = 2？
答案：代码片段根据指定的位置旋转（返回）数组。虽然看起来很简单，但它考验的是你对循环和数组的理解，因此是 Java 面试中的常见问题。public static int[] rotateBruteForce(int[] nums, int k) {
for (int i = 0; i < k; i++) {
for (int j = nums.length - 1; j > 0; j--) {
// move each number by 1 place
int temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
}
System.out.println("Array rotation after "+(i+1)+" step");
printArray(nums);
System.out.println();
}
return nums;
}15.Java中的队列是什么？使用数组来实现它们。
答：队列是线性结构，以先到先服务的方式展示操作顺序。Java 确实为队列、堆栈等抽象数据类型提供了更简单的实现。然而，使用数组实现它们是一个考验你对这个概念的理解的问题。请记住，队列的数组实现不是动态的。package org.arpit.java2blog;
public class QueueUsingArrayMain {
private int capacity;
int queueArr[];
int front;
int rear;
int currentSize = 0;
public QueueUsingArrayMain(int sizeOfQueue) {
this.capacity = sizeOfQueue;
front = 0;
rear = -1;
queueArr = new int[this.capacity];
}16.什么是堆排序？编写代码来实现它
答： HeapSort是一种基于二叉堆数据结构的排序方法。二叉堆是一棵二叉树，其中元素的存储方式是父节点中的值大于（最大堆）或小于（最小堆）子节点中的值。实现HeapSort的代码如下所示：public class HeapSort {
public void sort(int arr[])
{
int n = arr.length;
// Build heap (rearrange array)
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
// One by one extract an element from heap
for (int i = n - 1; i > 0; i--) {
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// call max heapify on the reduced heap
heapify(arr, i, 0);
}
}
// To heapify a subtree rooted with node i which is
// an index in arr[]. n is size of heap
void heapify(int arr[], int n, int i)
{
int largest = i; // Initialize largest as root
int l = 2 * i + 1; // left = 2*i + 1
int r = 2 * i + 2; // right = 2*i + 2
// If left child is larger than root
if (l < n && arr[l] > arr[largest])
largest = l;
// If right child is larger than largest so far
if (r < n && arr[r] > arr[largest])
largest = r;
// If largest is not root
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
// Recursively heapify the affected sub-tree
heapify(arr, n, largest);
}
}
/* A utility function to print array of size n */
static void printArray(int arr[])
{
int n = arr.length;
for (int i = 0; i < n; ++i)
System.out.print(arr[i] + " ");
System.out.println();
}
// Driver code
public static void main(String args[])
{
int arr[] = { 12, 11, 13, 5, 6, 7 };
int n = arr.length;
HeapSort ob = new HeapSort();
ob.sort(arr);
System.out.println("Sorted array is");
printArray(arr);
}
}17. 什么是记忆化？
答：记忆化是一种有助于解决动态规划引起的问题的方法。此过程确保不会对同一输入多次执行给定方法。返回值存储在哈希表或哈希映射中，并根据需要重用。下面的代码是斐波那契数列记忆的示例。import java.io.*;
class GFG
{
// Fibonacci Series
// using Recursion
static int fib(int n)
{
// Base case
if (n <= 1)
return n;
// recursive calls
return fib(n - 1) +
fib(n - 2);
}
// Driver Code
public static void main (String[] args)
{
int n = 6;
System.out.println(fib(n));
}
}18.编写一段代码实现冒泡排序
答：下面的代码是冒泡排序的解决方案，这也是Java面试中的常见问题。public class BubbleSortExample {
static void bubbleSort(int[] arr) {
int n = arr.length;
int temp = 0;
for(int i=0; i < n; i++){
for(int j=1; j < (n-i); j++){
if(arr[j-1] > arr[j]){
//swap elements
temp = arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
}
}
}
public static void main(String[] args) {
int arr[] ={3,60,35,2,45,320,5};
System.out.println("Array Before Bubble Sort");
for(int i=0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
bubbleSort(arr);//sorting array elements using bubble sort
System.out.println("Array After Bubble Sort");
for(int i=0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
}
}19. Java中的trie数据结构是什么？
Ans： Trie 是一种使用存储键将数据存储在有序树结构中的数据结构。节点在树中的位置决定了与该节点关联的键，并且该节点的后代共享一个公共前缀。由于这种结构，尝试提供了更好的性能并且更快地检索数据。然而，使用木材的唯一缺点是它需要更多的存储空间。20.编写一段代码将HashMap转换为ArrayList
答：下面的代码用于将HashMap转换为ArrayList。import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Java8MapToListExamples
{
public static void main(String[] args)
{
//Creating a HashMap object
HashMap studentPerformanceMap = new HashMap();
//Adding elements to HashMap
studentPerformanceMap.put("John Kevin", "Average");
studentPerformanceMap.put("Rakesh Sharma", "Good");
studentPerformanceMap.put("Prachi D", "Very Good");
studentPerformanceMap.put("Ivan Jose", "Very Bad");
studentPerformanceMap.put("Smith Jacob", "Very Good");
studentPerformanceMap.put("Anjali N", "Bad");
//Getting Set of keys
Set keySet = studentPerformanceMap.keySet();
//Creating an ArrayList of keys
ArrayList listOfKeys = new ArrayList(keySet);
System.out.println("ArrayList Of Keys :");
for (String key : listOfKeys)
{
System.out.println(key);
}
System.out.println("--------------------------");
//Getting Collection of values
Collection values = studentPerformanceMap.values();
//Creating an ArrayList of values
ArrayList listOfValues = new ArrayList(values);
System.out.println("ArrayList Of Values :");
for (String value : listOfValues)
{
System.out.println(value);
}
System.out.println("--------------------------");
//Getting the Set of entries
Set> entrySet = studentPerformanceMap.entrySet();
//Creating an ArrayList Of Entry objects
ArrayList> listOfEntry = new ArrayList>(entrySet);
System.out.println("ArrayList of Key-Values :");
for (Entry entry : listOfEntry)
{
System.out.println(entry.getKey()+" : "+entry.getValue());
}
}
}
GO TO FULL VERSION