国庆中秋特辑（七）Java软件工程师常见20道编程面试题

国庆中秋特辑系列文章：

国庆中秋特辑（八）Spring Boot项目如何使用JPA

国庆中秋特辑（七）Java软件工程师常见20道编程面试题

国庆中秋特辑（六）大学生常见30道宝藏编程面试题

国庆中秋特辑（五）MySQL如何性能调优？下篇

国庆中秋特辑（四）MySQL如何性能调优？上篇

国庆中秋特辑（三）使用生成对抗网络（GAN）生成具有节日氛围的画作，深度学习框架 TensorFlow 和 Keras 来实现

国庆中秋特辑（二）浪漫祝福方式 使用生成对抗网络（GAN）生成具有节日氛围的画作

国庆中秋特辑（一）浪漫祝福方式 用循环神经网络（RNN）或长短时记忆网络（LSTM）生成祝福诗词

以下是中高级Java软件工程师常见编程面试题，共有20道。

1. 如何判断一个数组是否为有序数组？
   答案：可以通过一次遍历，比较相邻元素的大小。如果发现相邻元素的大小顺序不对，则数组不是有序数组。

public boolean isSortedArray(int[] nums) {  
   for (int i = 0; i < nums.length - 1; i++) {  
       if (nums[i] > nums[i + 1]) {  
           return false;  
       }  
   }  
   return true;  
}
1
2
3
4
5
6
7
8

2. 如何删除一个有序数组中的重复元素？
   答案：可以通过一次遍历，将相邻的重复元素删除。

