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

以下是中高级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;  
}

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;  
}

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;  
}

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;  }  
}

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

public double averageArray(int[] nums) {  long sum = 0;  for (int num : nums) {  sum += num;  }  return (double) sum / nums.length;  
}

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];  }  
}

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

public int mostCommon(int[] nums) {  int[] count = new int[101];  for (int num : nums) {  count[num]++;  }  int max = 0;  int resfor (int i = 0; i < 101; i++) {    if (count[i] > max) {    max = count[i];    res = i;    }    }    return res;    
}

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;    
}

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

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

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;    
}

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);    
}

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();    
}

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];  
}

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

public class Singleton {  private static Singleton instance;private Singleton() {  }public static Singleton getInstance() {  if (instance == null) {  instance = new Singleton();  }  return instance;  }  
}

饿汉式：

public class Singleton {  private static final Singleton instance = new Singleton();private Singleton() {  }public static Singleton getInstance() {  return instance;  }  
}

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");  }  
}

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!");  }  }  }  
}

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");  }  }  
}

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();  }  
}

在这个示例中，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);  }  }  
}

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;  }  
}

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