public int[] removeDuplicates(int[] nums) {  
   if (nums == null || nums.length == 0) {  
       return null;  
   }  
   int i = 0;  
   for (int j = 0; j < nums.length; j++) {  
       if (i == 0 || nums[j]!= nums[i]) {  
           nums[i++] = nums[j];  
       }  
   }  
   int[] result = new int[i];  
   System.arraycopy(nums, 0, result, 0, i);  
   return result;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 如何合并两个有序数组？
   答案：可以通过一次遍历，将两个有序数组合并成一个新的有序数组。

public int[] mergeTwoSortedArrays(int[] nums1, int[] nums2) {  
   int[] result = new int[nums1.length + nums2.length];  
   int i = 0, j = 0, k = 0;  
   while (i < nums1.length && j < nums2.length) {  
       if (nums1[i] < nums2[j]) {  
           result[k++] = nums1[i++];  
       } else {  
           result[k++] = nums2[j++];  
       }  
   }  
   while (i < nums1.length) {  
       result[k++] = nums1[i++];  
   }  
   while (j < nums2.length) {  
       result[k++] = nums2[j++];  
   }  
   return result;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4. 如何反转一个数组？
   答案：可以通过一次遍历，将数组的每个元素翻转。

public void reverseArray(int[] nums) {  
   for (int i = 0; i < nums.length; i++) {  
       int temp = nums[i];  
       nums[i] = nums[nums.length - 1 - i];  
       nums[nums.length - 1 - i] = temp;  
   }  
}
1
2
3
4
5
6
7

5. 如何计算一个数组的平均值？
   答案：将数组的所有元素相加，然后除以数组的长度。

public double averageArray(int[] nums) {  
   long sum = 0;  
   for (int num : nums) {  
       sum += num;  
   }  
   return (double) sum / nums.length;  
}
1
2
3
4
5
6
7

6. 如何计算一个数组的中位数？
   答案：将数组排序后，找到中间的元素。如果数组长度为偶数，则中间的两个元素的平均值是中位数。

public double medianArray(int[] nums) {  
   Arrays.sort(nums);  
   int length = nums.length;  
   if (length % 2 == 0) {  
       return (double) (nums[length / 2 - 1] + nums[length / 2]) / 2.0;  
   } else {  
       return (double) nums[length / 2];  
   }  
}
1
2
3
4
5
6
7
8
9

7. 如何计算一个数组的众数？
   答案：可以通过一次遍历，统计每个元素出现的次数。出现次数最多的元素是众数。

public int mostCommon(int[] nums) {  
   int[] count = new int[101];  
   for (int num : nums) {  
       count[num]++;  
   }  
   int max = 0;  
   int res

   for (int i = 0; i < 101; i++) {    
       if (count[i] > max) {    
           max = count[i];    
           res = i;    
       }    
   }    
   return res;    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8. 如何计算一个数组的方差？
   答案：将数组的所有元素相减后求平方，然后求和，最后除以数组的长度。

public double varianceArray(int[] nums) {    
   long sum = 0;    
   for (int num : nums) {    
       sum += num;    
   }    
   double mean = (double) sum / nums.length;    
   double sumSqr = 0;    
   for (int num : nums) {    
       double d = num - mean;    
       sumSqr += d * d;    
   }    
   return sumSqr / nums.length;    
}
1
2
3
4
5
6
7
8
9
10
11
12
13

9. 如何计算一个数组的标准差？
   答案：计算方差后，对方差开平方根。

public double standardDeviationArray(int[] nums) {    
   double variance = varianceArray(nums);    
   return Math.sqrt(variance);    
}
1
2
3
4

10. 如何判断一个字符串是否为回文字符串？
    答案：可以通过两次遍历，比较字符串的前半部分和后半部分是否相同。

public boolean isPalindrome(String s) {    
   int i = 0;    
   int j = s.length() - 1;    
   while (i < j) {    
       if (s.charAt(i)!= s.charAt(j)) {    
           return false;    
       }    
       i++;    
       j--;    
   }    
   return true;    
}
1
2
3
4
5
6
7
8
9
10
11
12

11. 如何删除一个字符串中的所有重复字符？
    答案：可以通过一次遍历，将字符串中的每个字符添加到一个新的字符数组中，如果字符数组中没有该字符，则将该字符添加到字符数组中。最后将字符数组转换为字符串。

public String removeDuplicates(String s) {    
   if (s == null || s.length() == 0) {    
       return null;    
   }    
   char[] chars = new char[s.length()];    
   for (int i = 0; i < s.length(); i++) {    
       if (chars[i]!= s.charAt(i)) {    
           chars[chars.length - 1] = s.charAt(i);    
       }    
   }    
   return new String(chars);    
}
1
2
3
4
5
6
7
8
9
10
11
12

12. 如何合并两个字符串？
    答案：可以通过一次遍历，将两个字符串中的字符合并到一个新的字符串中。

public String mergeStrings(String s1, String s2) {    
   if (s1 == null) {    
       return s2;    
   }    
   if (s2 == null) {    
       return s1;    
   }    
   StringBuilder sb = new StringBuilder();    
   for (int i = 0; i < Math.max(s1.length(), s2.length()); i++) {    
       char c1 = (i < s1.length())? s1.charAt(i) : '\0';    
       char c2 = (i < s2.length())? s2.charAt(i) : '\0';    
       sb.append(c1);    
       sb.append(c2);    
   }    
   return sb.toString();    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

13. 如何计算两个字符串的编辑距离？
    答案：可以通过动态规划的方法，计算将一个字符串转换为另一个字符串所需的最少操作次数。

public int editDistance(String s1, String s2) {  
   int m = s1.length();  
   int n = s2.length();  
   int[][] dp = new int[m + 1][n + 1];
   for (int i = 0; i <= m; i++) {  
       for (int j = 0; j <= n; j++) {  
           if (i == 0) {  
               dp[i][j] = j;  
           } else if (j == 0) {  
               dp[i][j] = i;  
           } else if (s1.charAt(i - 1) == s2.charAt(j - 1)) {  
               dp[i][j] = dp[i - 1][j - 1];  
           } else {  
               dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1;  
           }  
       }  
   }  
   return dp[m][n];  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

14. 如何实现一个单例模式？
    答案：可以使用懒汉式和饿汉式实现单例模式。
    懒汉式：

public class Singleton {  
   private static Singleton instance;
   private Singleton() {  
   }
   public static Singleton getInstance() {  
       if (instance == null) {  
           instance = new Singleton();  
       }  
       return instance;  
   }  
}
1
2
3
4
5
6
7
8
9
10
11

饿汉式：

public class Singleton {  
   private static final Singleton instance = new Singleton();
   private Singleton() {  
   }
   public static Singleton getInstance() {  
       return instance;  
   }  
}
1
2
3
4
5
6
7
8

15. 如何实现一个工厂模式？
    答案：创建一个工厂类，根据传入的参数创建相应的对象。

public class Factory {  
   public static void main(String[] args) {  
       Product productA = factory.createProductA();  
       Product productB = factory.createProductB();
       productA.display();  
       productB.display();  
   }
   public static Product createProductA() {  
       return new ProductA();  
   }
   public static Product createProductB() {  
       return new ProductB();  
   }  
}
abstract class Product {  
   public abstract void display();  
}
class ProductA extends Product {  
   public void display() {  
       System.out.println("Product A");  
   }  
}
class ProductB extends Product {  
   public void display() {  
       System.out.println("Product B");  
   }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

16. 如何实现一个观察者模式？
    答案：创建一个观察者接口，一个主题接口，以及具体的观察者和主题类。当主题状态发生变化时，通知所有观察者。

public class ObserverPattern {  
   public static void main(String[] args) {  
       Subject subject = new Subject();  
       Observer observer1 = new ConcreteObserver(subject);  
       Observer observer2 = new ConcreteObserver(subject);
       subject.addObserver(observer1);  
       subject.addObserver(observer2);
       subject.notifyObservers();  
   }
   public static interface Subject {  
       void addObserver(Observer observer);  
       void removeObserver(Observer observer);  
       void notifyObservers();  
   }
   public static interface Observer {  
       void update(String message);  
   }
   public static class ConcreteObserver implements Observer {  
       private Subject subject;
       public ConcreteObserver(Subject subject) {  
           this.subject = subject;  
       }
       @Override  
       public void update(String message) {  
           System.out.println("Received: " + message);  
       }  
   }
   public static class ConcreteSubject implements Subject {  
       private List<Observer> observers;
       public ConcreteSubject() {  
           observers = new ArrayList<>();  
       }
       @Override  
       public void addObserver(Observer observer) {  
           observers.add(observer);  
       }
       @Override  
       public void removeObserver(Observer observer) {  
           observers.remove(observer);  
       }
       @Override  
       public void notifyObservers() {  
           for (Observer observer : observers) {  
               observer.update("Hello, World!");  
           }  
       }  
   }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

17. 如何实现一个策略模式？
    答案：创建一个策略接口，以及具体的策略类。在运行时，根据不同的情况选择相应的策略来执行。

public class StrategyPattern {  
   public static void main(String[] args) {  
       Strategy strategy = new DefaultStrategy();  
       strategy.execute();
       strategy = new CustomStrategy();  
       strategy.execute();  
   }
   public static interface Strategy {  
       void execute();  
   }
   public static class DefaultStrategy implements Strategy {  
       @Override  
       public void execute() {  
           System.out.println("Default strategy");  
       }  
   }
   public static class CustomStrategy implements Strategy {  
       @Override  
       public void execute() {  
           System.out.println("Custom strategy");  
       }  
   }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

18. 如何实现一个适配器模式？

实现适配器模式需要以下几个步骤：

1. 确定目标接口：首先需要明确要适配的目标接口，即客户端期望使用的接口。这个接口可以是一个现有的接口，也可以是一个抽象的接口。
2. 创建适配器类：创建一个适配器类，该类将实现目标接口，并在其内部包含一个被适配的类的实例。适配器类需要实现目标接口的所有方法，并在这些方法中调用被适配的类的相应方法。
3. 实现目标接口：在适配器类中实现目标接口的所有方法，这些方法将被客户端使用。在实现这些方法时，需要将客户端传入的参数传递给被适配的类的相应方法，并将被适配的类的方法返回的结果返回给客户端。
   下面是一个简单的适配器模式实现示例：

// 目标接口  
public interface Target {  
   void request();  
}
// 被适配的类  
public class Adaptee {  
   public void specificRequest() {  
       System.out.println("被适配的类的方法被调用");  
   }  
}
// 适配器类  
public class Adapter implements Target {  
   private Adaptee adaptee;
   public Adapter(Adaptee adaptee) {  
       this.adaptee = adaptee;  
   }
   @Override  
   public void request() {  
       adaptee.specificRequest();  
   }  
}
// 客户端代码  
public class Client {  
   public static void main(String[] args) {  
       Adaptee adaptee = new Adaptee();  
       Target target = new Adapter(adaptee);  
       target.request();  
   }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在这个示例中，Target 是目标接口，Adaptee 是被适配的类，Adapter 是适配器类。适配器类 Adapter 实现了目标接口 Target，并在其 request() 方法中调用了被适配的类 Adaptee 的 specificRequest() 方法。客户端代码通过目标接口 Target 使用适配器类 Adapter，实现了对被适配的类 Adaptee 的调用。

19. 题目：汉诺塔问题
    问题描述：请用 Java 实现一个解决方案，解决汉诺塔问题。汉诺塔是一个经典的递归问题，要求将一个杆子上的 N 个圆盘按照一定的规则从一边移动到另一边。
    答案：以下是一个 Java 实现汉诺塔问题的示例代码：

public class HanoiTower {  
   public static void main(String[] args) {  
       int n = 3; // 设置盘子的数量  
       hanoi(n, 'A', 'B', 'C');  
   }
   /**  
    * 汉诺塔递归方法  
    * @param n 盘子数量  
    * @param from 源柱子  
    * @param auxiliary 辅助柱子  
    * @param to 目标柱子  
    */  
   public static void hanoi(int n, char from, char auxiliary, char to) {  
       if (n == 1) { // 当只有一个盘子时，直接从源柱子移动到目标柱子  
           System.out.println("Move disk 1 from " + from + " to " + to);  
       } else {  
           // 将 n-1 个盘子从源柱子借助目标柱子移动到辅助柱子  
           hanoi(n - 1, from, to, auxiliary);  
           // 将第 n 个盘子从源柱子移动到目标柱子  
           System.out.println("Move disk " + n + " from " + from + " to " + to);  
           // 将 n-1 个盘子从辅助柱子借助源柱子移动到目标柱子  
           hanoi(n - 1, auxiliary, from, to);  
       }  
   }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

20. 题目：购物车类
    问题描述：请设计一个购物车类，包含添加商品、删除商品、计算总价等功能。
    答案：以下是一个简单的购物车类实现：

public class ShoppingCart {  
   private ArrayList<Item> items;
   public ShoppingCart() {  
       items = new ArrayList<>();  
   }
   /**  
    * 向购物车添加商品  
    * @param item 商品对象  
    */  
   public void addItem(Item item) {  
       for (int i = 0; i < items.size(); i++) {  
           if (items.get(i) == item) {  
               items.set(i, item);  
               return;  
           }  
       }  
       items.add(item);  
   }
   /**  
    * 从购物车中删除商品  
    * @param item 商品对象  
    * @return 是否成功删除  
    */  
   public boolean removeItem(Item item) {  
       for (int i = 0; i < items.size(); i++) {  
           if (items.get(i) == item) {  
               items.remove(i);  
               return true;  
           }  
       }  
       return false;  
   }
   /**  
    * 计算购物车中商品的总价  
    * @return 总价  
    */  
   public double calculateTotal() {  
       double total = 0;  
       for (Item item : items) {  
           total += item.getPrice();  
       }  
       return total;  
   }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

购物车类使用一个 ArrayList 来存储商品对象。添加商品、删除商品和计算总价的方法分别遍历 ArrayList 来完成相应操作。